🪝 QAIL — The Universal Query Transpiler

Safe but Free. Write queries once. Run them everywhere. Zero lock-in.

Why QAIL?

For years, developers have been trapped between two choices:

1. Raw SQL — Maximum freedom, but dangerous strings scattered across your codebase.
2. ORMs / Query Builders — Maximum safety, but a "prison" of boilerplate and language lock-in.

QAIL is the third way.

We moved validation from the networking layer to the grammar level. By treating queries as a compiled language instead of raw strings, QAIL provides compile-time safety with the freedom of raw SQL.

• ✅ No language lock-in — Same syntax in Rust, Node.js, Go, Python, PHP
• ✅ No heavy dependencies — Pure logic, zero networking code
• ✅ No "big bang" migration — Adopt incrementally, one query at a time
• ✅ Works with your existing driver — SQLx, pg, PDO, psycopg2, etc.

-- SQL (The Assembly)
SELECT id, email FROM users WHERE active = true LIMIT 10;

# QAIL (The Source Code)
get::users:'id'email [ 'active == true, 0..10 ]

One line. Zero ceremony. Runs everywhere.

🚀 Installation

Rust (Native)

cargo install qail

[dependencies]
qail-core = "0.6.1"

Node.js / Browser (WASM)

npm i qail-wasm

💡 Usage

Rust

use qail_core::prelude::*;

// Parse and transpile
let sql = parse("get::users:'id'email [ 'active == true ]")?.to_sql();
// Returns: "SELECT id, email FROM users WHERE active = true"

// Use with your existing driver (sqlx, diesel, etc.)
let users = sqlx::query_as::<_, User>(&sql)
    .fetch_all(&pool)
    .await?;

JavaScript / TypeScript

import { parseAndTranspile } from 'qail-wasm';

const sql = parseAndTranspile("get::users:'id'email [ 'active == true ]");
// Returns: "SELECT id, email FROM users WHERE active = true"

// Use with your existing driver (pg, mysql2, etc.)
const result = await client.query(sql);

📖 Quick Reference

📚 Examples

Basic SELECT

get::users:'id'email [ 'active == true ]
# → SELECT id, email FROM users WHERE active = true

All Columns

get::users:'_
# → SELECT * FROM users

Sorting & Pagination

get::users:'_ [ -created_at, 0..10 ]
# → SELECT * FROM users ORDER BY created_at DESC LIMIT 10

Fuzzy Search

get::users:'id'name [ 'name ~ "john" ]
# → SELECT id, name FROM users WHERE name ILIKE '%john%'

UPDATE

set::users:[ status = "active" ] [ 'id == $1 ]
# → UPDATE users SET status = 'active' WHERE id = $1

DELETE

del::users:[ 'id == $1 ]
# → DELETE FROM users WHERE id = $1

JOINs

get::users<-profiles:'name'avatar
# → SELECT name, avatar FROM users LEFT JOIN profiles ON ...

📦 Schema Management (Migrations)

Create and modify tables with the same concise syntax.

Create Table (make::)

make::users:'id:uuid^pk'email:varchar^unique^comment("User email")
# → CREATE TABLE users (id UUID PRIMARY KEY, email VARCHAR(255) UNIQUE);
# → COMMENT ON COLUMN users.email IS 'User email'

Constraints & Defaults

make::posts:'id:uuid^pk'status:varchar^def("draft")'views:int^def(0)
# → CREATE TABLE posts (
#     id UUID PRIMARY KEY,
#     status VARCHAR(255) DEFAULT 'draft',
#     views INT DEFAULT 0
# )

Composite Constraints

make::bookings:'user_id:uuid'slot_id:uuid^unique(user_id, slot_id)
# → CREATE TABLE bookings (..., UNIQUE (user_id, slot_id))

Create Index (index::)

index::idx_email^on(users:'email)^unique
# → CREATE UNIQUE INDEX idx_email ON users (email)

🌐 One Syntax. Every Stack.

QAIL provides multiple integration paths:

The C-API Advantage

Instead of building separate bindings for each language, we expose a Universal C-API (libqail). Any language with FFI support can call QAIL directly:

// C / C++
#include <qail.h>
const char* sql = qail_transpile("get::users:'_ [ 0..10 ]");

# Python (via ctypes or cffi)
from ctypes import cdll
libqail = cdll.LoadLibrary("libqail.so")
sql = libqail.qail_transpile(b"get::users:'_")

// Go (via cgo)
// #include <qail.h>
import "C"
sql := C.GoString(C.qail_transpile(C.CString("get::users:'_")))

Same syntax. Same validation. Any driver.

🤝 Contributing

We welcome contributions!

git clone https://github.com/qail-rs/qail.git
cd qail
cargo test

📄 License

MIT © 2025 QAIL Contributors