Crate exarrow_rs 

exarrow-rs

ADBC-compatible driver for Exasol with Apache Arrow data format support.

This library provides high-performance database connectivity for Exasol using the ADBC (Arrow Database Connectivity) interface. It enables efficient data transfer using the Apache Arrow columnar format, making it ideal for analytical workloads and data science applications.

Features

• ADBC Interface: Standard Arrow Database Connectivity driver
• Query Execution: Execute SQL queries and retrieve results as Arrow RecordBatches
• Bulk Import: Import data from CSV, Parquet, and Arrow RecordBatches
• Bulk Export: Export data to CSV, Parquet, and Arrow RecordBatches
• Streaming: Memory-efficient streaming for large datasets
• Compression: Support for gzip, bzip2, snappy, lz4, and zstd compression

Connect

use exarrow_rs::adbc::{Driver, Database, Connection};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let driver = Driver::new();
    // Schema in the URI is automatically opened with OPEN SCHEMA after login.
    let database = driver.open(
        "exasol://sys:exasol@localhost:8563/my_schema?validateservercertificate=0"
    )?;
    let mut connection = database.connect().await?;
    println!("Connected: session {}", connection.session_id());
    connection.close().await?;
    Ok(())
}

Execute a query

use exarrow_rs::adbc::{Driver, Connection};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let driver = Driver::new();
    let database = driver.open(
        "exasol://sys:exasol@localhost:8563/my_schema?validateservercertificate=0"
    )?;
    let mut connection = database.connect().await?;

    let batches = connection.query("SELECT id, name FROM users ORDER BY id").await?;
    let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
    println!("Fetched {} rows across {} batch(es)", total_rows, batches.len());

    connection.close().await?;
    Ok(())
}

Import data

use exarrow_rs::adbc::{Driver, Connection};
use exarrow_rs::import::{CsvImportOptions, ParquetImportOptions};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let driver = Driver::new();
    let database = driver.open(
        "exasol://sys:exasol@localhost:8563/my_schema?validateservercertificate=0"
    )?;
    let mut connection = database.connect().await?;

    // Import CSV files
    let csv_files = vec![PathBuf::from("/data/part1.csv"), PathBuf::from("/data/part2.csv")];
    let rows = connection
        .import_csv_from_files("users", csv_files, CsvImportOptions::default())
        .await?;
    println!("Imported {} rows from CSV", rows);

    // Import Parquet files
    let parquet_files = vec![PathBuf::from("/data/snapshot.parquet")];
    let rows = connection
        .import_parquet_from_files("users", parquet_files, ParquetImportOptions::default())
        .await?;
    println!("Imported {} rows from Parquet", rows);

    connection.close().await?;
    Ok(())
}

Re-exports

pub use adbc::Connection;

pub use adbc::Database;

pub use adbc::Driver;

pub use adbc::Statement;

pub use arrow_conversion::ArrowConverter;

pub use error::ConnectionError;

pub use error::ConversionError;

pub use error::ExasolError;

pub use error::QueryError;

pub use types::ExasolType;

pub use types::TypeMapper;

pub use import::import_from_arrow_ipc;

pub use import::import_from_callback;

pub use import::import_from_file;

pub use import::import_from_iter;

pub use import::import_from_parquet;

pub use import::import_from_parquet_stream;

pub use import::import_from_record_batch;

pub use import::import_from_record_batches;

pub use import::import_from_stream;

pub use import::ArrowImportOptions;

pub use import::ArrowToCsvWriter;

pub use import::CsvImportOptions;

pub use import::CsvWriterOptions;

pub use import::DataPipeSender;

pub use import::ImportError;

pub use import::ParquetImportOptions;

pub use export::csv_to_record_batches;

pub use export::exasol_types_to_arrow_schema;

pub use export::export_to_arrow_ipc;

pub use export::export_to_callback;

pub use export::export_to_file;

pub use export::export_to_list;

pub use export::export_to_parquet;

pub use export::export_to_parquet_stream;

pub use export::export_to_parquet_via_transport;

pub use export::export_to_record_batches;

pub use export::export_to_stream;

pub use export::ArrowExportOptions;

pub use export::CsvExportOptions;

pub use export::CsvToArrowReader;

pub use export::DataPipeReceiver;

pub use export::ExportError;

pub use export::ParquetCompression;

pub use export::ParquetExportOptions;

pub use query::export::Compression;

pub use query::export::DelimitMode;

pub use query::export::ExportQuery;

pub use query::export::ExportSource;

pub use query::export::RowSeparator;

pub use query::import::Compression as ImportCompression;

pub use query::import::ImportQuery;

pub use query::import::RowSeparator as ImportRowSeparator;

pub use query::import::TrimMode;

pub use query::statement::Parameter;

pub use query::statement::StatementType;

pub use query::PreparedStatement;

pub use query::QueryMetadata;

pub use query::ResultSet;

pub use query::ResultSetIterator;

pub use adbc_ffi::FfiConnection;

pub use adbc_ffi::FfiDatabase;

pub use adbc_ffi::FfiDriver;

pub use adbc_ffi::FfiStatement;

Modules

adbc

ADBC (Arrow Database Connectivity) interface implementation.

adbc_ffi

ADBC FFI-compatible trait implementations.

arrow_conversion

Arrow data format conversion utilities.

connection

Connection management for Exasol database connections.

error

Error types for exarrow-rs.

export

Export functionality for exporting data from Exasol.

import

Import functionality for Exasol data.

query

Query execution and result handling.

transport

Transport layer for Exasol database communication.

types

Type mapping between Exasol and Arrow data types.