oxisql-parse — SQL parsing, planning, and optimization for OxiSQL

sqlparser facade with dialect-aware parsing, a fluent query builder, logical planning (with subquery decorrelation), a cost-based optimizer, and LRU parse/plan caches.

What it is

oxisql-parse wraps sqlparser with OxiSQL-idiomatic APIs: dialect-aware parsing, a fluent QueryBuilder, a logical planner with correlated-subquery decorrelation, a rule-based (and optionally cost-based, statistics-driven join-reordering) optimizer, DML planning, a cost model, a schema validator, aggregate / window helpers, plain and verbose/JSON explain pretty-printers, and thread-safe LRU caches for both parsed ASTs (ParseCache) and optimized plans (PlanCache). It re-exports the most commonly needed sqlparser AST types. The crate is Pure Rust and has no feature flags.

Installation

[dependencies]
oxisql-parse = "0.4.1"

MSRV 1.89 · edition 2021 · Apache-2.0.

Quick start

use oxisql_parse::{parse, parse_one, is_read_only, QueryBuilder, ParseCache, SqlDialect};

// Parse multiple statements.
let stmts = parse("SELECT 1; SELECT 2")?;
assert_eq!(stmts.len(), 2);

// Parse a single statement and classify it.
let stmt = parse_one("SELECT 42")?;
assert!(is_read_only(&stmt));

// Fluent query builder.
let sql = QueryBuilder::select(&["id", "name", "email"])
    .from("users")
    .join("orders", "users.id = orders.user_id")
    .where_clause("users.active = TRUE")
    .order_by("users.name", true)
    .limit(10)
    .offset(20)
    .build()?;

// Thread-safe LRU parse cache, keyed by (sql, dialect).
let cache = ParseCache::new(32);
let _ = cache.parse("SELECT 1", SqlDialect::Generic)?;
assert_eq!(cache.len(), 1);
# Ok::<(), oxisql_core::OxiSqlError>(())

Key API

Parsing

SqlDialect: Generic, Postgres, MySQL, SQLite.

Analysis (analysis module)

QueryBuilder

Fluent SELECT builder; chaining methods return Self.

Static DML helpers return a String directly:

# use oxisql_parse::QueryBuilder;
QueryBuilder::insert("users", &["id", "name"], &["1", "'Alice'"]);
// → "INSERT INTO users (id, name) VALUES (1, 'Alice')"
QueryBuilder::update("users", &[("name", "'Bob'")], Some("id = 42"));
// → "UPDATE users SET name = 'Bob' WHERE id = 42"
QueryBuilder::delete("users", Some("id = 99"));
// → "DELETE FROM users WHERE id = 99"

Logical planner

Optimizer

DML planning

Cost model, validation, aggregates, windows, explain

ParseCache

Thread-safe LRU cache keyed by (sql, dialect).

PlanCache

Thread-safe LRU cache of optimized logical plans — distinct from ParseCache above, which caches raw parsed ASTs. Keyed by a literal-normalized SQL template (via parameterize) plus a schema generation counter, so two queries differing only in literal values (WHERE id = 1 vs WHERE id = 2) share one cache entry.

parameterize(sql) -> ParameterizedSql extracts the { template, literals } pair used as PlanCache's cache key; it is also usable standalone for any literal-normalization need.

use oxisql_parse::{explain, optimize, parse_one, plan_query};

let stmt = parse_one("SELECT id FROM users WHERE id = 1")?;
let plan = optimize(plan_query(&stmt));
println!("{}", explain(&plan));
# Ok::<(), oxisql_core::OxiSqlError>(())

Re-exports common sqlparser AST types (Statement, Expr, SelectItem, TableFactor, JoinConstraint, …) for downstream backends.

Feature flags

None.

Test coverage

191 tests pass (178 unit + 13 doc).

Part of the OxiSQL workspace

oxisql-parse is one of 18 crates in the OxiSQL workspace (11 facade/driver crates plus a 7-crate C-free oxisqlite-* engine). See the workspace README for the full architecture and the 2,261 workspace tests (2,755 with --all-features).

License

Apache-2.0 — COOLJAPAN OU (Team Kitasan). Copyright © 2024–2026 COOLJAPAN OU (Team Kitasan). Repository: https://github.com/cool-japan/oxisql