Struct QueryBuilder 

pub struct QueryBuilder { /* private fields */ }

A builder for Flux queries

let query = QueryBuilder::from("telegraf/autogen")
    .range_start(Duration::Minutes(-15))
    .filter(
        r#"r._measurement == "cpu" and
        r._field == "usage_system" and
        r.cpu == "cpu-total""#
    )
    .build();

assert_eq!(
    query.as_ref(),
    r#"from(bucket: "telegraf/autogen")
  |> range(start: -15m)
  |> filter(fn: (r) =>
    r._measurement == "cpu" and
    r._field == "usage_system" and
    r.cpu == "cpu-total"
  )
  |> yield()"#,
);

Implementations

impl QueryBuilder

pub fn from<T>(bucket: T) -> Self

where T: Into<String>,

Create a query selecting from a bucket.

pub fn range_start<T>(self, start: T) -> Self

where T: Into<InstantOrDuration>,

Restrict query results to a start time

pub fn range_stop<T>(self, stop: T) -> Self

where T: Into<InstantOrDuration>,

Restrict query results to a stop time

pub fn range<T, S>(self, start: T, stop: S) -> Self

where T: Into<InstantOrDuration>, S: Into<InstantOrDuration>,

Restrict query results to a between two instants

pub fn filter<T>(self, filter: T) -> Self

where T: Into<String>,

Add a filter to the query

pub fn window<T>(self, every: T) -> Self

where T: Into<Duration>,

Add a window to the query

pub fn aggregate<T>(self, fn_: T) -> Self

where T: Into<String>,

Aggregate results

pub fn mean(self) -> Self

Aggregate results using the mean function

pub fn duplicate<T, S>(self, column: T, as_: S) -> Self

where T: Into<String>, S: Into<String>,

Duplicate fields

pub fn aggregate_window<T, S>(self, fn_: S, every: Duration) -> Self

where T: Into<String>, S: Into<String>,

Aggregate results over a window

pub fn build(self) -> Query

Create the Flux query