pub struct SqlClient  /* private fields */

High-level SQL client that wraps Kinetica with result parsing.

SqlClient executes SQL through Kinetica’s /execute/sql endpoint and returns SqlResults, with helpers for paging through large result sets.

Example

use gpudb_api::{Kinetica, KineticaOptions, SqlClient};
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let options = KineticaOptions::new();
    let kinetica = Arc::new(
        Kinetica::new(vec!["http://localhost:9191".to_string()], options).await?
    );

    let client = SqlClient::new(kinetica);

    // Execute a SELECT query
    let result = client.execute("SELECT * FROM my_table LIMIT 10").await?;
    println!("Found {} records", result.total_records());

    // Fetch a specific page
    let page = client.execute_paged("SELECT * FROM my_table ORDER BY id", 100, 50).await?;

    Ok(())
}

Implementations

Source

impl SqlClient

Source

pub fn new(kinetica: Arc<Kinetica>) -> Self

Create a new SqlClient wrapping a Kinetica instance

use gpudb_api::{Kinetica, KineticaOptions, SqlClient};
use std::sync::Arc;

let kinetica = Arc::new(
    Kinetica::new(vec!["http://localhost:9191".to_string()], KineticaOptions::new()).await?
);
let client = SqlClient::new(kinetica);

Source

pub fn with_defaults( kinetica: Arc<Kinetica>, encoding: &str, limit: i64, ) -> Self

Create a SqlClient with custom defaults

Source

pub fn kinetica(&self) -> &Arc<Kinetica>

Get a reference to the underlying Kinetica client

Source

pub async fn execute(&self, sql: &str) -> SqlOpResult<SqlResult>

Execute a raw SQL string

use gpudb_api::SqlClient;

let mut result = client.execute("SELECT COUNT(*) FROM users WHERE active = true").await?;
let count: i64 = result.scalar()?;

Source

pub async fn execute_paged( &self, sql: &str, offset: i64, limit: i64, ) -> SqlOpResult<SqlResult>

Execute a raw SQL string with custom limit and offset

use gpudb_api::SqlClient;

// Get records 10-19
let result = client.execute_paged("SELECT * FROM users", 10, 10).await?;

Source

pub async fn execute_with_options( &self, sql: &str, offset: i64, limit: i64, options: Option<HashMap<String, String>>, ) -> SqlOpResult<SqlResult>

Execute SQL with full control over options

use gpudb_api::SqlClient;
use std::collections::HashMap;

let mut options = HashMap::new();
options.insert("parallel_execution".to_string(), "true".to_string());

let result = client.execute_with_options(
    "SELECT * FROM large_table",
    0,
    1000,
    Some(options)
).await?;

Source

pub async fn fetch_next_page( &self, paging_table: &str, offset: i64, limit: i64, ) -> SqlOpResult<SqlResult>

Fetch the next page of results using a paging table

When a query returns has_more_records = true, Kinetica creates a temporary paging table containing the full result set. Use this method to fetch subsequent pages from that paging table.

paging_table - The paging table name from SqlResult::paging_table()
offset - The offset within the paging table to start fetching from
limit - The maximum number of records to fetch

use gpudb_api::SqlClient;

// Initial query with a limit
let mut result = client.execute_paged("SELECT * FROM large_table", 0, 1000).await?;
let mut all_rows = result.rows()?.to_vec();

// Fetch remaining pages if there are more records
let paging_table = result.paging_table().map(|s| s.to_string());
if let Some(pt) = paging_table {
    let mut offset = 1000i64;
    while result.has_more() {
        result = client.fetch_next_page(&pt, offset, 1000).await?;
        all_rows.extend(result.rows()?.to_vec());
        offset += 1000;
    }
}

Source

pub async fn execute_all( &self, sql: &str, page_size: i64, ) -> SqlOpResult<SqlResult>

Execute a query and iterate through all pages automatically

This method handles pagination transparently, fetching all pages from the paging table and returning an iterator over all results.

Warning: This loads all results into memory. For very large result sets, consider using execute_paged and fetch_next_page to process results in batches.

sql - The SQL query to execute
page_size - The number of records to fetch per page

use gpudb_api::SqlClient;

// Fetch all records, 10000 at a time
let mut result = client.execute_all("SELECT * FROM large_table", 10000).await?;

println!("Total records fetched: {}", result.row_count()?);

for row in result.rows()? {
    let id: i64 = row.get("column_1")?;
    // Process each row...
}

Source

pub async fn execute_paginated<F>( &self, sql: &str, page_size: i64, callback: F, ) ->SqlOpResult<PaginationStats>
where F: FnMut(SqlResult, u64) -> SqlOpResult<bool>,

Execute a query and process results page by page with a callback

This is the most memory-efficient way to process large result sets, as it only loads one page at a time.

sql - The SQL query to execute
page_size - The number of records to fetch per page
callback - A function called for each page of results

use gpudb_api::SqlClient;

let mut total_processed = 0u64;

client.execute_paginated(
    "SELECT * FROM large_table",
    10000,
    |mut page, page_num| {
        println!("Processing page {}", page_num);
        for row in page.rows()? {
            let id: i64 = row.get("column_1")?;
            // Process row...
        }
        Ok(true) // Return false to stop pagination early
    }
).await?;

Trait Implementations

Source

impl Clone for SqlClient

Source

fn clone(&self) -> SqlClient

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

​Example

​Implementations

​impl SqlClient

​pub fn new(kinetica: Arc<Kinetica>) -> Self

​pub fn with_defaults( kinetica: Arc<Kinetica>, encoding: &str, limit: i64, ) -> Self

​pub fn kinetica(&self) -> &Arc<Kinetica>

​pub async fn execute(&self, sql: &str) -> SqlOpResult<SqlResult>

​pub async fn execute_paged( &self, sql: &str, offset: i64, limit: i64, ) -> SqlOpResult<SqlResult>

​pub async fn execute_with_options( &self, sql: &str, offset: i64, limit: i64, options: Option<HashMap<String, String>>, ) -> SqlOpResult<SqlResult>

​pub async fn fetch_next_page( &self, paging_table: &str, offset: i64, limit: i64, ) -> SqlOpResult<SqlResult>

​pub async fn execute_all( &self, sql: &str, page_size: i64, ) -> SqlOpResult<SqlResult>

​pub async fn execute_paginated<F>( &self, sql: &str, page_size: i64, callback: F, ) ->SqlOpResult<PaginationStats> where F: FnMut(SqlResult, u64) -> SqlOpResult<bool>,

​Trait Implementations

​impl Clone for SqlClient

​fn clone(&self) -> SqlClient

​fn clone_from(&mut self, source: &Self)

Example

Implementations

impl SqlClient

pub fn new(kinetica: Arc<Kinetica>) -> Self

pub fn with_defaults( kinetica: Arc<Kinetica>, encoding: &str, limit: i64, ) -> Self

pub fn kinetica(&self) -> &Arc<Kinetica>

pub async fn execute(&self, sql: &str) -> SqlOpResult<SqlResult>

pub async fn execute_paged( &self, sql: &str, offset: i64, limit: i64, ) -> SqlOpResult<SqlResult>

pub async fn execute_with_options( &self, sql: &str, offset: i64, limit: i64, options: Option<HashMap<String, String>>, ) -> SqlOpResult<SqlResult>

pub async fn fetch_next_page( &self, paging_table: &str, offset: i64, limit: i64, ) -> SqlOpResult<SqlResult>

pub async fn execute_all( &self, sql: &str, page_size: i64, ) -> SqlOpResult<SqlResult>

pub async fn execute_paginated<F>( &self, sql: &str, page_size: i64, callback: F, ) ->SqlOpResult<PaginationStats>
where F: FnMut(SqlResult, u64) -> SqlOpResult<bool>,

Trait Implementations

impl Clone for SqlClient

fn clone(&self) -> SqlClient

fn clone_from(&mut self, source: &Self)