Transform data with Flux

This guide demonstrates using Flux functions to transform your data. It walks through creating a Flux script that partitions data into windows of time, averages the s in each window, and outputs the averages as a new table.

If you’re not familiar with how Flux structures and operates on data, see .

Use the query built in the previous Query data from InfluxDB guide, but update the range to pull data from the last hour:

Flux functions

Flux provides a number of functions that perform specific operations, transformations, and tasks. You can also create custom functions in your Flux queries. Functions are covered in detail in the documentation.

A common type of function used when transforming data queried from InfluxDB is an aggregate function. Aggregate functions take a set of _values in a table, aggregate them, and transform them into a new value.

This example uses the mean() function to average values within each time window.

The following example walks through the steps required to window and aggregate data, but there is a that does it for you. It’s just good to understand the steps in the process.

Calendar months and years

every supports all , including calendar months (1mo) and years (1y).

For this example, window data in five minute intervals (5m).

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "cpu" and r._field == "usage_system" and r.cpu == "cpu-total")

As data is gathered into windows of time, each window is output as its own table. When visualized, each table is assigned a unique color.

Aggregate windowed data

Flux aggregate functions take the _values in each table and aggregate them in some way. Use the to average the _values of each table.

As rows in each window are aggregated, their output table contains only a single row with the aggregate value. Windowed tables are all still separate and, when visualized, will appear as single, unconnected points.

A _time column is required in the next operation. To add one, use the to duplicate the _stop column as the _time column for each windowed table.

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> mean()
    |> duplicate(column: "_stop", as: "_time")

Unwindow aggregate tables

Use the window() function with the every: inf parameter to gather all points into a single, infinite window.

Once ungrouped and combined into a single table, the aggregate data points will appear connected in your visualization.

This may seem like a lot of coding just to build a query that aggregates data, however going through the process helps to understand how data changes “shape” as it is passed through each function.

Flux provides (and allows you to create) “helper” functions that abstract many of these steps. The same operation performed in this guide can be accomplished using .

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "cpu" and r._field == "usage_system" and r.cpu == "cpu-total")
    |> aggregateWindow(every: 5m, fn: mean)

Congratulations!

You have now constructed a Flux query that uses Flux functions to transform your data. There are many more ways to manipulate your data using both Flux’s primitive functions and your own custom functions, but this is a good introduction into the basic syntax and query structure.

Related

• window() function