Upgrade to Pro — share decks privately, control downloads, hide ads and more …

IFQL and the future of InfluxData

Paul Dix
February 13, 2018

IFQL and the future of InfluxData

Talk at InfluxDays NYC

Paul Dix

February 13, 2018
Tweet

More Decks by Paul Dix

Other Decks in Technology

Transcript

  1. IFQL and the future of InfluxData Paul Dix Founder &

    CTO @pauldix paul@influxdata.com
  2. Vaguely Familiar select percentile(90, value) from cpu where time >

    now() - 1d and “host” = ‘serverA’ group by time(10m)
  3. Kapacitor’s TICKscript stream |from() .database('telegraf') .measurement('cpu') .groupBy(*) |window() .period(5m) .every(5m)

    .align() |mean('usage_idle') .as('usage_idle') |influxDBOut() .database('telegraf') .retentionPolicy('autogen') .measurement('mean_cpu_idle') .precision('s')
  4. { "operations": [ { "id": "select0", "kind": "select", "spec": {

    "database": "foo", "hosts": null } }, { "id": "where1", "kind": "where", "spec": { "expression": { "root": { "type": "binary", "operator": "and", "left": { "type": "binary", "operator": "and", "left": { "type": "binary", "operator": "==", "left": { "type": "reference", "name": "_measurement", "kind": "tag" }, "right": { "type": "stringLiteral", "value": "cpu" } }, Query represented as DAG in JSON
  5. // get the last value written for anything from a

    given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> last()
  6. // get the last value written for anything from a

    given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> last() Result: _result Block: keys: [_field, _measurement, host, region] bounds: [1677-09-21T00:12:43.145224192Z, 2018-02-12T15:53:04.361902250Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- 2018-02-12T15:53:00.000000000Z usage_system cpu server0 east 60.6284 Block: keys: [_field, _measurement, host, region] bounds: [1677-09-21T00:12:43.145224192Z, 2018-02-12T15:53:04.361902250Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- 2018-02-12T15:53:00.000000000Z usage_user cpu server0 east 39.3716
  7. // get the last minute of data from a specific

    // measurement & field & host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m)
  8. // get the last minute of data from a specific

    // measurement & field & host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) Result: _result Block: keys: [_field, _measurement, host, region] bounds: [2018-02-12T16:01:45.677502014Z, 2018-02-12T16:02:45.677502014Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- 2018-02-12T16:01:50.000000000Z usage_user cpu server0 east 50.549 2018-02-12T16:02:00.000000000Z usage_user cpu server0 east 35.4458 2018-02-12T16:02:10.000000000Z usage_user cpu server0 east 30.0493 2018-02-12T16:02:20.000000000Z usage_user cpu server0 east 44.3378 2018-02-12T16:02:30.000000000Z usage_user cpu server0 east 11.1584 2018-02-12T16:02:40.000000000Z usage_user cpu server0 east 46.712
  9. // get the mean in 10m intervals of last hour

    from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu") |> range(start:-1h) |> window(every:15m) |> mean() Result: _result Block: keys: [_field, _measurement, host, region] bounds: [2018-02-12T15:05:06.708945484Z, 2018-02-12T16:05:06.708945484Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- 2018-02-12T15:28:41.128654848Z usage_user cpu server0 east 50.72841444444444 2018-02-12T15:43:41.128654848Z usage_user cpu server0 east 51.19163333333333 2018-02-12T15:13:41.128654848Z usage_user cpu server0 east 45.5091088235294 2018-02-12T15:58:41.128654848Z usage_user cpu server0 east 49.65145555555555 2018-02-12T16:05:06.708945484Z usage_user cpu server0 east 46.41292368421052 Block: keys: [_field, _measurement, host, region] bounds: [2018-02-12T15:05:06.708945484Z, 2018-02-12T16:05:06.708945484Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- 2018-02-12T15:28:41.128654848Z usage_system cpu server0 east 49.27158555555556 2018-02-12T15:58:41.128654848Z usage_system cpu server0 east 50.34854444444444 2018-02-12T16:05:06.708945484Z usage_system cpu server0 east 53.58707631578949 2018-02-12T15:13:41.128654848Z usage_system cpu server0 east 54.49089117647058 2018-02-12T15:43:41.128654848Z usage_system cpu server0 east 48.808366666666664
  10. Functional // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m)
  11. Functional // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) built in functions
  12. Functional // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) anonymous functions
  13. Functional // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) pipe forward operator
  14. Named Parameters // get the last 1 hour written for

    anything from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) named parameters only!
  15. Inputs // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) no input
  16. Outputs // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) output is entire db
  17. Outputs // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) pipe that output to filter
  18. Filter function input // get the last 1 hour written

    for anything from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) anonymous filter function input is a single record {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  19. Filter function input // get the last 1 hour written

    for anything from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) A record looks like a flat object or row in a table {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  20. Record Properties // get the last 1 hour written for

    anything from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) tag key {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  21. Record Properties // get the last 1 hour written for

    anything from a given host from(db:"mydb") |> filter(fn: (r) => r.host == "server0") |> range(start:-1m) same as before {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  22. Special Properties starts with _ reserved for system attributes from(db:"mydb")

    |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  23. Special Properties works other way from(db:"mydb") |> filter(fn: (r) =>

    r["host"] == "server0" and r._measurement == "cpu" and r._field == "usage_user") |> range(start:-1m) |> max() {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  24. Special Properties _measurement and _field present for all InfluxDB data

    from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  25. Special Properties _value exists in all series from(db:"mydb") |> filter(fn:

    (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == “usage_user" and r[“_value"] > 50.0) |> range(start:-1m) |> max() {“_measurement”:”cpu”, ”_field”:”usage_user", “host":"server0", “region":"west", "_value":23.2}
  26. Filter function output // get the last 1 hour written

    for anything from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) filter function output is a boolean to determine if record is in set
  27. Filter Operators // get the last 1 hour written for

    anything from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) != =~ !~ in
  28. Filter Boolean Logic // get the last 1 hour written

    for anything from a given host from(db:"mydb") |> filter(fn: (r) => (r[“host"] == “server0" or r[“host"] == “server1") and r[“_measurement”] == “cpu") |> range(start:-1m) parens for precedence
  29. Function with explicit return // get the last 1 hour

    written for anything from a given host from(db:"mydb") |> filter(fn: (r) => {return r[“host"] == “server0"}) |> range(start:-1m) long hand function definition
  30. Outputs // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) filter output is set of data matching filter function
  31. Outputs // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) piped to range which further filters by a time range
  32. Outputs // get the last 1 hour written for anything

    from a given host from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1m) range output is the final query result
  33. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max()
  34. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() range and filter switched
  35. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() results the same Result: _result Block: keys: [_field, _measurement, host, region] bounds: [2018-02-12T17:52:02.322301856Z, 2018-02-12T17:53:02.322301856Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- 2018-02-12T17:53:02.322301856Z usage_user cpu server0 east 97.3174
  36. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() is this the same as the top two? from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() |> range(start:-1m)
  37. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() moving max to here changes semantics from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() |> range(start:-1m)
  38. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() here it operates on only the last minute of data from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() |> range(start:-1m)
  39. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() here it operates on data for all time from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() |> range(start:-1m)
  40. Does order matter? from(db:"mydb") |> filter(fn: (r) => r["host"] ==

    "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() then that result is filtered down to the last minute (which will likely be empty) from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() |> range(start:-1m)
  41. Optimization from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and

    r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max()
  42. Optimization from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and

    r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() this is more efficient
  43. Optimization from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and

    r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == "usage_user") |> max() query DAG different plan DAG same as one on left
  44. Optimization from(db:"mydb") |> filter(fn: (r) => r["host"] == "server0" and

    r["_measurement"] == "cpu" and r["_field"] == “usage_user” r[“_value"] > 22.0) |> range(start:-1m) |> max() from(db:"mydb") |> range(start:-1m) |> filter(fn: (r) => r["host"] == "server0" and r["_measurement"] == "cpu" and r["_field"] == “usage_user" r[“_value"] > 22.0) |> max() this does a full table scan
  45. Variables & Closures db = "mydb" measurement = "cpu" from(db:db)

    |> filter(fn: (r) => r._measurement == measurement and r.host == "server0") |> last()
  46. Variables & Closures db = "mydb" measurement = "cpu" from(db:db)

    |> filter(fn: (r) => r._measurement == measurement and r.host == "server0") |> last() anonymous filter function closure over surrounding context
  47. User Defined Functions db = "mydb" measurement = “cpu" fn

    = (r) => r._measurement == measurement and r.host == "server0" from(db:db) |> filter(fn: fn) |> last() assign function to variable fn
  48. User Defined Functions from(db:"mydb") |> filter(fn: (r) => r["_measurement"] ==

    "cpu" and r["_field"] == "usage_user" and r["host"] == "server0") |> range(start:-1h)
  49. User Defined Functions from(db:"mydb") |> filter(fn: (r) => r["_measurement"] ==

    "cpu" and r["_field"] == "usage_user" and r["host"] == "server0") |> range(start:-1h) get rid of some common boilerplate?
  50. User Defined Functions select = (db, m, f) => {

    return from(db:db) |> filter(fn: (r) => r._measurement == m and r._field == f) }
  51. User Defined Functions select = (db, m, f) => {

    return from(db:db) |> filter(fn: (r) => r._measurement == m and r._field == f) } select(db: "mydb", m: "cpu", f: "usage_user") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1h)
  52. User Defined Functions select = (db, m, f) => {

    return from(db:db) |> filter(fn: (r) => r._measurement == m and r._field == f) } select(m: "cpu", f: "usage_user") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1h) throws error error calling function "select": missing required keyword argument "db"
  53. Default Arguments select = (db="mydb", m, f) => { return

    from(db:db) |> filter(fn: (r) => r._measurement == m and r._field == f) } select(m: "cpu", f: "usage_user") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1h)
  54. Default Arguments select = (db="mydb", m, f) => { return

    from(db:db) |> filter(fn: (r) => r._measurement == m and r._field == f) } select(m: "cpu", f: "usage_user") |> filter(fn: (r) => r["host"] == "server0") |> range(start:-1h)
  55. Multiple Results to Client data = from(db:"mydb") |> filter(fn: (r)

    r._measurement == "cpu" and r._field == "usage_user") |> range(start: -4h) |> window(every: 5m) data |> min() |> yield(name: "min") data |> max() |> yield(name: "max") data |> mean() |> yield(name: "mean")
  56. Multiple Results to Client data = from(db:"mydb") |> filter(fn: (r)

    r._measurement == "cpu" and r._field == "usage_user") |> range(start: -4h) |> window(every: 5m) data |> min() |> yield(name: "min") data |> max() |> yield(name: "max") data |> mean() |> yield(name: "mean") Result: min Block: keys: [_field, _measurement, host, region] bounds: [2018-02-12T16:55:55.487457216Z, 2018-02-12T20:55:55.487457216Z) _time _field _measurement host region _value ------------------------------ --------------- --------------- --------------- --------------- ---------------------- name
  57. User Defined Pipe Forwardable Functions mf = (m, f, table=<-)

    => { return table |> filter(fn: (r) => r._measurement == m and r._field == f) } from(db:"mydb") |> mf(m: "cpu", f: "usage_user") |> filter(fn: (r) => r.host == "server0") |> last()
  58. User Defined Pipe Forwardable Functions mf = (m, f, table=<-)

    => { return table |> filter(fn: (r) => r._measurement == m and r._field == f) } from(db:"mydb") |> mf(m: "cpu", f: "usage_user") |> filter(fn: (r) => r.host == "server0") |> last() takes a table from a pipe forward by default
  59. User Defined Pipe Forwardable Functions mf = (m, f, table=<-)

    => { return table |> filter(fn: (r) => r._measurement == m and r._field == f) } from(db:"mydb") |> mf(m: "cpu", f: "usage_user") |> filter(fn: (r) => r.host == "server0") |> last() calling it, then chaining
  60. Passing as Argument mf = (m, f, table=<-) => {

    return table |> filter(fn: (r) => r._measurement == m and r._field == f) } sending the from as argument mf(m: "cpu", f: "usage_user", table: from(db:"mydb")) |> filter(fn: (r) => r.host == "server0") |> last()
  61. Passing as Argument mf = (m, f, table=<-) => filter(fn:

    (r) => r._measurement == m and r._field == f, table: table) rewrite the function to use argument mf(m: "cpu", f: "usage_user", table: from(db:"mydb")) |> filter(fn: (r) => r.host == "server0") |> last()
  62. Any pipe forward function can use arguments min(table: range(start: -1h,

    table: filter(fn: (r) => r.host == "server0", table: from(db: "mydb"))))
  63. package functions import ( "fmt" "github.com/influxdata/ifql/ifql" "github.com/influxdata/ifql/query" "github.com/influxdata/ifql/query/execute" "github.com/influxdata/ifql/query/plan" )

    const CountKind = "count" type CountOpSpec struct { } func init() { ifql.RegisterFunction(CountKind, createCountOpSpec) query.RegisterOpSpec(CountKind, newCountOp) plan.RegisterProcedureSpec(CountKind, newCountProcedure, CountKind) execute.RegisterTransformation(CountKind, createCountTransformation) } func createCountOpSpec(args map[string]ifql.Value, ctx ifql.Context) (query.OperationSpec, error) { if len(args) != 0 { return nil, fmt.Errorf(`count function requires no arguments`) } return new(CountOpSpec), nil } func newCountOp() query.OperationSpec { return new(CountOpSpec) } func (s *CountOpSpec) Kind() query.OperationKind { return CountKind }
  64. type CountProcedureSpec struct { } func newCountProcedure(query.OperationSpec) (plan.ProcedureSpec, error) {

    return new(CountProcedureSpec), nil } func (s *CountProcedureSpec) Kind() plan.ProcedureKind { return CountKind } func (s *CountProcedureSpec) Copy() plan.ProcedureSpec { return new(CountProcedureSpec) } func (s *CountProcedureSpec) PushDownRule() plan.PushDownRule { return plan.PushDownRule{ Root: SelectKind, Through: nil, } } func (s *CountProcedureSpec) PushDown(root *plan.Procedure, dup func() *plan.Procedure) { selectSpec := root.Spec.(*SelectProcedureSpec) if selectSpec.AggregateSet { root = dup() selectSpec = root.Spec.(*SelectProcedureSpec) selectSpec.AggregateSet = false selectSpec.AggregateType = "" return } selectSpec.AggregateSet = true selectSpec.AggregateType = CountKind }
  65. type CountAgg struct { count int64 } func createCountTransformation(id execute.DatasetID,

    mode execute.AccumulationMode, spec plan.ProcedureSpec, ctx execute.Context (execute.Transformation, execute.Dataset, error) { t, d := execute.NewAggregateTransformationAndDataset(id, mode, ctx.Bounds(), new(CountAgg)) return t, d, nil } func (a *CountAgg) DoBool(vs []bool) { a.count += int64(len(vs)) } func (a *CountAgg) DoUInt(vs []uint64) { a.count += int64(len(vs)) } func (a *CountAgg) DoInt(vs []int64) { a.count += int64(len(vs)) } func (a *CountAgg) DoFloat(vs []float64) { a.count += int64(len(vs)) } func (a *CountAgg) DoString(vs []string) { a.count += int64(len(vs)) } func (a *CountAgg) Type() execute.DataType { return execute.TInt } func (a *CountAgg) ValueInt() int64 { return a.count }
  66. Imports and Namespaces from(db:"mydb") |> filter(fn: (r) => r.host ==

    "server0") |> range(start: -1h) // square the value |> map(fn: (r) => r._value * r._value) shortcut for this?
  67. Imports and Namespaces from(db:"mydb") |> filter(fn: (r) => r.host ==

    "server0") |> range(start: -1h) // square the value |> map(fn: (r) => r._value * r._value) square = (table=<-) { table |> map(fn: (r) => r._value * r._value) }
  68. Imports and Namespaces import "github.com/pauldix/ifqlmath" from(db:"mydb") |> filter(fn: (r) =>

    r.host == "server0") |> range(start: -1h) |> ifqlmath.square()
  69. Imports and Namespaces import "github.com/pauldix/ifqlmath" from(db:"mydb") |> filter(fn: (r) =>

    r.host == "server0") |> range(start: -1h) |> ifqlmath.square() namespace
  70. Math across measurements foo = from(db: "mydb") |> filter(fn: (r)

    => r._measurement == "foo") |> range(start: -1h) bar = from(db: "mydb") |> filter(fn: (r) => r._measurement == "bar") |> range(start: -1h) join( tables: {foo:foo, bar:bar}, fn: (t) => t.foo._value + t.bar._value) |> yield(name: "foobar")
  71. Having Query from(db:"mydb") |> filter(fn: (r) => r._measurement == "cpu")

    |> range(start:-1h) |> window(every:10m) |> mean() // this is the having part |> filter(fn: (r) => r._value > 90)
  72. Grouping // group - average utilization across regions from(db:"mydb") |>

    filter(fn: (r) => r._measurement == "cpu" and r._field == "usage_system") |> range(start: -1h) |> group(by: ["region"]) |> window(every:10m) |> mean()
  73. Get Metadata from(db:"mydb") |> filter(fn: (r) => r._measurement == "cpu")

    |> range(start: -48h, stop: -47h) |> tagValues(key: "host")
  74. Get Metadata from(db:"mydb") |> filter(fn: (r) => r._measurement == "cpu")

    |> range(start: -48h, stop: -47h) |> group(by: ["measurement"], keep: ["host"]) |> distinct(column: "host")
  75. Get Metadata from(db:"mydb") |> filter(fn: (r) => r._measurement == "cpu")

    |> range(start: -48h, stop: -47h) |> tagValues(key: “host") |> count()
  76. Functions Implemented as IFQL // _sortLimit is a helper function,

    which sorts // and limits a table. _sortLimit = (n, desc, cols=["_value"], table=<-) => table |> sort(cols:cols, desc:desc) |> limit(n:n) // top sorts a table by cols and keeps only the top n records. top = (n, cols=["_value"], table=<-) => _sortLimit(table:table, n:n, cols:cols, desc:true)