sqlx-code-review
/sqlx-code-review
Reviews sqlx database code for compile-time query checking, connection pool management, migration patterns, and PostgreSQL-specific usage. Use when reviewing Rust code that uses sqlx, database queries, connection pools, or migrations. Covers offline mode, type mapping, and transaction patterns.
- Author
- existential-birds ↗
- Repository
- beagle ↗
- Licence
- Apache-2.0
- Last repository change
- 09.08.2026
Assessment and security
- Files in this package
- 3
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 09.08.2026, without references to retired models or APIs.
Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.
What it does and when to use it
Reviews sqlx database code for compile-time query checking, connection pool management, migration patterns, and PostgreSQL-specific usage. Use when reviewing Rust code that uses sqlx, database queries, connection pools, or migrations. Covers offline mode, type mapping, and transaction patterns.
Original author description
Reviews sqlx database code for compile-time query checking, connection pool management, migration patterns, and PostgreSQL-specific usage. Use when reviewing Rust code that uses sqlx, database queries, connection pools, or migrations. Covers offline mode, type mapping, and transaction patterns.
How it works
- Review Workflow
- Gates (evidence before severity)
- Output Format
- Quick Reference
- Review Checklist
- Severity Calibration
- Valid Patterns (Do NOT Flag)
- Before Submitting Findings
SKILL.md preview
--- name: sqlx-code-review description: Reviews sqlx database code for compile-time query checking, connection pool management, migration patterns, and PostgreSQL-specific usage. Use when reviewing Rust code that uses sqlx, database queries, connection pools, or migrations. Covers offline mode, type mapping, and transaction patterns. --- # sqlx Code Review ## Review Workflow 1. **Check Cargo.toml** — Note sqlx features (`runtime-tokio`, `tls-rustls`/`tls-native-tls`, `postgres`/`mysql`/`sqlite`, `uuid`, `chrono`, `json`, `migrate`) and Rust edition (2024 changes RPIT lifetime capture and removes need for `async-trait`) 2. **Check query patterns** — Compile-time checked (`query!`, `query_as!`) vs runtime (`query`, `query_as`) 3. **Check pool configuration** — Connection limits, timeouts, idle settings 4. **Check migrations** — File naming, reversibility, data migration safety 5. **Check type mappings** — Rust types align with SQL column types ## Gates (evidence before severity) Complete in order; do not assign **Critical** / **Major** until the gate for that claim is passed. 1. **Scope** — Identify the crate under review (`Cargo.toml` path) and the `.rs` files (or directory) you opened. **Pass:** At least one concrete path you inspected is named. 2. **sqlx / compile claims** — Before asserting issues about `query!` / `query_as!`, offline mode, `sqlx.toml`, `DATABASE_URL`, or Cargo features: open the relevant `Cargo.toml` and, if applicable, `sqlx.toml` or documented env. **Pass:** The finding cites a line or you state that those files were absent / out of scope. 3. **Finding anchors** — Each reported issue includes `[FILE:LINE]` per **Output Format**. **Pass:** No Critical or Major without a line reference. 4. **Protocol** — Load and complete the [review-verification-protocol](../review-verification-protocol/SKILL.md) skill **after** gates 1–3 and **before** final severity labels. **Pass:** Protocol steps satisfied for each retained finding. ## Output Format Report findings as: ```text [FILE:LINE] ISSUE_TITLE Severity: Critical | Major | Minor | Informational Description of the issue and why it matters. ``` ## Quick Reference | Issue Type | Reference | |------------|-----------| | Query macros, bind parameters, result mapping | [references/queries.md](references/queries.md) | | Migrations, pool config, transaction patterns | [references/migrations.md](references/migrations.md) | ## Review Checklist ### Query Patterns - [ ] Compile-time checked queries (`query!`, `query_as!`) used where possible - [ ] `sqlx.toml` or `DATABASE_URL` configured for offline compile-time checking - [ ] No string interpolation in queries (SQL injection risk) — use bind parameters (`$1`, `$2`) - [ ] `query_as!` maps to named structs, not anonymous records, for public APIs - [ ] `.fetch_one()`, `.fetch_optional()`, `.fetch_all()` chosen appropriately - [ ] `.fetch()` (streaming) used for large result sets ### Connection Pool - [ ] `PgPool` shared via `Arc` or framework state (not created per-request) - [ ] Pool size configured for the deployment (not left at defaults in production) - [ ] Connection acquisition timeout set - [ ] Idle connection cleanup configured - [ ] **Edition 2024**: Pool initialization uses `std::sync::LazyLock` (not `once_cell::sync::Lazy` or `lazy_static!`) for static pool singletons ### Transactions - [ ] `pool.begin()` used for multi-statement operations - [ ] Transaction committed explicitly (not relying on implicit rollback on drop) - [ ] Errors within transactions trigger rollback before propagation - [ ] Nested transactions use savepoints (`tx.begin()`) if needed ### Type Mapping - [ ] `sqlx::Type` derives match database column types - [ ] Enum representations consistent between Rust, serde, and SQL - [ ] `Uuid`, `DateTime<Utc>`, `Decimal` types used (not strings for structured data) - [ ] `Option<T>` used for nullable columns - [ ] `serde_json::Value` used for JSONB columns - [ ] No enum variants or struct fields named `gen` — reserved keyword in edition 2024 (use `r#gen` with `#[sqlx(rename = "gen")]` or choose a different name) ### Edition 2024 Compatibility - [ ] Functions returning `-> impl Stream` or `-> impl Future` account for RPIT lifetime capture changes (all in-scope lifetimes captured by default; use `+ use<'a>` for precise control) - [ ] Custom `FromRow` or `Type` trait impls use native `async fn` in traits where applicable (no `#[async_trait]` needed, stable since Rust 1.75) - [ ] Prefer `#[expect(unused)]` over `#[allow(unused)]` for compile-time query fields only used in some code paths (self-cleaning lint suppression, stable since 1.81) - [ ] Static pool initialization uses `std::sync::LazyLock` (not `once_cell` or `lazy_static!`) ### Migrations - [ ] Migration files follow naming convention (`YYYYMMDDHHMMSS_description.sql`) - [ ] Destructive migrations (DROP, ALTER DROP COLUMN) are reversible or have data backup plan - [ ] No data-dependent schema changes in same migration as data changes - [ ] `sqlx::migrate!()` called at application startup ## Severity Calibration ### Critical - String interpolation in SQL queries (SQL injection) - Missing transaction for multi-statement writes (partial writes on error) - Connection pool created per-request (connection exhaustion) - Missing bind parameter escaping ### Major - Runtime queries (`query()`) where compile-time (`query!()`) could verify correctness - Missing transaction rollback on error paths - Enum type mismatch between Rust and database - Unbounded `.fetch_all()` on potentially large tables - Field or variant named `gen` without `r#gen` escape (edition 2024 compile failure) ### Minor - Pool defaults used in production without tuning - Missing `.fetch_optional()` (using `.fetch_one()` then handling error for "not found") - Overly broad `SELECT *` when only specific columns needed - Missing indexes for queried columns (flag only if query pattern is clearly slow) - **Edition 2024**: `once_cell::sync::Lazy` or `lazy_static!` used where `std::sync::LazyLock` works - Using `#[allow(unused)]` instead of `#[expect(unused)]` for query fields (prefer self-cleaning lint suppression) ### Informational - Suggestions to use `query_as!` for type-safe result mapping - Suggestions to add database-level constraints alongside Rust validation - Migration organization improvements ## Valid Patterns (Do NOT Flag) - **Runtime `query()` for dynamic queries** — Compile-time checking doesn't work with dynamic SQL - **`sqlx::FromRow` derive** — Valid alternative to `query_as!` for reusable row types - **`TEXT` columns for enum storage** — Valid with `sqlx::Type` derive, simpler than custom SQL types - **`.execute()` ignoring row count** — Acceptable for idempotent operations (upserts, deletes) - **Shared DB with other languages** — e.g., Elixir owns migrations, Rust reads. This is a valid architecture. - **`r#gen` with `#[sqlx(rename = "gen")]`** — Correct edition 2024 workaround for `gen` columns in database types - **`+ use<'a>` on query helper return types** — Precise RPIT lifetime capture (edition 2024) - **`std::sync::LazyLock` for static pool initialization** — Replaces `once_cell`/`lazy_static` (stable since Rust 1.80) - **Native `async fn` in custom `FromRow`/`Type` trait impls** — `async-trait` crate no longer needed (stable since Rust 1.75) ## Before Submitting Findings Complete **Gates (evidence before severity)**, then load and follow the [review-verification-protocol](../review-verification-protocol/SKILL.md) skill before reporting any issue.
Files in this package (3)
- SKILL.md 7 KB
- references/migrations.md 5 KB
- references/queries.md 7 KB
Versions
The database has no other skills named sqlx-code-review.
Database snapshot: 13.11.2026 · package version 74e5ecb5d67e (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 90rc-sqlx
Implements and reviews SQLx 0.8+ with PostgreSQL in Rust — PgPool, query/query_as, bind parameters, transactions, migrations, compile-time macros, database tests. Use when writing or changing SQLx/Postgres access from Rust. Do not use for Axum routing alone (rc-axum), SvelteKit… - 100rust-database
Design, implement, migrate, test, and operate Rust database access, including SQLx, Diesel, SeaORM, schema evolution, transaction boundaries, connection pools, retries, type mapping, concurrency control, and real-database verification. Use when users ask about Rust SQL or ORM… - 100update-sqlx
How to safely update SQLx offline query cache. MUST use when SQL queries change. - 90rs-domain-data
Use when working with databases, caches or analytics stores from Rust — choosing sqlx/diesel/sea-orm, connection pools, transactions, migrations, query performance, N+1, pagination, caching patterns (cache-aside, write-through, TTL, invalidation, stampede), Redis, ClickHouse,… - 100golang-database
Comprehensive guide for Go database access — parameterized queries, struct scanning, NULLable columns, transactions, isolation levels, SELECT FOR UPDATE, connection pool, batch processing, context propagation, and migration tooling. Use when writing, reviewing, or debugging… - 100go-data-persistence
Data persistence patterns in Go covering raw SQL with sqlx/pgx, ORMs like Ent and GORM, connection pooling, migrations with golang-migrate, and transaction management. Use when implementing database access, designing repositories, or managing schema migrations.