Module zino_core::orm

Available on crate feature orm only.

Database schema and ORM.

Supported database drivers

The following optional features are available:

Feature flag	Description	Default?
orm-mariadb	Enables the MariaDB database driver.	No
orm-mysql	Enables the MySQL database driver.	No
orm-postgres	Enables the PostgreSQL database driver.	No
orm-sqlite	Enables the SQLite database driver.	No
orm-tidb	Enables the TiDB database driver.	No

Design references

The design of our ORM is inspired by Mongoose, Prisma, TypeORM and PostgREST.

use zino_core::{model::{Mutation, Query}, orm::Schema, Map, Record};

// Constructs a model `Query` with JSON expressions.
let query = Query::new(json!({
    "$or": [
        {
            "roles": "worker",
            "visibility": "Public",
        },
        {
            "roles": { "$in": ["admin", "auditor"] },
            "visibility": { "$ne": "Public" },
        },
    ],
    "status": { "$nin": ["Deleted", "Locked"] },
}));

// Constructs a model `Mutation` with JSON expressions.
let mut mutation = Mutation::new(json!({
    "status": "Active",
    "refreshed_at": DateTime::now(),
    "$inc": { "refresh_count": 1 },
}));

// Updates the models using `update_many` provided by the `Schema` trait.
let ctx = User::update_many(&query, &mut mutation).await?;
ctx.emit_metrics("user_refresh");

// Constructs a model `Query` with projection fields.
let mut query = Query::new(json!({
    "project.start_date": { "$le": "2023-10-07" },
    "project.end_date": { "$ge": "2023-10-01" },
    "task.status": "Completed",
}));
query.allow_fields(&[
    "task.id",
    "task.name",
    "task.status",
    "task.project_id",
    "project.start_date",
    "project.end_date",
]);
query.order_desc("task.updated_at");

// Performs a LEFT OUTER JOIN using `lookup` provided by the `Schema` trait.
let entries = Task::lookup::<Project, Map>(&query, &[("project_id", "id")]).await?;

// Executes the raw SQL with interpolations `${param}` and argument bindings `#{param}`.
let sql =
    "SELECT u.id, u.name, u.tags, t.id, t.name \
        FROM ${user_table} u INNER JOIN ${tag_table} t \
            ON t.id = ANY(u.tags) AND t.category = #{category};";
let params = json!({
    "user_table": User::table_name(),
    "tag_table": Tag::table_name(),
    "category": "Rustacean",
});
let records = User::query::<Record>(sql, params.as_object()).await?;

Query operators

Name	MySQL	PostgreSQL	SQLite
$and	AND	AND	AND
$or	OR	OR	OR
$not	NOT	NOT	NOT
$rand	rand()	random()	abs(random())
$text	match() against()	to_tsvector()	MATCH
$ovlp	overlaps()	OVERLAPS	N/A
$eq	=	=	=
$ne	<>	<>	<>
$lt	<	<	<
$le	<=	<=	<=
$gt	>	>	>
$ge	>=	>=	>=
$in	IN	IN	IN
$nin	NOT IN	NOT IN	NOT IN
$betw	BETWEEN AND	BETWEEN AND	BETWEEN AND
$like	LIKE	LIKE	LIKE
$ilike	ILIKE	ILIKE	N/A
$rlike	RLIKE	~*	REGEXP
$glob	N/A	N/A	GLOB
$is	IS	IS	IS
$size	json_length()	array_length()	json_array_length()

Structs

• ConnectionPool
  A database connection pool with metadata.
• GlobalPool
  Global access to the shared connection pools.

Traits

• Executor
  Executing queries against the database.
• ModelAccessor
  Access model fields.
• ModelHelper
  Helper utilities for models.
• PoolManager
  A manager of the connection pool.
• ScalarQueryorm-sqlx
  Query on scalar values.
• Schema
  Database schema.
• Transaction
  An in-progress database transaction.

Functions

• decodeorm-sqlx
  Decodes a single value as T for the field in a row.
• decode_arrayorm-sqlx
  Decodes a single value as Vec<T> for the field in a row.
• decode_decimalorm-sqlx
  Decodes a single value as Decimal for the field in a row.
• decode_uuidorm-sqlx
  Decodes a single value as Uuid for the field in a row.

Type Aliases

• DatabaseConnection
  SQLite database connection.
• DatabaseDriver
  SQLite database driver.
• DatabasePool
  SQLite database pool.
• DatabaseRow
  A single row from the SQLite database.