Struct Context 

pub struct Context { /* private fields */ }

A SQL execution context that can register multiple tables and execute queries.

This is the preferred entrypoint for JOINs across multiple DataFrames.

Example (JOIN)

use rust_data_processing::pipeline::DataFrame;
use rust_data_processing::sql;
use rust_data_processing::types::{DataSet, DataType, Field, Schema, Value};

let people = DataSet::new(
    Schema::new(vec![
        Field::new("id", DataType::Int64),
        Field::new("name", DataType::Utf8),
    ]),
    vec![
        vec![Value::Int64(1), Value::Utf8("Ada".to_string())],
        vec![Value::Int64(2), Value::Utf8("Grace".to_string())],
    ],
);
let scores = DataSet::new(
    Schema::new(vec![
        Field::new("id", DataType::Int64),
        Field::new("score", DataType::Float64),
    ]),
    vec![vec![Value::Int64(1), Value::Float64(98.5)]],
);

let mut ctx = sql::Context::new();
ctx.register("people", &DataFrame::from_dataset(&people)?)?;
ctx.register("scores", &DataFrame::from_dataset(&scores)?)?;

let out = ctx
    .execute("SELECT p.id, p.name, s.score FROM people p JOIN scores s ON p.id = s.id")?
    .collect()?;

assert_eq!(out.row_count(), 1);

Implementations

impl Context

pub fn new() -> Self

Create an empty SQL context.

pub fn register(&mut self, name: &str, df: &DataFrame) -> IngestionResult<()>

Register a DataFrame as a SQL table.

pub fn execute(&mut self, sql: &str) -> IngestionResult<DataFrame>

Execute a SQL query and return a lazy DataFrame.

Trait Implementations

impl Default for Context

fn default() -> Self

Returns the “default value” for a type.