#@jennifer/influxdb

def p as influxdb.Point init influxdb.point("cpu");
$p = influxdb.tag($p, "host", "server01");
$p = influxdb.field($p, "value", 0.64);
$p = influxdb.intField($p, "cores", 8);
influxdb.line($p);   # cpu,host=server01 value=0.64,cores=8i

#Querying

def struct influxdb.Series {
    name as string,                       # measurement name
    tags as map of string to string,      # GROUP BY tag set ({} if none)
    columns as list of string,            # column names, e.g. ["time", "value"]
    values as list of list of string      # rows, one stringified cell per column
};
def struct influxdb.Result {
    series as list of Series              # flattened across every statement
};

influxdb.query(client, influxql) runs an InfluxQL statement against /query and parses the tabular JSON into Series (the same read-a-parsed-result shape as prometheus's retrieval half). Every cell is stringified: time comes back as its RFC 3339 string, numbers via their shortest form, booleans as "true" / "false", and JSON null as "" - so a homogeneous list of list of string can hold a row of otherwise mixed-type columns. Convert a cell you know is numeric with convert.toFloat. A per-statement or top-level error in the response throws Error{kind: "influxdb"}. The statement goes in the POST body (q=...), not the URL, so it stays out of proxy and access logs. A result the server cut at its row limit ("partial": true) comes back as far as it goes, without a flag: page with LIMIT / OFFSET for large results.

def r as influxdb.Result init influxdb.query($db, "SELECT value FROM cpu");
for (def s in $r.series) {
    for (def row in $s.values) {
        # row[0] = time (string), row[1] = value (stringified number)
    }
}

#Flux (2.x)

influxdb.queryFlux(client2, flux) runs a Flux script against a 2.x client's organization (POST /api/v2/query?org=... under application/vnd.flux). InfluxDB answers a Flux query with annotated CSV (RFC 4180 with #datatype / #group / #default header rows), not JSON, so queryFlux returns the response body verbatim as a string; parse it with the csv module. (The JSON-parsing query / Series / Result shape is the 1.x InfluxQL path.)

def db2 as influxdb.Client init influxdb.client2("http://localhost:8086", "myorg", "mybucket", "mytoken");
def csv as string init influxdb.queryFlux($db2,
    "from(bucket:\"mybucket\") |> range(start:-1h) |> filter(fn:(r) => r._measurement == \"cpu\")");

#Scope

• Both API generations. 1.x line protocol + InfluxQL (client / clientWith, query) and 2.x org/bucket writes + Flux (client2, queryFlux), sharing the line protocol and Point builders. InfluxDB 3.x takes client2 writes; it has no Flux, so query it through client with InfluxQL.
• Nanosecond write precision (precision=ns); a point's timestamp is an integer nanosecond value (or a time.Time via atTime).
• 1.x query cells are stringified. The Result keeps rows homogeneous (list of list of string) rather than exposing a typed cell union; convert numeric columns yourself.
• Flux returns raw annotated CSV. queryFlux returns the response body as a string for the csv module to parse, rather than a bespoke Flux-CSV decoder.
• Auth: 1.x Basic auth, 2.x token. Credentials ride in the Authorization header and are redacted from any raised error. TLS client certs are not wired; use a reverse proxy for those.

#See also

• http.md - the HTTP client this module builds on.
• prometheus.md - the pull-based metrics sibling; its retrieval half shares this parsed-result shape.
• modules/index.md - the module catalog and import rules.