Can I use it in rust project?

[div002123]

I see it seems to only have a CLI way to use it? How can I integrate it into my Rust project?

[scsmithr]

This can be used in a rust project, but it hasn't been the primary use case we've been developing for. The focus has been on SQL stability and using either the CLI or python clients.

Here's an example of using in a rust project. Note that APIs may continue to evolve, and the developer experience for the rust-centric use case would need to improve.

Cargo.toml:

[package]
name = "glaredb_example"
version = "0.1.0"
edition = "2024"

[dependencies]
glaredb_core  = { git = "https://github.com/glaredb/glaredb.git", tag = "v25.6.2" }
glaredb_rt_native  = { git = "https://github.com/glaredb/glaredb.git", tag = "v25.6.2" }
ext_default  = { git = "https://github.com/glaredb/glaredb.git", tag = "v25.6.2" }

We don't currently release anything to crates.io, so git needs to be used. Unfortunately cargo doesn't handle submodules well, and there's no way to skip them, so the following config would need to be added in your rust project.

.cargo/config.toml:

[net]
git-fetch-with-cli = true

And now the code.

src/main.rs:

use std::error::Error;

use glaredb_core::{
    arrays::format::pretty::{components::PRETTY_COMPONENTS, table::PrettyTable},
    engine::single_user::SingleUserEngine,
};
use glaredb_rt_native::runtime::{
    NativeSystemRuntime, ThreadedNativeExecutor, new_tokio_runtime_for_io,
};

fn main() -> Result<(), Box<dyn Error>> {
    // Create a tokio runtime that's used for remote io (object storage). If a
    // tokio runtime already exists, this can be skipped. A handle to the
    // existing tokio runtime should be passed to NativeSystemRuntime.
    let tokio_rt = new_tokio_runtime_for_io()?;
    // Create an 'executor' for executing the queries. `try_new` will create a
    // thread pool using all threads. `try_new_with_num_threads` may be used as
    // an alternative.
    let executor = ThreadedNativeExecutor::try_new()?;
    // Create a 'runtime' for accessing external data (e.g. file systems, how
    // http clients are created, etc).
    let runtime = NativeSystemRuntime::new(tokio_rt.handle().clone());

    // Simple wrapper around a database engine and a single session connected to
    // that db engine.
    let engine = SingleUserEngine::try_new(executor, runtime.clone())?;
    // Register all default extensions (parquet, csv, etc). Alternatively
    // individual `ext_` crates can be used to selectively register extensions.
    ext_default::register_all(&engine.engine)?;

    let (batches, schema) = tokio_rt.block_on(async {
        // Begin executeion of a single query. `query` expects a single sql
        // statement, `query_many` can be used to execute multiple statements
        // (with a bit more code required to do so).
        let mut q_res = engine
            .session()
            .query("SELECT avg(salary), count(*) FROM 's3://glaredb-public/userdata0.parquet")
            .await?;

        // Collect all batches. Execution is streaming, `collect` just fetches
        // everything.
        let batches = q_res.output.collect().await?;

        Ok::<_, Box<dyn Error>>((batches, q_res.output_schema))
    })?;

    // Create and display a pretty table containing the output data in batches.
    let table = PrettyTable::try_new(&schema, &batches, 100, None, PRETTY_COMPONENTS)?;
    println!("{table}");

    Ok(())
}

Running this should produce the following output:

$ cargo run
...
┌─────────────────────┬───────┐
│ avg                 │ count │
│ Float64             │ Int64 │
├─────────────────────┼───────┤
│  149005.35665236053 │  1000 │
└─────────────────────┴───────┘

I'll look at releasing on crates.io to make using this in rust a nicer experience.

[scsmithr]

I've just published the crates to crates.io, so we can avoid the git cloning stuff.

Cargo.toml:

[package]
name = "glaredb_example"
version = "0.1.0"
edition = "2024"

[dependencies]
glaredb_core = { version = "25.6.2" }
glaredb_rt_native = { version = "25.6.2" }
glaredb_ext_default = { version = "25.6.2" }

src/main.rs:

use std::error::Error;

use glaredb_core::{
    arrays::format::pretty::{components::PRETTY_COMPONENTS, table::PrettyTable},
    engine::single_user::SingleUserEngine,
};
use glaredb_rt_native::runtime::{
    NativeSystemRuntime, ThreadedNativeExecutor, new_tokio_runtime_for_io,
};

fn main() -> Result<(), Box<dyn Error>> {
    // Create a tokio runtime that's used for remote io (object storage). If a
    // tokio runtime already exists, this can be skipped. A handle to the
    // existing tokio runtime should be passed to NativeSystemRuntime.
    let tokio_rt = new_tokio_runtime_for_io()?;
    // Create an 'executor' for executing the queries. `try_new` will create a
    // thread pool using all threads. `try_new_with_num_threads` may be used as
    // an alternative.
    let executor = ThreadedNativeExecutor::try_new()?;
    // Create a 'runtime' for accessing external data (e.g. file systems, how
    // http clients are created, etc).
    let runtime = NativeSystemRuntime::new(tokio_rt.handle().clone());

    // Simple wrapper around a database engine and a single session connected to
    // that db engine.
    let engine = SingleUserEngine::try_new(executor, runtime.clone())?;
    // Register all default extensions (parquet, csv, etc). Alternatively
    // individual `ext_` crates can be used to selectively register extensions.
    glaredb_ext_default::register_all(&engine.engine)?;

    let (batches, schema) = tokio_rt.block_on(async {
        // Begin executeion of a single query. `query` expects a single sql
        // statement, `query_many` can be used to execute multiple statements
        // (with a bit more code required to do so).
        let mut q_res = engine
            .session()
            .query("SELECT avg(salary), count(*) FROM 's3://glaredb-public/userdata0.parquet")
            .await?;

        // Collect all batches. Execution is streaming, `collect` just fetches
        // everything.
        let batches = q_res.output.collect().await?;

        Ok::<_, Box<dyn Error>>((batches, q_res.output_schema))
    })?;

    // Create and display a pretty table containing the output data in batches.
    let table = PrettyTable::try_new(&schema, &batches, 100, None, PRETTY_COMPONENTS)?;
    println!("{table}");

    Ok(())
}

[div002123]

I've just published the crates to crates.io, so we can avoid the git cloning stuff.

Cargo.toml:

[package]
name = "glaredb_example"
version = "0.1.0"
edition = "2024"

[dependencies]
glaredb_core = { version = "25.6.2" }
glaredb_rt_native = { version = "25.6.2" }
glaredb_ext_default = { version = "25.6.2" }
src/main.rs:

use std::error::Error;

use glaredb_core::{
arrays::format::pretty::{components::PRETTY_COMPONENTS, table::PrettyTable},
engine::single_user::SingleUserEngine,
};
use glaredb_rt_native::runtime::{
NativeSystemRuntime, ThreadedNativeExecutor, new_tokio_runtime_for_io,
};

fn main() -> Result<(), Box> {
// Create a tokio runtime that's used for remote io (object storage). If a
// tokio runtime already exists, this can be skipped. A handle to the
// existing tokio runtime should be passed to NativeSystemRuntime.
let tokio_rt = new_tokio_runtime_for_io()?;
// Create an 'executor' for executing the queries. try_new will create a
// thread pool using all threads. try_new_with_num_threads may be used as
// an alternative.
let executor = ThreadedNativeExecutor::try_new()?;
// Create a 'runtime' for accessing external data (e.g. file systems, how
// http clients are created, etc).
let runtime = NativeSystemRuntime::new(tokio_rt.handle().clone());

// Simple wrapper around a database engine and a single session connected to
// that db engine.
let engine = SingleUserEngine::try_new(executor, runtime.clone())?;
// Register all default extensions (parquet, csv, etc). Alternatively
// individual `ext_` crates can be used to selectively register extensions.
glaredb_ext_default::register_all(&engine.engine)?;

let (batches, schema) = tokio_rt.block_on(async {
    // Begin executeion of a single query. `query` expects a single sql
    // statement, `query_many` can be used to execute multiple statements
    // (with a bit more code required to do so).
    let mut q_res = engine
        .session()
        .query("SELECT avg(salary), count(*) FROM 's3://glaredb-public/userdata0.parquet")
        .await?;

    // Collect all batches. Execution is streaming, `collect` just fetches
    // everything.
    let batches = q_res.output.collect().await?;

    Ok::<_, Box<dyn Error>>((batches, q_res.output_schema))
})?;

// Create and display a pretty table containing the output data in batches.
let table = PrettyTable::try_new(&schema, &batches, 100, None, PRETTY_COMPONENTS)?;
println!("{table}");

Ok(())

}

Thank you 💗