Crate prax_query 

prax-query

Type-safe query builder for the Prax ORM.

This crate provides the core query building functionality, including:

• Fluent API for building queries (find_many, find_unique, create, update, delete)
• Type-safe filtering with where clauses
• Sorting and pagination
• Relation loading (include, select)
• Transaction support
• Raw SQL escape hatch
• Middleware system
• Multi-tenant support

Filters

Build type-safe filters for queries:

use prax_query::{Filter, FilterValue};

// Equality filter
let filter = Filter::Equals("email".into(), FilterValue::String("test@example.com".into()));

// Greater than filter
let filter = Filter::Gt("age".into(), FilterValue::Int(18));

// Contains filter (for strings)
let filter = Filter::Contains("name".into(), FilterValue::String("john".into()));

// Combine filters with AND/OR
let combined = Filter::and([
    Filter::Equals("active".into(), FilterValue::Bool(true)),
    Filter::Gt("age".into(), FilterValue::Int(18)),
]);

let either = Filter::or([
    Filter::Equals("role".into(), FilterValue::String("admin".into())),
    Filter::Equals("role".into(), FilterValue::String("moderator".into())),
]);

Filter Values

Convert Rust types to filter values:

use prax_query::FilterValue;

// Integer values
let val: FilterValue = 42.into();
assert!(matches!(val, FilterValue::Int(42)));

// String values
let val: FilterValue = "hello".into();
assert!(matches!(val, FilterValue::String(_)));

// Boolean values
let val: FilterValue = true.into();
assert!(matches!(val, FilterValue::Bool(true)));

// Float values
let val: FilterValue = 3.14f64.into();
assert!(matches!(val, FilterValue::Float(_)));

// Null values
let val = FilterValue::Null;

Sorting

Build sort specifications:

use prax_query::{OrderBy, OrderByField, NullsOrder};

// Ascending order
let order = OrderByField::asc("created_at");

// Descending order
let order = OrderByField::desc("updated_at");

// With NULLS FIRST/LAST
let order = OrderByField::asc("name").nulls(NullsOrder::First);
let order = OrderByField::desc("score").nulls(NullsOrder::Last);

// Combine multiple orderings
let orders = OrderBy::Field(OrderByField::asc("name"))
    .then(OrderByField::desc("created_at"));

Raw SQL

Build raw SQL queries with parameter binding:

use prax_query::Sql;

// Simple query
let sql = Sql::new("SELECT * FROM users");
assert_eq!(sql.sql(), "SELECT * FROM users");

// Query with parameter - bind appends placeholder
let sql = Sql::new("SELECT * FROM users WHERE id = ")
    .bind(42);
assert_eq!(sql.params().len(), 1);

Connection Strings

Parse database connection strings:

use prax_query::ConnectionString;

// PostgreSQL
let conn = ConnectionString::parse("postgres://user:pass@localhost:5432/mydb").unwrap();
assert_eq!(conn.host(), Some("localhost"));
assert_eq!(conn.port(), Some(5432));
assert_eq!(conn.database(), Some("mydb"));

// MySQL
let conn = ConnectionString::parse("mysql://user:pass@localhost:3306/mydb").unwrap();

Transaction Config

Configure transaction behavior:

use prax_query::IsolationLevel;

let level = IsolationLevel::Serializable;
assert_eq!(level.as_sql(), "SERIALIZABLE");

Error Handling

Work with query errors:

use prax_query::{QueryError, ErrorCode};

// Create errors
let err = QueryError::not_found("User");
assert_eq!(err.code, ErrorCode::RecordNotFound);

Re-exports

pub use error::ErrorCode;

pub use error::ErrorContext;

pub use error::QueryError;

pub use error::QueryResult;

pub use error::Suggestion;

pub use filter::AndFilterBuilder;

pub use filter::FieldName;

pub use filter::Filter;

pub use filter::FilterValue;

pub use filter::FluentFilterBuilder;

pub use filter::LargeValueList;

pub use filter::OrFilterBuilder;

pub use filter::ScalarFilter;

pub use filter::SmallValueList;

pub use filter::ValueList;

pub use nested::NestedWrite;

pub use nested::NestedWriteBuilder;

pub use nested::NestedWriteOperations;

pub use operations::CreateOperation;

pub use operations::DeleteOperation;

pub use operations::FindManyOperation;

pub use operations::FindUniqueOperation;

pub use operations::UpdateOperation;

pub use pagination::Cursor;

pub use pagination::CursorDirection;

pub use pagination::Pagination;

pub use query::QueryBuilder;

pub use raw::RawExecuteOperation;

pub use raw::RawQueryOperation;

pub use raw::Sql;

pub use relations::Include;

pub use relations::IncludeSpec;

pub use relations::RelationLoader;

pub use relations::RelationSpec;

pub use relations::SelectSpec;

pub use traits::Executable;

pub use traits::IntoFilter;

pub use traits::Model;

pub use traits::QueryEngine;

pub use transaction::IsolationLevel;

pub use transaction::Transaction;

pub use transaction::TransactionConfig;

pub use types::NullsOrder;

pub use types::OrderBy;

pub use types::OrderByBuilder;

pub use types::OrderByField;

pub use types::Select;

pub use types::SortOrder;

pub use types::order_patterns;

pub use middleware::LoggingMiddleware;

pub use middleware::MetricsMiddleware;

pub use middleware::Middleware;

pub use middleware::MiddlewareBuilder;

pub use middleware::MiddlewareChain;

pub use middleware::MiddlewareStack;

pub use middleware::QueryContext;

pub use middleware::QueryMetadata;

pub use middleware::QueryMetrics;

pub use middleware::QueryType;

pub use middleware::RetryMiddleware;

pub use middleware::TimingMiddleware;

pub use connection::ConnectionError;

pub use connection::ConnectionOptions;

pub use connection::ConnectionString;

pub use connection::DatabaseConfig;

pub use connection::Driver;

pub use connection::EnvExpander;

pub use connection::MultiDatabaseConfig;

pub use connection::PoolConfig;

pub use connection::PoolOptions;

pub use connection::SslConfig;

pub use connection::SslMode;

pub use data::BatchCreate;

pub use data::ConnectData;

pub use data::CreateData;

pub use data::DataBuilder;

pub use data::FieldValue;

pub use data::IntoData;

pub use data::UpdateData;

pub use tenant::DynamicResolver;

pub use tenant::IsolationStrategy;

pub use tenant::RowLevelConfig;

pub use tenant::SchemaConfig;

pub use tenant::StaticResolver;

pub use tenant::TenantConfig;

pub use tenant::TenantConfigBuilder;

pub use tenant::TenantContext;

pub use tenant::TenantId;

pub use tenant::TenantInfo;

pub use tenant::TenantMiddleware;

pub use tenant::TenantResolver;

pub use intern::clear_interned;

pub use intern::fields;

pub use intern::intern;

pub use intern::intern_cow;

pub use intern::interned_count;

pub use pool::FilterBuilder;

pub use pool::FilterPool;

pub use pool::IntoPooledValue;

pub use pool::PooledFilter;

pub use pool::PooledValue;

pub use sql::DatabaseType;

pub use sql::FastSqlBuilder;

pub use sql::QueryCapacity;

pub use sql::SqlBuilder;

pub use sql::templates;

pub use cache::CacheStats;

pub use cache::CachedQuery;

pub use cache::ExecutionPlan;

pub use cache::ExecutionPlanCache;

pub use cache::PlanHint;

pub use cache::QueryCache;

pub use cache::QueryHash;

pub use cache::QueryKey;

pub use cache::SqlTemplate;

pub use cache::SqlTemplateCache;

pub use cache::get_global_template;

pub use cache::global_template_cache;

pub use cache::patterns as cache_patterns;

pub use cache::precompute_query_hash;

pub use cache::register_global_template;

pub use batch::Batch;

pub use batch::BatchBuilder;

pub use batch::BatchOperation;

pub use batch::BatchResult;

pub use batch::OperationResult;

pub use batch::Pipeline;

pub use batch::PipelineBuilder;

pub use batch::PipelineQuery;

pub use batch::PipelineResult;

pub use batch::QueryResult as PipelineQueryResult;

pub use row::FromColumn;

pub use row::FromRow;

pub use row::FromRowRef;

pub use row::RowData;

pub use row::RowError;

pub use row::RowRef;

pub use row::RowRefIter;

pub use lazy::Lazy;

pub use lazy::LazyRelation;

pub use lazy::ManyToOneLoader;

pub use lazy::OneToManyLoader;

pub use static_filter::CompactValue;

pub use static_filter::StaticFilter;

pub use static_filter::and2;

pub use static_filter::and3;

pub use static_filter::and4;

pub use static_filter::and5;

pub use static_filter::contains;

pub use static_filter::ends_with;

pub use static_filter::eq;

pub use static_filter::fields as static_fields;

pub use static_filter::gt;

pub use static_filter::gte;

pub use static_filter::in_list;

pub use static_filter::is_not_null;

pub use static_filter::is_null;

pub use static_filter::lt;

pub use static_filter::lte;

pub use static_filter::ne;

pub use static_filter::not;

pub use static_filter::not_in_list;

pub use static_filter::or2;

pub use static_filter::or3;

pub use static_filter::or4;

pub use static_filter::or5;

pub use static_filter::starts_with;

pub use typed_filter::And;

pub use typed_filter::AndN;

pub use typed_filter::Contains;

pub use typed_filter::DirectSql;

pub use typed_filter::EndsWith;

pub use typed_filter::Eq;

pub use typed_filter::Gt;

pub use typed_filter::Gte;

pub use typed_filter::InI64;

pub use typed_filter::InI64Slice;

pub use typed_filter::InStr;

pub use typed_filter::InStrSlice;

pub use typed_filter::IsNotNull;

pub use typed_filter::IsNull;

pub use typed_filter::LazyFilter;

pub use typed_filter::Lt;

pub use typed_filter::Lte;

pub use typed_filter::Maybe;

pub use typed_filter::Ne;

pub use typed_filter::Not as TypedNot;

pub use typed_filter::NotInI64Slice;

pub use typed_filter::Or;

pub use typed_filter::OrN;

pub use typed_filter::StartsWith;

pub use typed_filter::TypedFilter;

pub use typed_filter::and_n;

pub use typed_filter::eq as typed_eq;

pub use typed_filter::gt as typed_gt;

pub use typed_filter::gte as typed_gte;

pub use typed_filter::in_i64 as typed_in_i64;

pub use typed_filter::in_i64_slice;

pub use typed_filter::in_str as typed_in_str;

pub use typed_filter::in_str_slice;

pub use typed_filter::is_not_null as typed_is_not_null;

pub use typed_filter::is_null as typed_is_null;

pub use typed_filter::lazy;

pub use typed_filter::lt as typed_lt;

pub use typed_filter::lte as typed_lte;

pub use typed_filter::ne as typed_ne;

pub use typed_filter::not_in_i64_slice;

pub use typed_filter::or_n;

pub use memory::BufferPool;

pub use memory::CompactFilter;

pub use memory::GLOBAL_BUFFER_POOL;

pub use memory::GLOBAL_STRING_POOL;

pub use memory::MemoryStats;

pub use memory::PoolStats;

pub use memory::PooledBuffer;

pub use memory::StringPool;

pub use memory::get_buffer;

pub use memory::intern as memory_intern;

pub use logging::get_log_format;

pub use logging::get_log_level;

pub use logging::init as init_logging;

pub use logging::init_debug;

pub use logging::init_with_level;

pub use logging::is_debug_enabled;

pub use smallvec;

Modules

batch

Batch query execution for combining multiple operations.

cache

Query caching and prepared statement management.

connection

Connection string parsing and multi-database configuration.

data

Ergonomic data creation utilities.

error

Comprehensive error types for query operations with actionable messages.

filter

Filter types for building WHERE clauses.

intern

String interning for efficient field name storage.

lazy

Lazy loading utilities for relations.

logging

Logging infrastructure for Prax ORM.

macros

Compile-time filter construction macros.

memory

Memory optimization utilities for prax-query.

middleware

Middleware system for query interception.

nested

Nested write operations for managing relations in a single mutation.

operations

Query operations for the fluent API.

pagination

Pagination types for query results.

pool

Arena-based filter pool for efficient nested filter construction.

prelude

Prelude module for convenient imports.

query

Query builder entry point.

raw

Raw SQL query execution with type-safe parameter interpolation.

relations

Relation loading support for eager and lazy loading.

row

Zero-copy row deserialization traits and utilities.

sql

SQL generation utilities.

static_filter

Static filter construction for zero-allocation filters.

tenant

Multi-tenant support for Prax.

traits

Core traits for the query builder.

transaction

Transaction support with async closures and savepoints.

typed_filter

Type-level filter composition for zero-cost filter abstractions.

types

Common types used in query building.

Macros

and_filter

Combine filters with AND.

connect

Macro for creating connection data.

data

Macro for concise data creation.

decrement

Macro for decrement operations.

filter

Create a filter expression with minimal allocations.

impl_from_row

Macro to implement FromRow for simple structs.

increment

Macro for increment operations.

not_filter

Negate a filter.

or_filter

Combine filters with OR.

prax_debug

Macro for conditional debug logging.

prax_trace

Macro for conditional trace logging.

query_error

Helper for creating errors with context.

raw_query

A macro for creating raw SQL queries with inline parameter binding.