Module model 

Available on crate features model-mysql or model-postgres or model-sqlite only.

Model — Async Database Access Layer

An async JPA/Hibernate-style ORM backed by sqlx. Provides:

• #[derive(Model)] proc-macro for struct-to-table mapping
• Repository<T, i64> trait for zero-boilerplate async CRUD
• QueryBuilder<T> for fluent async filtering
• DbPool for connection management (wraps sqlx::Pool)
• Async migration runner
• Relationship helpers (HasMany, HasOne, BelongsTo)
• Primary keys of type i64, i32, String or Uuid (18.30.0)
• Conventions save and delete maintain (18.30.0): #[timestamps] (created_at / updated_at, Timestamp), #[soft_delete] (deleted_at; deleted rows are left out of queries unless asked for) and #[version] (optimistic locking: saving a stale copy fails with DbErrorKind::StaleVersion instead of overwriting)
• Eager loading for a whole result set (QueryBuilder::with, Relation), many-to-many links (BelongsToMany), scopes (QueryBuilder::scope), seeds written in Rust (Seeders), read replicas (DbPool::with_replicas) and the schema as JSON (DbPool::schema) (18.30.0)

Enable one or more backend features — model-sqlite, model-postgres, and model-mysql are not mutually exclusive, so a single binary can hold pools to more than one backend at once (see Backend):

# SQLite
rust-web-server = { features = ["model-sqlite"] }
# PostgreSQL
rust-web-server = { features = ["model-postgres"] }
# MySQL
rust-web-server = { features = ["model-mysql"] }
# Or more than one at once
rust-web-server = { features = ["model-sqlite", "model-postgres"] }

Modules

backend

Backend — which compiled-in database driver a super::DbPool uses.

connection

Database connection configuration.

db_schema

The database’s schema as data (18.30.0): DbPool::schema reads every table of the connected schema — columns (type, nullability, default), primary key, indexes and foreign keys — from the backend’s catalog (sqlite_master and the pragma_* functions on SQLite, information_schema and pg_catalog on PostgreSQL, information_schema on MySQL), and DbSchema::to_json writes it for tools: rws db schema --json and the dev MCP server’s db_schema.

eager

Eager loading (18.30.0): a Relation names how one model reaches another; QueryBuilder::with loads it for a whole result set in one more query per relation (WHERE fk IN (…)), not one per row.

migration

Async migration runner.

pool

Async connection pool — DbPool and DbTransaction.

query

Async fluent QueryBuilder<T> for constructing SQL queries.

relation

Async relationship helpers: HasMany, HasOne, BelongsTo, and BelongsToMany (18.30.0) through a join table.

repository

Async Repository trait and ModelRepository implementation.

seed

Seeds written in Rust (18.30.0), run after the seeds/*.sql files by DbPool::seed_with — and by an app’s own db seed command, built on rust_web_server::db_cli::run_with_seeders.

timestamp

Timestamp: a UTC instant with microsecond precision, the type of the created_at / updated_at / deleted_at columns the repository maintains (18.30.0).

uuid

Uuid: a 128-bit RFC 9562 UUID for primary keys (18.30.0).

Structs

BelongsTo

Represents the inverse side of a relationship (child → owner).

BelongsToMany

Many-to-many through a join table (18.30.0): the rows of R one owner is linked to, and the links themselves — attach, detach, sync.

ColumnSchema

One column.

CursorPage

A single page of cursor (keyset) paginated results.

DbConfig

Database connection configuration.

DbError

Error type returned by all model/DB operations.

DbSchema

Every table of the connected schema, by name.

DbTls

How a PostgreSQL or MySQL connection uses TLS (ignored for SQLite).

EagerQuery

A QueryBuilder with relations to load: from QueryBuilder::with. Its fetch_* answer Loaded models.

ForeignKeySchema

One foreign key.

HasMany

Represents a one-to-many relationship from an owner to a collection of T.

HasOne

Represents a one-to-one relationship (owner → child).

IndexSchema

One index.

Loaded

A model with the relations QueryBuilder::with loaded for it. Derefs to the model.

MigrationStatus

Status of a single migration file.

ModelInfo

What a Model type maps to, read from its trait implementation: the type, its table, its columns and primary key (18.28.0). Rust can’t list the #[derive(Model)] types of a program at run time, so whatever reports models (the dev MCP server’s models tool, DevTools::model::<T>()) is given each type once.

ModelRepository

Repository tied to a model type and a pool.

ModelRow

Backend-independent database row.

Page

A single page of offset-paginated results (LIMIT/OFFSET-style).

QueryBuilder

Fluent async query builder for SELECT, COUNT, DELETE, and UPDATE.

Relation

How a model O reaches related rows of R: for QueryBuilder::with, and to load the rows of one owner (load) or of many (load_for). Usually returned by an associated function of the owner, so call sites name it:

Replicas

The pools of a DbPool::Replicated: one primary, the replicas reads go to, and the round-robin position (18.30.0).

Seeders

Seeders, run in the order added. Cheap to clone.

SyncChanges

What BelongsToMany::sync changed: the related keys it linked and unlinked.

TableSchema

One table.

Timestamp

A UTC instant, microseconds since the Unix epoch.

Uuid

A UUID, kept as its 16 bytes.

Enums

Backend

Selects which compiled-in database backend a super::DbPool talks to.

DbErrorKind

What a DbError is about, for errors a caller handles differently from the rest (18.30.0).

DbPool

An async connection pool backed by sqlx.

DbSslMode

TLS modes, named as libpq’s sslmode.

DbTransaction

An in-progress database transaction.

Order

Sort direction for order_by.

RelationKind

What a Relation is.

Value

Backend-independent SQL value representation.

Traits

FromColumn

Convert a Value into a Rust type.

Model

Trait generated by #[derive(Model)]. Maps a Rust struct to a database table.

PrimaryKey

A type ModelRepository can key rows by: i64, i32, String or Uuid (18.30.0). Sealed — these are the types Repository is implemented for.

Repository

Async CRUD operations for a model type.

Seeder

Rows put in a database by Rust code; see the module docs. Seeders::add makes one from a closure.

ToColumn

Convert a Rust value into a Value.