FluxLang 101 Cheat Sheet

A Programming › Golang cheat sheet in English by rictomm

The basic functionalities of Flux Language

5,570 views 927 downloads 13 Oct 2022 History

PRs

A Table of Measure

Measurement	Sensor	Temperature	Timestamp
iot-oven	S1	290	1633953600000000000
iot-oven	S2	105	1633953615000000000
iot-oven	S1	305	1633953660000000000
iot-oven	S2	120	1633953675000000000

Basic Filtering

from(bucket: "training")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "iot-oven")
  |> filter(fn: (r) => r._field == "temperature")
  |> filter(fn: (r) => r.sensor == "S2")
  |> filter(fn: (r) => r._value < 100)

The range clause allows to filter by time creating a time windodw
The filter clause reduces the ammount of records and can be applied on the measurements, fields, tags, and field/tag keys.

Functions

Flux transformations take a stream of tables as input, transform the data in some way, and output a stream of tables.

Aggregation

from(bucket: "training")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "iot-oven")
  |> group(columns: ["_field"])
  |> mean()

Flux aggregate functions are transformations aggregate values from input tables in some way.

Selector

from(bucket: "training")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "iot-oven")
  |> filter(fn: (r) => r.sensor == "S1")
  |> group(columns: ["_field"])
  |> last()

Flux selector functions are transformations that return one or more record per input table.

Conditional Expressions

... |> map(fn: (r) => ({
      r with _value:
                    if r._value == true then 1
                    else 0  }))

Conditional expressions evaluate a boolean-valued condition. If the result is true, the expression that follows the then keyword is evaluated and returned.

Line Protocol

Advanced Windowing

from(bucket: "training")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "iot-oven")
  |> filter(fn: (r) => r._field == "temperature")
  |> filter(fn: (r) => r.sensor == "S1")
  |> aggregateWindow(every: 2m, fn: mean)

aggregateWindow() downsamples data by grouping data into fixed windows of time and applying an aggregate or selector function to each window.

NOTE The flag createEmpty: false can be used to consider only the windows that contains data (its default value is true)

Map and Custom Functions

from(bucket: "training") ...  
        |> map(fn: (r) => ({ r with correctValue: r._value - 5.0 }))

Note the r with clause maintains alla the original columns and adds the new one.

Custom pipe forwardable function

adjValues = (tables=<-, x) =>
  tables
    |> map(fn: (r) => ({ r with correctValue: r._value + x}))

from(bucket: "training")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "iot-oven")
  |> adjValues(x:-5.0)

Most Flux functions manipulate data piped-forward into the function. In order for a custom function to process piped-forward data, one of the function parameters must capture the input tables using the <- pipe-receive expression.

Joins

from(bucket: "training")
...
join(tables: {s1: hs1, s2: hs2}, on: ["_time"], method: "inner")

The join() function merges two or more input streams, whose values are equal on a set of common columns, into a single output stream.

Comments

No comments yet.