Crate mik_sql 

mik-sql - SQL Query Builder with Mongo-style Filters

A standalone SQL query builder with intuitive macro syntax for CRUD operations. Supports Postgres and SQLite dialects.

Quick Start

use mik_sql::prelude::*;

// SELECT - Read data
let (sql, params) = sql_read!(users {
    select: [id, name, email],
    filter: { active: true },
    order: name,
    limit: 10,
});
// → "SELECT id, name, email FROM users WHERE active = $1 ORDER BY name LIMIT 10"

// INSERT - Create data
let (sql, params) = sql_create!(users {
    name: str(name),
    email: str(email),
    returning: [id],
});
// → "INSERT INTO users (name, email) VALUES ($1, $2) RETURNING id"

// UPDATE - Update data
let (sql, params) = sql_update!(users {
    set: { name: str(new_name) },
    filter: { id: int(user_id) },
});
// → "UPDATE users SET name = $1 WHERE id = $2"

// DELETE - Delete data
let (sql, params) = sql_delete!(users {
    filter: { id: int(user_id) },
});
// → "DELETE FROM users WHERE id = $1"

SQLite Dialect

Add sqlite as first parameter for SQLite syntax (?1, ?2 instead of $1, $2):

let (sql, params) = sql_read!(sqlite, users { ... });

Supported Operators

Operator	SQL	Example
$eq	=	"status": { "$eq": "active" }
$ne	!=	"status": { "$ne": "deleted" }
$gt	>	"age": { "$gt": 18 }
$gte	>=	"age": { "$gte": 21 }
$lt	<	"price": { "$lt": 100 }
$lte	<=	"price": { "$lte": 50 }
$in	IN	"status": { "$in": ["a", "b"] }
$nin	NOT IN	"status": { "$nin": ["x"] }
$like	LIKE	"name": { "$like": "%test%" }
$ilike	ILIKE	"name": { "$ilike": "%test%" }
$starts_with	LIKE $1 || '%'	"name": { "$starts_with": "John" }
$ends_with	LIKE '%' || $1	"email": { "$ends_with": "@example.com" }
$contains	LIKE '%' || $1 || '%'	"bio": { "$contains": "developer" }
$between	BETWEEN $1 AND $2	"age": { "$between": [18, 65] }

Cursor Pagination

use mik_sql::prelude::*;

let (sql, params) = sql_read!(posts {
    select: [id, title, created_at],
    filter: { published: true },
    order: [-created_at, -id],
    after: req.query("after"),
    limit: 20,
});

// Create cursor for next page
let next_cursor = Cursor::new()
    .string("created_at", &last_item.created_at)
    .int("id", last_item.id)
    .encode();

Modules

prelude

Prelude module for convenient imports.

Macros

ids

Collect field values from a list for batched loading.

sql_create

Build an INSERT query using object-like syntax.

sql_delete

Build a DELETE query using object-like syntax.

sql_read

Build a SELECT query using the query builder (CRUD: Read).

sql_update

Build an UPDATE query using object-like syntax.

Structs

Aggregate

An aggregation expression.

CompoundFilter

A compound filter combining multiple expressions with a logical operator.

ComputedField

A computed field expression with alias.

Cursor

A cursor for cursor-based pagination.

DeleteBuilder

Builder for DELETE queries.

Filter

Filter condition.

FilterValidator

Validation configuration for user-provided filters.

InsertBuilder

Builder for INSERT queries.

KeysetCondition

Keyset pagination condition.

PageInfo

Page information for paginated responses.

Postgres

Postgres dialect.

QueryBuilder

SQL query builder with dialect support.

QueryResult

Query result with SQL string and parameters.

SortField

Sort field with direction.

Sqlite

SQLite dialect.

UpdateBuilder

Builder for UPDATE queries.

Enums

AggregateFunc

Aggregation functions.

CursorDirection

Cursor pagination direction.

CursorError

Errors that can occur when parsing a cursor.

FilterExpr

A filter expression that can be simple or compound.

LogicalOp

Logical operators for compound filters.

Operator

SQL comparison operators.

SortDir

Sort direction.

ValidationError

Validation error types.

Value

SQL parameter values.

Traits

Dialect

SQL dialect trait for database-specific syntax.

IntoCursor

Trait for types that can be converted into a cursor.

Functions

and

Helper function to create an AND compound filter.

assert_valid_sql_expression

Assert that a SQL expression is valid for computed fields.

assert_valid_sql_identifier

Assert that a string is a valid SQL identifier.

delete

Create a DELETE builder for Postgres.

insert

Create an INSERT builder for Postgres.

is_valid_sql_expression

Validate a SQL expression for computed fields.

is_valid_sql_identifier

Validate that a string is a safe SQL identifier.

merge_filters

Merge trusted filters with validated user filters.

not

Helper function to create a NOT filter.

or

Helper function to create an OR compound filter.

postgres

Build a query for Postgres.

simple

Helper function to create a simple filter expression.

sqlite

Build a query for SQLite.

update

Create an UPDATE builder for Postgres.