Struct Client 

pub struct Client { /* private fields */ }

InfluxDB 2.x streaming client.

This client executes Flux queries and returns results as an async stream, allowing you to process millions of rows without loading them all into memory.

Example

use influxdb_stream::Client;
use futures::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("http://localhost:8086", "my-org", "my-token");

    let mut stream = client.query_stream(r#"
        from(bucket: "sensors")
        |> range(start: -1h)
        |> filter(fn: (r) => r._measurement == "temperature")
    "#).await?;

    while let Some(record) = stream.next().await {
        let record = record?;
        println!("Got: {:?}", record);
    }

    Ok(())
}

Implementations

impl Client

pub fn new( url: impl Into<String>, org: impl Into<String>, token: impl Into<String>, ) -> Self

Create a new InfluxDB client.

Arguments

• url - Base URL of the InfluxDB server (e.g., “http://localhost:8086”)
• org - Organization name
• token - Authentication token

Panics

Panics if the provided URL is invalid.

pub fn with_http_client( http: Client, url: impl Into<String>, org: impl Into<String>, token: impl Into<String>, ) -> Self

Create a new client with a custom reqwest client.

This allows you to configure timeouts, proxies, TLS settings, etc.

pub fn url(&self) -> &Url

Get the base URL.

pub fn org(&self) -> &str

Get the organization name.

pub async fn query_stream( &self, query: impl Into<String>, ) -> Result<Pin<Box<dyn Stream<Item = Result<FluxRecord>> + Send>>>

Execute a Flux query and return results as an async stream.

This is the primary method for querying InfluxDB. Results are streamed one record at a time, so you can process arbitrarily large result sets without running out of memory.

Arguments

• query - Flux query string

Returns

A stream of Result<FluxRecord>. Each item is either a successfully parsed record or an error.

Example

use futures::StreamExt;

let mut stream = client.query_stream("from(bucket: \"test\") |> range(start: -1h)").await?;

let mut count = 0;
while let Some(result) = stream.next().await {
    let record = result?;
    count += 1;
}
println!("Processed {} records", count);

pub async fn query(&self, query: impl Into<String>) -> Result<Vec<FluxRecord>>

Execute a Flux query and collect all results into a Vec.

Warning: This loads all results into memory. For large result sets, use query_stream() instead to process records one at a time.

Arguments

• query - Flux query string

Returns

A vector of all records from the query.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

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

Performs copy-assignment from source.