[dependencies]
sqlglot-rust = "0.9.24"

use sqlglot_rust::{parse, generate, Dialect};

fn main() {
    // Parse a SQL query
    let ast = parse("SELECT a, b FROM t WHERE a > 1", Dialect::Ansi).unwrap();

    // Generate SQL (roundtrip)
    let sql = generate(&ast, Dialect::Ansi);
    assert_eq!(sql, "SELECT a, b FROM t WHERE a > 1");
}

use sqlglot_rust::{transpile, Dialect};

fn main() {
    // Postgres → BigQuery: NOW() becomes CURRENT_TIMESTAMP()
    let sql = transpile(
        "SELECT NOW(), SUBSTRING(name, 1, 3) FROM users",
        Dialect::Postgres,
        Dialect::BigQuery,
    ).unwrap();
    // → "SELECT CURRENT_TIMESTAMP(), SUBSTRING(name, 1, 3) FROM users"

    // Oracle → T-SQL: NVL becomes ISNULL
    let sql = transpile(
        "SELECT NVL(a, b) FROM t",
        Dialect::Oracle,
        Dialect::Tsql,
    ).unwrap();
    // → "SELECT ISNULL(a, b) FROM t"
}

use sqlglot_rust::Dialect;

let d = Dialect::from_str("postgres").unwrap();
assert_eq!(d, Dialect::Postgres);

// Multiple aliases are supported
assert_eq!(Dialect::from_str("tsql"), Some(Dialect::Tsql));
assert_eq!(Dialect::from_str("mssql"), Some(Dialect::Tsql));
assert_eq!(Dialect::from_str("sqlserver"), Some(Dialect::Tsql));

use sqlglot_rust::builder::{select, condition, column, literal};
use sqlglot_rust::{generate, Dialect};

fn main() {
    // Fluent SELECT builder
    let query = select(&["u.id", "u.name", "COUNT(o.id) AS order_count"])
        .from("users")
        .left_join("orders", "u.id = o.user_id")
        .where_clause("u.active = true")
        .and_where("o.created_at > '2024-01-01'")
        .group_by(&["u.id", "u.name"])
        .having("COUNT(o.id) > 0")
        .order_by(&["order_count DESC"])
        .limit(10)
        .build();

    let sql = generate(&query, Dialect::Postgres);
    // => "SELECT u.id, u.name, COUNT(o.id) AS order_count FROM users LEFT JOIN orders ON u.id = o.user_id WHERE u.active = true AND o.created_at > '2024-01-01' GROUP BY u.id, u.name HAVING COUNT(o.id) > 0 ORDER BY order_count DESC LIMIT 10"

    // Condition builder
    let cond = condition("x = 1")
        .and("y = 2")
        .or("z = 3")
        .build();

    // Expression factory functions
    let col = column("name", Some("users"));  // users.name
    let num = literal(42);                     // 42
}

cargo install sqlglot-rust --features cli

# From stdin
echo "SELECT CAST(x AS INT) FROM t" | sqlglot transpile --read mysql --write postgres

# With pretty-printing
echo "SELECT a, b FROM t WHERE x > 1" | sqlglot transpile --pretty

# With optimizer
echo "SELECT * FROM t WHERE 1 = 1 AND a > 5" | sqlglot transpile --optimize

# From file to file
sqlglot transpile --read mysql --write postgres --input query.sql --output result.sql

echo "SELECT a FROM t" | sqlglot parse --pretty

echo "select a,b from t where x>1" | sqlglot format

# Build for the current host
make ffi

# Build for a specific target
make ffi-macos-arm64    # aarch64-apple-darwin
make ffi-macos-amd64    # x86_64-apple-darwin
make ffi-linux-amd64    # x86_64-unknown-linux-gnu
make ffi-linux-arm64    # aarch64-unknown-linux-gnu

# Build all four targets
make ffi-all

#include "sqlglot.h"

const char *sqlglot_version(void);
char *sqlglot_parse(const char *sql, const char *dialect);
char *sqlglot_transpile(const char *sql, const char *from_dialect, const char *to_dialect);
char *sqlglot_generate(const char *ast_json, const char *dialect);
void  sqlglot_free(char *ptr);   /* must be called on every non-NULL return */

#include <stdio.h>
#include "sqlglot.h"

int main(void) {
    char *result = sqlglot_transpile("SELECT * FROM t LIMIT 10", "mysql", "tsql");
    if (result) {
        printf("%s\n", result);   /* → SELECT TOP 10 * FROM t */
        sqlglot_free(result);
    }
    return 0;
}

# macOS
gcc example.c -Itarget/ffi/include -Ltarget/release -lsqlglot_rust -o example

# Linux
gcc example.c -Itarget/ffi/include -Ltarget/release -lsqlglot_rust -lpthread -ldl -lm -o example
LD_LIBRARY_PATH=target/release ./example

src/
├── ast/          # AST node definitions (~40 expression types, 15 statement types)
├── bin/          # CLI binary (sqlglot) — feature-gated behind "cli"
├── ffi.rs        # C-compatible FFI bindings (extern "C" API)
├── tokens/       # Token types (~200+ variants) and tokenizer
├── parser/       # Recursive-descent SQL parser
├── generator/    # SQL code generator
├── dialects/     # 30 dialect definitions with transform rules
├── optimizer/    # Query optimization and scope analysis
├── planner/      # Logical query planner (execution plan DAG)
├── executor/     # In-memory SQL execution engine
├── schema/       # Schema management (MappingSchema, dialect-aware lookups)
├── errors/       # Error types
└── lib.rs        # Public API (parse, generate, transpile)

# Build
cargo build

# Build with CLI
cargo build --features cli

# Run tests (500+ tests)
cargo test

# Run CLI tests
cargo test --features cli --test test_cli

# Run benchmarks
cargo bench

# Lint
cargo clippy

# Format
cargo fmt

make build          # cargo build
make test           # cargo test
make lint           # cargo clippy
make fmt            # cargo fmt
make sbom           # Generate SPDX SBOM (see below)
make bump-version   # Update version across all files (see below)
make ffi            # Build FFI libraries for the current host
make ffi-all        # Build FFI libraries for all 4 targets (macOS/Linux × arm64/amd64)
make all            # build + sbom

cargo sbom --output-format spdx_json_2_3 > target/sbom/sqlglot-rust.spdx.json

make bump-version VERSION=1.0.0

MIT License

Copyright (c) 2023 Toby Mao

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.