使用 Flux 查询数据

from(bucket: "example-bucket")
    |> range(start: -1h)
    |> filter(fn: (r) => r._measurement == "example-measurement" and r.tag == "example-tag")
    |> filter(fn: (r) => r._field == "example-field")

data
    |> group(columns: ["host"], mode: "by")

data
    |> sort(columns: ["host", "_value"])
    |> limit(n: 4)

data
    |> aggregateWindow(every: 20m, fn: mean)

import "influxdata/influxdb/schema"

// List buckets
buckets()

// List measurements
schema.measurements(bucket: "example-bucket")

// List field keys
schema.fieldKeys(bucket: "example-bucket")

// List tag keys
schema.tagKeys(bucket: "example-bucket")

// List tag values
schema.tagValues(bucket: "example-bucket", tag: "example-tag")

data
    |> map(fn: (r) => ({ r with _value: r._value * r._value }))

data
  |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
  |> map(
      fn: (r) => ({
          _time: r._time,
          _field: "used_percent",
          _value: float(v: r.used) / float(v: r.total) * 100.0,
      }),
  )

data
    |> increase()

data
    |> movingAverage(n: 3)

data
    |> timedMovingAverage(every: 2m, period: 4m)

data
    |> derivative(unit: 1m, nonNegative: true)

import "experimental/aggregate"

data
    |> aggregate.rate(every: 20m, unit: 1m)

data
    |> histogram(
        column: "_value",
        upperBoundColumn: "le",
        countColumn: "_value",
        bins: [100.0, 200.0, 300.0, 400.0],
    )

data
    |> fill(usePrevious: true)

data
    |> fill(value: 0.0)

data
    |> median()

data
    |> quantile(q: 0.99, method: "estimate_tdigest")

import "join"
import "sql"

left =
    from(bucket: "example-bucket-1")
        |> range(start: "-1h")
        |> filter(fn: (r) => r._measurement == "example-m")
        |> filter(fn: (r) => r._field == "example-f")
        |> drop(columns: ["_measurement", "_field"])

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

join.inner(
    left: left |> group(),
    right: right,
    on: (l, r) => l.sensorID == r.ID,
    as: (l, r) => ({l with expired: r.expired}),
)
    |> group(columns: ["_time", "_value"], mode: "except")

data
    |> cumulativeSum()

data
    |> first()

data
    |> last()

data
  |> filter(fn: (r) => exists r._value)

multByX = (tables=<-, x) => tables
    |> map(fn: (r) => ({r with _value: r._value * x}))

data
    |> multByX(x: 2.0)

scalarValue = (tables=<-) => {
    _record = tables
        |> findRecord(fn: (key) => true, idx: 0)

    return _record._value
}

import "sql"

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

if color == "green" then "008000" else "ffffff"

data
    |> filter(fn: (r) => r.tag =~ /^foo[1-3]/)

import "experimental/geo"

sampleGeoData
    |> geo.filterRows(region: {lat: 30.04, lon: 31.23, radius: 200.0})
    |> geo.groupByArea(newColumn: "geoArea", level: 5)

import "array"
import "runtime"

array.from(rows: [{version: runtime.version()}])