Documentation

InfluxDB OSS

v2

Flux vs InfluxQL

Flux is an alternative to InfluxQL and other SQL-like query languages for querying and analyzing data. Flux uses functional language patterns that overcome many InfluxQL limitations. Check out the following distinctions between Flux and InfluxQL:

Tasks possible with Flux

Joins

InfluxQL has never supported joins. Although you can use a join in a TICKscript, TICKscript’s join capabilities are limited. Flux’s join() function lets you join data from any bucket, any measurement, and on any columns as long as each data set includes the columns to join on.

dataStream1 = from(bucket: "example-bucket1")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "network" and r._field == "bytes-transferred")

dataStream2 = from(bucket: "example-bucket2")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "httpd" and r._field == "requests-per-sec")

join(tables: {d1: dataStream1, d2: dataStream2}, on: ["_time", "_stop", "_start", "host"])

For an in-depth walkthrough of using the join() function, see how to join data with Flux.

Math across measurements

Being able to perform joins across measurements lets you calculate data from separate measurements. The example below takes data from two measurements, mem and processes, joins them, and then calculates the average amount of memory used per running process:

// Memory used (in bytes)
memUsed = from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "mem" and r._field == "used")

// Total processes running
procTotal = from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "processes" and r._field == "total")

// Join memory used with total processes to calculate
// the average memory (in MB) used for running processes.
join(tables: {mem: memUsed, proc: procTotal}, on: ["_time", "_stop", "_start", "host"])
    |> map(fn: (r) => ({_time: r._time, _value: r._value_mem / r._value_proc / 1000000}))

Sort by tags

InfluxQL’s sorting capabilities only let you control the sort order of time using the ORDER BY time clause. The Flux sort() function sorts records based on a list of columns. Depending on the column type, Flux sorts records lexicographically, numerically, or chronologically.

from(bucket: "example-bucket")
    |> range(start: -12h)
    |> filter(fn: (r) => r._measurement == "system" and r._field == "uptime")
    |> sort(columns: ["region", "host", "_value"])

Group by any column

InfluxQL lets you group by tags or time intervals only. Flux lets you group data by any column, including _value. Use the Flux group() function to define which columns to group data by.

from(bucket:"example-bucket")
    |> range(start: -12h)
    |> filter(fn: (r) => r._measurement == "system" and r._field == "uptime" )
    |> group(columns:["host", "_value"])

Window by calendar months and years

InfluxQL does not support windowing data by calendar months and years due to their varied lengths. Flux supports calendar month and year duration units (1mo, 1y) and lets you window and aggregate data by calendar month and year.

from(bucket:"example-bucket")
    |> range(start:-1y)
    |> filter(fn: (r) => r._measurement == "mem" and r._field == "used_percent" )
    |> aggregateWindow(every: 1mo, fn: mean)

Work with multiple data sources

InfluxQL can only query data stored in InfluxDB. Flux can query data from other data sources such as CSV, PostgreSQL, MySQL, Google BigTable, and more. Join that data with data in InfluxDB to enrich query results.

import "csv"
import "sql"

csvData = csv.from(csv: rawCSV)

sqlData = sql.from(
    driverName: "postgres",
    dataSourceName: "postgresql://user:password@localhost",
    query: "SELECT * FROM example_table",
)

data = from(bucket: "example-bucket")
    |> range(start: -24h)
    |> filter(fn: (r) => r._measurement == "sensor")

auxData = join(tables: {csv: csvData, sql: sqlData}, on: ["sensor_id"])
enrichedData = join(tables: {data: data, aux: auxData}, on: ["sensor_id"])

enrichedData
    |> yield(name: "enriched_data")

For an in-depth walkthrough of querying SQL data, see Query SQL data sources.

DatePart-like queries

InfluxQL doesn’t support DatePart-like queries that only return results during specified hours of the day. The Flux hourSelection function returns only data with time values in a specified hour range.

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "cpu" and r.cpu == "cpu-total")
    |> hourSelection(start: 9, stop: 17)

Pivot

Pivoting data tables isn’t supported in InfluxQL. Use the Flux pivot() function to pivot data tables by rowKey, columnKey, and valueColumn parameters.

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "cpu" and r.cpu == "cpu-total")
    |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")

Histograms

Generating histograms isn’t supported in InfluxQL. Use the Flux histogram() function to generate a cumulative histogram.

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "mem" and r._field == "used_percent")
    |> histogram(buckets: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100])

For more examples, see how to create histograms with Flux.

Covariance

Flux provides functions for simple covariance calculations. Use the covariance() function to calculate the covariance between two columns and the cov() function to calculate the covariance between two data streams.

Covariance between two columns
from(bucket: "example-bucket")
    |> range(start:-5m)
    |> covariance(columns: ["x", "y"])
Covariance between two streams of data
table1 = from(bucket: "example-bucket")
    |> range(start: -15m)
    |> filter(fn: (r) => r._measurement == "measurement_1")

table2 = from(bucket: "example-bucket")
    |> range(start: -15m)
    |> filter(fn: (r) => r._measurement == "measurement_2")

cov(x: table1, y: table2, on: ["_time", "_field"])

Cast booleans to integers

InfluxQL supports type casting for numeric data types (floats to integers and vice versa) only. Use Flux type conversion functions to perform many more type conversions, including casting boolean values to integers.

Cast boolean field values to integers
from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "m" and r._field == "bool_field")
    |> toInt()

String manipulation and data shaping

InfluxQL doesn’t support string manipulation when querying data. Use Flux Strings package functions to operate on string data. Combine functions in this package with the map() function to perform operations like sanitizing and normalizing strings.

import "strings"

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "weather" and r._field == "temp")
    |> map(
        fn: (r) => ({
            r with
            location: strings.toTitle(v: r.location),
            sensor: strings.replaceAll(v: r.sensor, t: " ", u: "-"),
            status: strings.substring(v: r.status, start: 0, end: 8)
        })
    )

Work with geo-temporal data

InfluxQL doesn’t support working with geo-temporal data. The Flux Geo package is a collection of functions that let you shape, filter, and group geo-temporal data.

import "experimental/geo"

from(bucket: "geo/autogen")
    |> range(start: -1w)
    |> filter(fn: (r) => r._measurement == "taxi")
    |> geo.shapeData(latField: "latitude", lonField: "longitude", level: 20)
    |> geo.filterRows(region: {lat: 40.69335938, lon: -73.30078125, radius: 20.0}, strict: true)
    |> geo.asTracks(groupBy: ["fare-id"])

InfluxQL and Flux parity

We’re continuing to add functions to complete parity between Flux and InfluxQL. The table below shows InfluxQL statements, clauses, and functions along with their equivalent Flux functions.

For a complete list of Flux functions, view all Flux functions.

InfluxQL Flux Functions
SELECT filter()
WHERE filter(), range()
GROUP BY group()
INTO to()
ORDER BY sort()
LIMIT limit()
SLIMIT –
OFFSET –
SOFFSET –
SHOW DATABASES buckets()
SHOW MEASUREMENTS schema.measurements
SHOW FIELD KEYS keys()
SHOW RETENTION POLICIES buckets()
SHOW TAG KEYS schema.tagKeys(), schema.measurementTagKeys()
SHOW TAG VALUES schema.tagValues(), schema.measurementTagValues()
SHOW SERIES –
CREATE DATABASE N/A
DROP DATABASE N/A
DROP SERIES N/A
DELETE N/A
DROP MEASUREMENT N/A
DROP SHARD N/A
CREATE RETENTION POLICY N/A
ALTER RETENTION POLICY N/A
DROP RETENTION POLICY N/A
COUNT count()
DISTINCT distinct()
INTEGRAL integral()
MEAN mean()
MEDIAN median()
MODE mode()
SPREAD spread()
STDDEV stddev()
SUM sum()
BOTTOM bottom()
FIRST first()
LAST last()
MAX max()
MIN min()
PERCENTILE quantile()
SAMPLE sample()
TOP top()
ABS math.abs()
ACOS math.acos()
ASIN math.asin()
ATAN math.atan()
ATAN2 math.atan2()
CEIL math.ceil()
COS math.cos()
CUMULATIVE_SUM cumulativeSum()
DERIVATIVE derivative()
DIFFERENCE difference()
ELAPSED elapsed()
EXP math.exp()
FLOOR math.floor()
HISTOGRAM histogram()
LN math.log()
LOG math.logb()
LOG2 math.log2()
LOG10 math.log10()
MOVING_AVERAGE movingAverage()
NON_NEGATIVE_DERIVATIVE derivative(nonNegative:true)
NON_NEGATIVE_DIFFERENCE difference(nonNegative:true)
POW math.pow()
ROUND math.round()
SIN math.sin()
SQRT math.sqrt()
TAN math.tan()
HOLT_WINTERS holtWinters()
CHANDE_MOMENTUM_OSCILLATOR chandeMomentumOscillator()
EXPONENTIAL_MOVING_AVERAGE exponentialMovingAverage()
DOUBLE_EXPONENTIAL_MOVING_AVERAGE doubleEMA()
KAUFMANS_EFFICIENCY_RATIO kaufmansER()
KAUFMANS_ADAPTIVE_MOVING_AVERAGE kaufmansAMA()
TRIPLE_EXPONENTIAL_MOVING_AVERAGE tripleEMA()
TRIPLE_EXPONENTIAL_DERIVATIVE tripleExponentialDerivative()
RELATIVE_STRENGTH_INDEX relativeStrengthIndex()

Was this page helpful?

Thank you for your feedback!

© 2024 InfluxData, Inc.

What is your InfluxDB OSS URL?

Customize your InfluxDB OSS URL and we’ll update code examples for you.

Default
Custom

For more information, see InfluxDB OSS URLs.

Thank you for your feedback!

Let us know what we can do better:

Thank you!

No thanks

Introducing InfluxDB Clustered

A highly available InfluxDB 3.0 cluster on your own infrastructure.

InfluxDB Clustered is a highly available InfluxDB 3.0 cluster built for high write and query workloads on your own infrastructure.

InfluxDB Clustered is currently in limited availability and is only available to a limited group of InfluxData customers. If interested in being part of the limited access group, please contact the InfluxData Sales team.

Learn more
Contact InfluxData Sales

The future of Flux

Flux is going into maintenance mode. You can continue using it as you currently are without any changes to your code.

Flux is going into maintenance mode and will not be supported in InfluxDB 3.0. This was a decision based on the broad demand for SQL and the continued growth and adoption of InfluxQL. We are continuing to support Flux for users in 1.x and 2.x so you can continue using it with no changes to your code. If you are interested in transitioning to InfluxDB 3.0 and want to future-proof your code, we suggest using InfluxQL.

For information about the future of Flux, see the following: