Influxdata
/
docs-v2
mirror of https://github.com/influxdata/docs-v2.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Remove flux from Dedicated and Serverless docs. (#5014) 

* chore(v3): remove Flux

* chore(v3): remove Flux: flux-sql.md

* chore(v3): Remove Flux: reference

* chore(v3): Remove Flux: Reference, set aliases for removed pages

* chore(serverless): Remove Flux: Glossary

* Update content/influxdb/cloud-serverless/query-data/sql/execute-queries/data-explorer.md
pull/5020/head^2
Jason Stirnaman 2023-07-10 17:16:52 -05:00 committed by GitHub
parent 2290eecc6c
commit 46a062948f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 1137 additions and 1036 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
content/influxdb/cloud-dedicated/query-data/_index.md
View File

@ -2,18 +2,14 @@
title: Query data in InfluxDB Cloud
seotitle: Query data stored in InfluxDB Cloud
description: >
Learn to query data stored in InfluxDB using SQL, InfluxQL, and Flux using tools
like the InfluxDB user interface and the 'influx' command line interface.
Learn to query data stored in InfluxDB using SQL and InfluxQL.
menu:
influxdb_cloud_dedicated:
name: Query data
weight: 4
influxdb/cloud-dedicated/tags: [query, flux]
influxdb/cloud-dedicated/tags: [query]
---
Learn to query data stored in InfluxDB.
<!-- using SQL, InfluxQL, and Flux using tools
like the InfluxDB user interface and the 'influx' command line interface. -->
{{< children >}}

10
content/influxdb/cloud-dedicated/reference/glossary.md
View File

@ -373,16 +373,6 @@ Related entries:
## G
### group key
In [Flux](/{{< latest "flux" >}}/), the group key determines the schema and
contents of tables in Flux output.
A group key is a list of columns for which every row in the table has the same value.
Columns with unique values in each row are not part of the group key.
Related entries:
[primary key](#primary-key)
### gzip
gzip is a type of data compression that compress chunks of data, which is

26
content/influxdb/cloud-dedicated/write-data/best-practices/schema-design.md
View File

@ -266,7 +266,6 @@ matching or regular expressions to evaluate the `sensor` tag:
{{% code-tabs %}}
[SQL](#)
[InfluxQL](#)
[Flux](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
@ -281,18 +280,6 @@ SELECT * FROM home WHERE sensor LIKE '%id-1726ZA%'
SELECT * FROM home WHERE sensor =~ /id-1726ZA/
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
import "experimental/iox"
iox.from(bucket: "example-bucket")
|> range(start: -1y)
|> filter(fn: (r) => r._measurement == "home")
|> filter(fn: (r) => r.sensor =~ /id-1726ZA/)
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}
@ -329,7 +316,6 @@ simple equality expression:
{{< code-tabs-wrapper >}}
{{% code-tabs %}}
[SQL & InfluxQL](#)
[Flux](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
@ -337,18 +323,6 @@ simple equality expression:
SELECT * FROM home WHERE sensor_id = '1726ZA'
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
import "experimental/iox"
iox.from(bucket: "example-bucket")
|> range(start: -1y)
|> filter(fn: (r) => r._measurement == "home")
|> filter(fn: (r) => r.sensor_id == "1726ZA")
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}

2
content/influxdb/cloud-dedicated/write-data/migrate-data/_index.md
View File

@ -65,7 +65,7 @@ in more regions around the world.
#### Are you reliant on Flux queries and Flux tasks?
**You should not migrate**. InfluxDB Cloud Dedicated does not support Flux.
**You should not migrate**. {{% cloud-name %}} doesn't support Flux.
---

13
content/influxdb/cloud-serverless/admin/buckets/create-bucket.md
View File

@ -57,19 +57,6 @@ There are two places you can create a bucket in the UI.
- **Older than** to choose a specific retention period.
5. Click **Create** to create the bucket.
### Create a bucket in the Data Explorer
1. In the navigation menu on the left, select **Explore* (**Data Explorer**).
{{< nav-icon "data-explorer" >}}
2. In the **From** panel in the Flux Builder, select `+ Create Bucket`.
3. Enter a **Name** for the bucket.
4. Select when to **Delete Data**:
- **Never** to retain data forever.
- **Older than** to choose a specific retention period.
5. Click **Create** to create the bucket.
{{% /tab-content %}}
<!------------------------------- END UI CONTENT ------------------------------>

132
content/influxdb/cloud-serverless/get-started/query.md
View File

@ -773,138 +773,6 @@ RECORD BATCH
{{% /influxdb/custom-timestamps %}}
<!------------------------------ END GO CONTENT ------------------------------->
{{% /tab-content %}}
{{% tab-content %}}
<!-------------------------- BEGIN FLUX CLI CONTENT --------------------------->
The [`influx query` command](/influxdb/cloud-serverless/reference/cli/influx/query/)
uses the InfluxDB `/api/v2/query` endpoint to query InfluxDB.
This endpoint only accepts Flux queries. To use SQL with the `influx` CLI, wrap
your SQL query in Flux and use [`iox.sql()`](/flux/v0.x/stdlib/experimental/iox/)
to query the InfluxDB IOx storage engine with SQL.
Provide the following:
- **Bucket name** with the `bucket` parameter
- **SQL query** with the `query` parameter
{{< expand-wrapper >}}
{{% expand "View `iox.sql()` Flux example" %}}
```js
import "experimental/iox"
iox.sql(
bucket: "example-bucket",
query: "SELECT * FROM measurement'"
)
```
{{% /expand %}}
{{< /expand-wrapper >}}
1. If you haven't already, [download, install, and configure the `influx` CLI](/influxdb/cloud-serverless/tools/influx-cli/).
2. Use the [`influx query` command](/influxdb/cloud-serverless/reference/cli/influx/query/)
to query InfluxDB using Flux.
**Provide the following**:
- String-encoded Flux query that uses `iox.sql()` to query the InfluxDB IOx
storage engine with SQL.
- [Connection and authentication credentials](/influxdb/cloud-serverless/get-started/setup/?t=influx+CLI#configure-authentication-credentials)
{{% influxdb/custom-timestamps %}}
```sh
influx query "
import \"experimental/iox\"
iox.sql(
bucket: \"get-started\",
query: \"
SELECT
*
FROM
home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time <= '2022-01-01T20:00:00Z'
\",
)"
```
{{% /influxdb/custom-timestamps %}}
<!--------------------------- END FLUX CLI CONTENT ---------------------------->
{{% /tab-content %}}
{{% tab-content %}}
<!-------------------------- BEGIN FLUX API CONTENT --------------------------->
To query data from InfluxDB using SQL and the InfluxDB HTTP API, send a request
to the InfluxDB API [`/api/v2/query` endpoint](/influxdb/cloud-serverless/api/#operation/PostQuery)
using the `POST` request method.
{{< api-endpoint endpoint="http://localhost:8086/api/v2/query" method="post" api-ref="/influxdb/cloud-serverless/api/#operation/PostQuery" >}}
The `/api/v2/query` endpoint only accepts Flux queries.
To query data with SQL, wrap your SQL query in Flux and use [`iox.sql()`](/flux/v0.x/stdlib/experimental/iox/)
to query the InfluxDB IOx storage engine with SQL.
Provide the following:
- **Bucket name** with the `bucket` parameter
- **SQL query** with the `query` parameter
{{< expand-wrapper >}}
{{% expand "View `iox.sql()` Flux example" %}}
```js
import "experimental/iox"
iox.sql(
bucket: "example-bucket",
query: "SELECT * FROM measurement'"
)
```
{{% /expand %}}
{{< /expand-wrapper >}}
Include the following with your request:
- **Headers**:
- **Authorization**: Token <INFLUX_TOKEN>
- **Content-Type**: application/vnd.flux
- **Accept**: application/csv
- _(Optional)_ **Accept-Encoding**: gzip
- **Request body**: Flux query as plain text. In the Flux query, use `iox.sql()`
and provide your bucket name and your SQL query.
The following example uses cURL and the InfluxDB API to query data with Flux:
{{% influxdb/custom-timestamps %}}
```sh
curl --request POST \
"$INFLUX_HOST/api/v2/query" \
--header "Authorization: Token $INFLUX_TOKEN" \
--header "Content-Type: application/vnd.flux" \
--header "Accept: application/csv" \
--data "
import \"experimental/iox\"
iox.sql(
bucket: \"get-started\",
query: \"
SELECT
*
FROM
home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time <= '2022-01-01T20:00:00Z'
\",
)"
```
{{% /influxdb/custom-timestamps %}}
{{% note %}}
The InfluxDB `/api/v2/query` endpoint returns query results in
[annotated CSV](/influxdb/cloud-serverless/reference/syntax/annotated-csv/).
{{% /note %}}
<!--------------------------- END FLUX API CONTENT ---------------------------->
{{% /tab-content %}}
{{< /tabs-wrapper >}}
### Query results

8
content/influxdb/cloud-serverless/query-data/_index.md
View File

@ -2,20 +2,16 @@
title: Query data in InfluxDB Cloud
seotitle: Query data stored in InfluxDB Cloud
description: >
Learn to query data stored in InfluxDB using SQL, InfluxQL, and Flux using tools
like the InfluxDB user interface and the 'influx' command line interface.
Learn to query data stored in InfluxDB using SQL and InfluxQL.
menu:
influxdb_cloud_serverless:
name: Query data
weight: 4
influxdb/cloud-serverless/tags: [query, flux]
influxdb/cloud-serverless/tags: [query]
aliases:
- /influxdb/cloud-serverless/query-data/execute-queries/influx-api/
---
Learn to query data stored in InfluxDB.
<!-- using SQL, InfluxQL, and Flux using tools
like the InfluxDB user interface and the 'influx' command line interface. -->
{{< children >}}

87
content/influxdb/cloud-serverless/query-data/sql/execute-queries/data-explorer.md
View File

@ -19,7 +19,7 @@ Build, execute, and visualize your queries in InfluxDB UI's **Data Explorer**.
<!--Need a screenshot of the SQL builder with a pretty graph-->
Query using saved scripts, the SQL builder, the Flux builder, or by manually editing the query.
Query using saved scripts, the SQL builder, or by manually editing the query.
Choose between **visualization types** for your query.
## Query data with SQL and the Data Explorer
@ -71,88 +71,3 @@ After you **Run** your query, Data Explorer displays the results.
- Click {{< caps >}}Table{{< /caps >}} for a paginated tabular view of all rows and columns.
- Click {{< caps >}}Graph{{< /caps >}} to select a *visualization type* and options.
- Click {{< caps >}}CSV{{< /caps >}} to download query results in a comma-delimited file.
## Query data with Flux and the Data Explorer
Flux is a functional data scripting language designed for querying,
analyzing, and acting on time series data.
See [how to use Flux and SQL to query data](/influxdb/cloud-serverless/query-data/flux-sql/).
1. In the navigation menu on the left, click **Data Explorer**.
{{< nav-icon "data-explorer" >}}
2. Activate the **Switch to old Data Explorer** toggle to display the Flux builder. By default, the Cloud IOx UI displays the **Schema Browser** and the **SQL** script editor for creating queries.
![Data Explorer with Flux](/img/influxdb/2-0-data-explorer.png)
3. Use the bottom panel to create a Flux query:
- Select a bucket to define your data source or select `+ Create Bucket` to add a new bucket.
- Edit your time range with the [time range option](#select-time-range) in the dropdown menu.
- Add filters to narrow your data by selecting attributes or columns in the dropdown menu.
- Select **Group** from the **Filter** dropdown menu to group data into tables. For more about how grouping data in Flux works, see [group()](/flux/v0.x/stdlib/universe/group/).
3. Alternatively, click **Script Editor** to manually edit the query.
To switch back to the query builder, click **Query Builder**. Note that your updates from the Script Editor will not be saved.
4. Use the **Functions** list to review the available Flux functions.
Click a function from the list to add it to your query.
5. Click **Submit** (or press `Control+Enter`) to run your query. You can then preview your graph in the above pane.
To cancel your query while it's running, click **Cancel**.
6. To work on multiple queries at once, click the {{< icon "plus" >}} to add another tab.
- Click the eye icon on a tab to hide or show a query's visualization.
- Click the name of the query in the tab to rename it.
### Visualize your query
- Select an available **visualization type** from the dropdown menu:
{{< img-hd src="/img/influxdb/2-0-visualizations-dropdown.png" title="Visualization dropdown" />}}
## Control your dashboard cell
To open the cell editor overlay, click the gear icon in the upper right of a cell and select **Configure**.
The cell editor overlay opens.
### View raw data
Toggle the **View Raw Data** {{< icon "toggle" >}} option to see your data in table format instead of a graph. Scroll through raw data using arrows, or click page numbers to find specific tables. [Group keys](/influxdb/cloud-serverless/reference/glossary/#group-key) and [data types](/influxdb/cloud-serverless/reference/glossary/#data-type) are easily identifiable at the top of each column underneath the headings. Use this option when data can't be visualized using a visualization type.
{{< img-hd src="/img/influxdb/cloud-controls-view-raw-data.png" alt="View raw data" />}}
### Save as CSV
Click the CSV icon to save the cells contents as a CSV file.
### Manually refresh dashboard
Click the refresh button ({{< icon "refresh" >}}) to manually refresh the dashboard's data.
### Select time range
1. Select from the time range options in the dropdown menu.
{{< img-hd src="/img/influxdb/2-0-controls-time-range.png" alt="Select time range" />}}
2. Select **Custom Time Range** to enter a custom time range with precision up to nanoseconds.
The default time range is 5m.
> The custom time range uses the selected timezone (local time or UTC).
### Query Builder or Script Editor
Click **Query Builder** to use the builder to create a Flux query. Click **Script Editor** to manually edit the query.
#### Keyboard shortcuts
In **Script Editor** mode, the following keyboard shortcuts are available:
| Key | Description |
|--------------------------------|---------------------------------------------|
| `Control + /` (`⌘ + /` on Mac) | Comment/uncomment current or selected lines |
| `Control + Enter` | Submit query |
## Save your query as a dashboard cell or task
- Click **Save as** in the upper right, and then:
- To add your query to a dashboard, click **Dashboard Cell**.
- To save your query as a task, click **Task**.
- To save your query as a variable, click **Variable**.

577
content/influxdb/cloud-serverless/query-data/sql/execute-queries/flux-sql.md
View File

@ -1,577 +0,0 @@
---
title: Use Flux and SQL to query data
description: >
Leverage both the performance of SQL and the flexibility of Flux to query and
process your time series data.
menu:
influxdb_cloud_serverless:
name: Use Flux & SQL
parent: Execute SQL queries
weight: 204
aliases:
- /influxdb/cloud-serverless/query-data/flux-sql/
related:
- /influxdb/cloud-serverless/get-started/query/
- /influxdb/cloud-serverless/query-data/sql/
influxdb/cloud-serverless/tags: [sql, flux, query]
list_code_example: |
```js
import "experimental/iox"
query = "
SELECT *
FROM home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time < '2022-01-01T20:00:00Z'
"
iox.sql(bucket: "get-started", query: query)
```
---
InfluxDB Cloud Serverless supports both [Flux](/flux/v0.x/) and
[SQL](/influxdb/cloud-serverless/reference/sql/) query languages.
Flux is a full-featured data scripting language that provides a wide range of
functionality and flexibility. SQL is a proven and performant relational query language.
This guide walks through leveraging the performance of SQL and the flexibility of
Flux when querying your time series data.
{{% note %}}
#### Sample data
The query examples below use the
[Get started sample data](/influxdb/cloud-serverless/get-started/write/#write-line-protocol-to-influxdb).
{{% /note %}}
- [Performance and flexibility](#performance-and-flexibility)
- [What to do in SQL versus Flux?](#what-to-do-in-sql-versus-flux?)
- [Use SQL and Flux together](#use-sql-and-flux-together)
- [Helper functions for SQL in Flux](#helper-functions-for-sql-in-flux)
- [SQL results structure](#sql-results-structure)
- [Process SQL results with Flux](#process-sql-results-with-flux)
- [Group by tags](#group-by-tags)
- [Rename the `time` column to `_time`](#rename-the-time-column-to-_time)
- [Unpivot your data](#unpivot-your-data)
- [Example SQL query with further Flux processing](#example-sql-query-with-further-flux-processing)
## Performance and flexibility
Flux was designed and optimized for the
[TSM data model](/influxdb/v2.6/reference/internals/storage-engine/#time-structured-merge-tree-tsm),
which is fundamentally different from IOx.
Because of this, Flux is less performant when querying an IOx-powered bucket.
However, as a full-featured scripting language, Flux gives you the flexibility
to perform a wide range of data processing operations such as statistical
analysis, alerting, HTTP API interactions, and other operations that aren't
supported in SQL.
By using Flux and SQL together, you can benefit from both the performance of SQL
and the flexibility of Flux.
## What to do in SQL versus Flux?
We recommend doing as much of your query as possible in SQL for the most
performant queries.
Do any further processing in Flux.
For optimal performance, the following chain of Flux functions can and should be
performed in SQL:
{{< flex >}}
{{% flex-content %}}
#### Flux
```js
from(...)
|> range(...)
|> filter(...)
|> aggregateWindow(...)
```
{{% /flex-content %}}
{{% flex-content %}}
#### SQL
```sql
SELECT
DATE_BIN(...) AS _time,
avg(...) AS ...,
FROM measurement
WHERE
time >= ...
AND time < ...
GROUP BY _time
ORDER BY _time
```
{{% /flex-content %}}
{{< /flex >}}
#### Example Flux versus SQL queries
{{< expand-wrapper >}}
{{% expand "View example basic queries" %}}
{{% influxdb/custom-timestamps %}}
##### Flux
```js
from(bucket: "get-started")
|> range(start: 2022-01-01T08:00:00Z, stop: 2022-01-01T20:00:00Z)
|> filter(fn: (r) => r._measurement == "home")
```
##### SQL
```sql
SELECT *
FROM home
WHERE time >= '2022-01-01T08:00:00Z' AND time < '2022-01-01T20:00:00Z'
```
{{% /influxdb/custom-timestamps %}}
_For more information about performing basic queries with SQL, see
[Perform a basic SQL query](/influxdb/cloud-serverless/query-data/sql/basic-query/)._
{{% /expand %}}
{{% expand "View example aggregate queries" %}}
{{% influxdb/custom-timestamps %}}
##### Flux
```js
from(bucket: "get-started")
|> range(start: 2022-01-01T08:00:00Z, stop: 2022-01-01T20:00:00Z)
|> filter(fn: (r) => r._measurement == "home")
|> filter(fn: (r) => r._field == "temp" or r._field == "hum")
|> aggregateWindow(every: 2h, fn: mean)
```
##### SQL
```sql
SELECT
DATE_BIN(INTERVAL '2 hours', time, '1970-01-01T00:00:00Z'::TIMESTAMP) AS _time,
room,
avg(temp) AS temp,
avg(hum) AS hum,
FROM home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time < '2022-01-01T20:00:00Z'
GROUP BY room, _time
ORDER BY _time
```
{{% /influxdb/custom-timestamps %}}
_For more information about performing aggregate queries with SQL, see
[Aggregate data with SQL](/influxdb/cloud-serverless/query-data/sql/aggregate-select/)._
{{% /expand %}}
{{< /expand-wrapper >}}
## Use SQL and Flux together
To use SQL and Flux together and benefit from the strengths of both query languages,
build a **Flux query** that uses the [`iox.sql()` function](/flux/v0.x/stdlib/experimental/iox/sql/)
to execute a SQL query.
The SQL query should return the base data set for your query.
If this data needs further processing that can't be done in SQL, those operations
can be done with native Flux.
{{% note %}}
#### Supported by any InfluxDB 2.x client
The process below uses the `/api/v2/query` endpoint and can be used to execute
SQL queries against an InfluxDB IOx-powered bucket with an HTTP API request or
with all existing InfluxDB 2.x clients including, but not limited to, the following:
- InfluxDB 2.x client libraries
- Grafana and Grafana Cloud InfluxDB data source
- Flux VS code extensions
- InfluxDB OSS 2.x dashboards
{{% /note %}}
1. Import the [`experimental/iox` package](/flux/v0.x/stdlib/experimental/iox/).
2. Use [`iox.sql()`](/flux/v0.x/stdlib/experimental/iox/sql/) to execute a SQL
query. Include the following parameters:
- **bucket**: InfluxDB bucket to query
- **query**: SQL query to execute
{{% influxdb/custom-timestamps %}}
```js
import "experimental/iox"
query = "
SELECT *
FROM home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time < '2022-01-01T20:00:00Z'
"
iox.sql(bucket: "get-started", query: query)
```
{{% /influxdb/custom-timestamps %}}
{{% note %}}
#### Escape double quotes in your SQL query
If your SQL query uses **double-quoted (`""`) identifiers**, you must escape the
double quotes in your SQL query string.
{{< expand-wrapper >}}
{{% expand "View example" %}}
```js
import "experimental/iox"
query = "
SELECT *
FROM \"home\"
WHERE
\"time\" >= '2022-01-01T08:00:00Z'
AND \"time\" < '2022-01-01T20:00:00Z'
"
iox.sql(bucket: "get-started", query: query)
```
{{% /expand %}}
{{< /expand-wrapper >}}
{{% /note %}}
### Helper functions for SQL in Flux
The Flux `experimental/iox` package provides the following helper functions for
use with SQL queries in Flux:
- [iox.sqlInterval()](#ioxsqlinterval)
#### iox.sqlInterval()
[`iox.sqlInterval()`](/flux/v0.x/stdlib/experimental/iox/sqlinterval/) converts
a Flux [duration value](/flux/v0.x/data-types/basic/duration/) to a SQL
interval string. For example, `2d12h` converts to `2 days 12 hours`.
This is especially useful when using a Flux duration to downsample data in SQL.
{{< expand-wrapper >}}
{{% expand "View `iox.sqlInterval()` example" %}}
```js
import "experimental/iox"
windowPeriod = 2h
query = "
SELECT
DATE_BIN(INTERVAL '${iox.sqlInterval(d: windowPeriod)}', time, 0::TIMESTAMP) AS _time,
room,
avg(temp) AS temp,
avg(hum) AS hum
FROM home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time < '2022-01-01T20:00:00Z'
GROUP BY room, _time
ORDER BY room, _time
"
iox.sql(bucket: "get-started", query: query)
```
{{% /expand %}}
{{< /expand-wrapper >}}
### SQL results structure
`iox.sql()` returns a single table containing all the queried data.
Each row has a column for each queried field, tag, and time.
In the context of Flux, SQL results are ungrouped. This is important to understand
if you further process SQL results with Flux.
The [example query above](#use-sql-and-flux-together) returns:
{{% influxdb/custom-timestamps %}}
| co | hum | room | temp | time |
| --: | ---: | :---------- | ---: | :------------------- |
| 0 | 35.9 | Kitchen | 21 | 2022-01-01T08:00:00Z |
| 0 | 36.2 | Kitchen | 23 | 2022-01-01T09:00:00Z |
| 0 | 36.1 | Kitchen | 22.7 | 2022-01-01T10:00:00Z |
| 0 | 36 | Kitchen | 22.4 | 2022-01-01T11:00:00Z |
| 0 | 35.9 | Living Room | 21.1 | 2022-01-01T08:00:00Z |
| 0 | 35.9 | Living Room | 21.4 | 2022-01-01T09:00:00Z |
| 0 | 36 | Living Room | 21.8 | 2022-01-01T10:00:00Z |
| 0 | 36 | Living Room | 22.2 | 2022-01-01T11:00:00Z |
{{% /influxdb/custom-timestamps %}}
## Process SQL results with Flux
With your base data set returned from `iox.sql()`, you can further process your
data with Flux to perform actions such as complex data transformations, alerting,
HTTP requests, etc.
{{% note %}}
#### For the best performance, limit SQL results
All data returned by `iox.sql()` is loaded into memory and processed there.
To maximize the overall performance of your Flux query, try to return as little
data as possible from your SQL query.
This can by done by downsampling data in your SQL query or by limiting the
queried time range.
{{% /note %}}
1. [Group by tags](#group-by-tags)
1. [Rename the `time` column to `_time`](#rename-the-time-column-to-_time)
1. [Unpivot your data](#unpivot-your-data)
### Group by tags
The Flux `from()` functions returns results grouped by measurement, tag, and field key
and much of the Flux language is designed around this data model.
Because SQL results are ungrouped, to structure results the way many Flux
functions expect, use [`group()`](/flux/v0.x/stdlib/universe/group/) to group by
all of your queried tag columns.
{{% note %}}
Measurements are not stored as a column in the InfluxDB IOx storage engine and
are not returned by SQL.
{{% /note %}}
The [Get started sample data](#sample-data) only includes one tag: `room`.
```js
import "experimental/iox"
iox.sql(...)
|> group(columns: ["room"])
```
_`group()` does not guarantee sort order, so you likely need to use
[`sort()`](/flux/v0.x/stdlib/universe/sort/) to re-sort your data time **after**
performing other transformations._
### Rename the `time` column to `_time`
Many Flux functions expect or require a column named `_time` (with a leading underscore).
The IOx storage engine stores each point's timestamp in the `time` column (no leading underscore).
Depending on which Flux functions you use, you may need to rename the `time`
column to `_time`.
Rename the `time` column in your SQL query with an `AS` clause _**(recommended for performance)**_
or in Flux with the [`rename()` function](/flux/v0.x/stdlib/universe/rename/).
{{< code-tabs-wrapper >}}
{{% code-tabs "small" %}}
[SQL](#)
[Flux](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
```sql
SELECT time AS _time
FROM "get-started"
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
// ...
|> rename(columns: {time: "_time"})
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}
### Unpivot your data
In the context of Flux, data is considered "pivoted" when each field has its own
column. Flux generally expects a `_field` column that contains the the field key
and a `_value` column that contains the field. SQL returns each field as a column.
Depending on your use case and the type of processing you need to do in Flux,
you may need to "unpivot" your data.
{{< expand-wrapper >}}
{{% expand "View examples of pivoted and unpivoted data" %}}
{{% influxdb/custom-timestamps %}}
##### Pivoted data (SQL data model)
| _time | room | temp | hum |
| :------------------- | :------ | ---: | ---: |
| 2022-01-01T08:00:00Z | Kitchen | 21 | 35.9 |
| 2022-01-01T09:00:00Z | Kitchen | 23 | 36.2 |
| 2022-01-01T10:00:00Z | Kitchen | 22.7 | 36.1 |
##### Unpivoted data (Flux data model)
| _time | room | _field | _value |
| :------------------- | :------ | :----- | -----: |
| 2022-01-01T08:00:00Z | Kitchen | hum | 35.9 |
| 2022-01-01T09:00:00Z | Kitchen | hum | 36.2 |
| 2022-01-01T10:00:00Z | Kitchen | hum | 36.1 |
| _time | room | _field | _value |
| :------------------- | :------ | :----- | -----: |
| 2022-01-01T08:00:00Z | Kitchen | temp | 21 |
| 2022-01-01T09:00:00Z | Kitchen | temp | 23 |
| 2022-01-01T10:00:00Z | Kitchen | temp | 22.7 |
{{% /influxdb/custom-timestamps %}}
{{% /expand %}}
{{< /expand-wrapper >}}
{{% note %}}
#### Unpivoting data may not be necessary
Depending on your use case, unpivoting the SQL results may not be necessary.
For Flux queries that already pivot fields into columns, using SQL to return
pivoted results will greatly improve the performance of your query.
{{% /note %}}
To unpivot SQL results:
1. Import the `experimental` package.
2. [Ensure you have a `_time` column](#rename-the-time-column-to-_time).
3. Use [`experimental.unpivot()`](/flux/v0.x/stdlib/experimental/unpivot/) to unpivot your data.
```js
import "experimental"
import "experimental/iox"
iox.sql(...)
|> group(columns: ["room"])
|> experimental.unpivot()
```
{{% note %}}
`unpivot()` treats columns _not_ in the [group key](/flux/v0.x/get-started/data-model/#group-key)
(other than `_time` and `_measurement`) as fields. Be sure to [group by tags](#group-by-tags)
_before_ unpivoting data.
{{% /note %}}
### Example SQL query with further Flux processing
{{% influxdb/custom-timestamps %}}
```js
import "experimental"
import "experimental/iox"
query = "
SELECT
time AS _time,
room,
temp,
hum,
co
FROM home
WHERE
time >= '2022-01-01T08:00:00Z'
AND time <= '2022-01-01T20:00:00Z'
"
iox.sql(bucket: "get-started", query: query)
|> group(columns: ["room"])
|> experimental.unpivot()
```
{{% /influxdb/custom-timestamps %}}
{{< expand-wrapper >}}
{{% expand "View processed query results" %}}
{{% influxdb/custom-timestamps %}}
| _time | room | _field | _value |
| :------------------- | :---------- | :----- | -----: |
| 2022-01-01T08:00:00Z | Kitchen | co | 0 |
| 2022-01-01T09:00:00Z | Kitchen | co | 0 |
| 2022-01-01T10:00:00Z | Kitchen | co | 0 |
| 2022-01-01T11:00:00Z | Kitchen | co | 0 |
| 2022-01-01T12:00:00Z | Kitchen | co | 0 |
| 2022-01-01T13:00:00Z | Kitchen | co | 1 |
| 2022-01-01T14:00:00Z | Kitchen | co | 1 |
| 2022-01-01T15:00:00Z | Kitchen | co | 3 |
| 2022-01-01T16:00:00Z | Kitchen | co | 7 |
| 2022-01-01T17:00:00Z | Kitchen | co | 9 |
| 2022-01-01T18:00:00Z | Kitchen | co | 18 |
| 2022-01-01T19:00:00Z | Kitchen | co | 22 |
| 2022-01-01T20:00:00Z | Kitchen | co | 26 |
| _time | room | _field | _value |
| :------------------- | :---------- | :----- | -----: |
| 2022-01-01T08:00:00Z | Living Room | co | 0 |
| 2022-01-01T09:00:00Z | Living Room | co | 0 |
| 2022-01-01T10:00:00Z | Living Room | co | 0 |
| 2022-01-01T11:00:00Z | Living Room | co | 0 |
| 2022-01-01T12:00:00Z | Living Room | co | 0 |
| 2022-01-01T13:00:00Z | Living Room | co | 0 |
| 2022-01-01T14:00:00Z | Living Room | co | 0 |
| 2022-01-01T15:00:00Z | Living Room | co | 1 |
| 2022-01-01T16:00:00Z | Living Room | co | 4 |
| 2022-01-01T17:00:00Z | Living Room | co | 5 |
| 2022-01-01T18:00:00Z | Living Room | co | 9 |
| 2022-01-01T19:00:00Z | Living Room | co | 14 |
| 2022-01-01T20:00:00Z | Living Room | co | 17 |
| _time | room | _field | _value |
| :------------------- | :---------- | :----- | -----: |
| 2022-01-01T08:00:00Z | Kitchen | hum | 35.9 |
| 2022-01-01T09:00:00Z | Kitchen | hum | 36.2 |
| 2022-01-01T10:00:00Z | Kitchen | hum | 36.1 |
| 2022-01-01T11:00:00Z | Kitchen | hum | 36 |
| 2022-01-01T12:00:00Z | Kitchen | hum | 36 |
| 2022-01-01T13:00:00Z | Kitchen | hum | 36.5 |
| 2022-01-01T14:00:00Z | Kitchen | hum | 36.3 |
| 2022-01-01T15:00:00Z | Kitchen | hum | 36.2 |
| 2022-01-01T16:00:00Z | Kitchen | hum | 36 |
| 2022-01-01T17:00:00Z | Kitchen | hum | 36 |
| 2022-01-01T18:00:00Z | Kitchen | hum | 36.9 |
| 2022-01-01T19:00:00Z | Kitchen | hum | 36.6 |
| 2022-01-01T20:00:00Z | Kitchen | hum | 36.5 |
| _time | room | _field | _value |
| :------------------- | :---------- | :----- | -----: |
| 2022-01-01T08:00:00Z | Living Room | hum | 35.9 |
| 2022-01-01T09:00:00Z | Living Room | hum | 35.9 |
| 2022-01-01T10:00:00Z | Living Room | hum | 36 |
| 2022-01-01T11:00:00Z | Living Room | hum | 36 |
| 2022-01-01T12:00:00Z | Living Room | hum | 35.9 |
| 2022-01-01T13:00:00Z | Living Room | hum | 36 |
| 2022-01-01T14:00:00Z | Living Room | hum | 36.1 |
| 2022-01-01T15:00:00Z | Living Room | hum | 36.1 |
| 2022-01-01T16:00:00Z | Living Room | hum | 36 |
| 2022-01-01T17:00:00Z | Living Room | hum | 35.9 |
| 2022-01-01T18:00:00Z | Living Room | hum | 36.2 |
| 2022-01-01T19:00:00Z | Living Room | hum | 36.3 |
| 2022-01-01T20:00:00Z | Living Room | hum | 36.4 |
| _time | room | _field | _value |
| :------------------- | :---------- | :----- | -----: |
| 2022-01-01T08:00:00Z | Kitchen | temp | 21 |
| 2022-01-01T09:00:00Z | Kitchen | temp | 23 |
| 2022-01-01T10:00:00Z | Kitchen | temp | 22.7 |
| 2022-01-01T11:00:00Z | Kitchen | temp | 22.4 |
| 2022-01-01T12:00:00Z | Kitchen | temp | 22.5 |
| 2022-01-01T13:00:00Z | Kitchen | temp | 22.8 |
| 2022-01-01T14:00:00Z | Kitchen | temp | 22.8 |
| 2022-01-01T15:00:00Z | Kitchen | temp | 22.7 |
| 2022-01-01T16:00:00Z | Kitchen | temp | 22.4 |
| 2022-01-01T17:00:00Z | Kitchen | temp | 22.7 |
| 2022-01-01T18:00:00Z | Kitchen | temp | 23.3 |
| 2022-01-01T19:00:00Z | Kitchen | temp | 23.1 |
| 2022-01-01T20:00:00Z | Kitchen | temp | 22.7 |
| _time | room | _field | _value |
| :------------------- | :---------- | :----- | -----: |
| 2022-01-01T08:00:00Z | Living Room | temp | 21.1 |
| 2022-01-01T09:00:00Z | Living Room | temp | 21.4 |
| 2022-01-01T10:00:00Z | Living Room | temp | 21.8 |
| 2022-01-01T11:00:00Z | Living Room | temp | 22.2 |
| 2022-01-01T12:00:00Z | Living Room | temp | 22.2 |
| 2022-01-01T13:00:00Z | Living Room | temp | 22.4 |
| 2022-01-01T14:00:00Z | Living Room | temp | 22.3 |
| 2022-01-01T15:00:00Z | Living Room | temp | 22.3 |
| 2022-01-01T16:00:00Z | Living Room | temp | 22.4 |
| 2022-01-01T17:00:00Z | Living Room | temp | 22.6 |
| 2022-01-01T18:00:00Z | Living Room | temp | 22.8 |
| 2022-01-01T19:00:00Z | Living Room | temp | 22.5 |
| 2022-01-01T20:00:00Z | Living Room | temp | 22.2 |
{{% /influxdb/custom-timestamps %}}
{{% /expand %}}
{{< /expand-wrapper >}}
With the SQL results restructured into the Flux data model, you can do any further
processing with Flux. For more information about Flux, see the
[Flux documentation](/flux/v0.x/).

29
content/influxdb/cloud-serverless/reference/cli/influx/query/_index.md
View File

@ -1,8 +1,8 @@
---
title: influx query
description: >
The `influx query` command executes a literal Flux query provided as a string
or a literal Flux query contained in a file by specifying the file prefixed with an '@' sign.
The `influx query` command and `/api/v2/query` API endpoint don't work with InfluxDB Cloud Serverless.
Use [SQL](/influxdb/cloud-serverless/query-data/sql/execute-queries/) or [InfluxQL](/influxdb/cloud-serverless/query-data/influxql/) to query an InfluxDB Cloud Serverless bucket.
menu:
influxdb_cloud_serverless:
name: influx query
@ -10,21 +10,20 @@ menu:
weight: 101
influxdb/cloud-serverless/tags: [query]
related:
- /influxdb/cloud/query-data/
- /influxdb/cloud/query-data/execute-queries/influx-query/
- /influxdb/cloud-serverless/query-data/
- /influxdb/cloud-serverless/query-data/sql/execute-queries/
- /influxdb/cloud-serverless/query-data/influxql/execute-queries/
- /influxdb/cloud-serverless/reference/cli/influx/#provide-required-authentication-credentials, influx CLI—Provide required authentication credentials
- /influxdb/cloud-serverless/reference/cli/influx/#provide-required-authentication-credentials, influx CLI—Provide required authentication credentials
metadata: [influx CLI 2.0.0+]
updated_in: CLI v2.0.5
prepend:
block: warn
content: |
#### Command not supported
The `influx query` command and the InfluxDB `/api/v2/query` API endpoint it uses
don't work with {{% cloud-name %}}.
Use [SQL](/influxdb/cloud-serverless/query-data/sql/execute-queries/) or [InfluxQL](/influxdb/cloud-serverless/query-data/influxql/execute-queries/) tools to query a {{% cloud-name %}} bucket.
---
{{% note %}}
#### Use SQL and Flux together
The `influx query` command and the InfluxDB `/api/v2/query` API endpoint it uses
only support Flux queries. To query an InfluxDB Cloud Serverless bucket powered
by IOx with SQL, use the `iox.sql()` Flux function. For more information, see
[Use Flux and SQL to query data](/influxdb/cloud-serverless/query-data/flux-sql/).
{{% /note %}}
{{< duplicate-oss >}}

7
content/influxdb/cloud-serverless/reference/cli/influx/transpile/_index.md
View File

@ -11,12 +11,7 @@ prepend:
content: |
### Removed in influx CLI v2.0.5
The `influx transpile` command was removed in **v2.0.5** of the `influx` CLI.
[Use InfluxQL to query InfluxDB](/influxdb/cloud/query-data/influxql/).
For information about manually converting InfluxQL queries to Flux, see:
- [Get started with Flux](/flux/v0.x/get-started/)
- [Query data with Flux](/influxdb/cloud/query-data/flux/)
- [Migrate continuous queries to Flux tasks](/influxdb/cloud/upgrade/v1-to-cloud/migrate-cqs/)
Use [SQL](/influxdb/cloud-serverless/query-data/sql/execute-queries/) or [InfluxQL](/influxdb/cloud-serverless/query-data/influxql/execute-queries/) tools to query a {{% cloud-name %}} bucket.
---
{{< duplicate-oss >}}

77
content/influxdb/cloud-serverless/reference/flux.md
View File

@ -1,77 +0,0 @@
---
title: Flux reference documentation
description: >
Learn the Flux syntax and structure used to query InfluxDB.
menu:
influxdb_cloud_serverless:
name: Flux reference
parent: Reference
weight: 103
---
All Flux reference material is provided in the Flux documentation:
<a class="btn" href="/flux/v0.x/">View the Flux documentation</a>
## Flux with the InfluxDB IOx storage engine
When querying data from an InfluxDB bucket powered by InfluxDB IOx, use the following
input functions:
- [`iox.from()`](/flux/v0.x/stdlib/experimental/iox/from/): alternative to
[`from()`](/flux/v0.x/stdlib/influxdata/influxdb/from/).
- [`iox.sql()`](/flux/v0.x/stdlib/experimental/iox/sql/): execute a SQL query
with Flux.
Both IOx-based input functions return pivoted data with a column for each field
in the output. To unpivot the data:
1. Group by tag columns.
2. Rename the `time` column to `_time`.
3. Use [`experimental.unpivot()`](/flux/v0.x/stdlib/experimental/unpivot/) to
unpivot the data. All columns not in the group key (other than `_time`) are
treated as fields.
{{< code-tabs-wrapper >}}
{{% code-tabs %}}
[iox.from()](#)
[iox.sql()](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
```js
import "experimental"
import "experimental/iox"
iox.from(bucket: "example-bucket", measurement: "example-measurement")
|> range(start: -1d)
|> group(columns: ["tag1", "tag2". "tag3"])
|> rename(columns: {time: "_time_"})
|> experimental.unpivot()
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
import "experimental"
import "experimental/iox"
query = "SELECT * FROM \"example-measurement\" WHERE time >= now() - INTERVAL '1 day'"
iox.sql(bucket: "example-bucket", query: query)
|> group(columns: ["tag1", "tag2". "tag3"])
|> rename(columns: {time: "_time_"})
|> experimental.unpivot()
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}
{{% warn %}}
#### Flux performance with InfluxDB IOx
When querying data from an InfluxDB bucket powered by InfluxDB IOx, using `iox.from()`
is **less performant** than querying a TSM-powered bucket with `from()`.
For better Flux query performance, use `iox.sql()`.
{{% /warn %}}

1101
content/influxdb/cloud-serverless/reference/glossary.md
View File

File diff suppressed because it is too large Load Diff

35
content/influxdb/cloud-serverless/reference/syntax/annotated-csv/_index.md
View File

@ -1,8 +1,7 @@
---
title: Annotated CSV
description: >
The InfluxDB `/api/v2/query` API returns query results in annotated CSV format.
You can write data to InfluxDB using annotated CSV and the `influx write` command.
You can write data to InfluxDB using annotated CSV and the InfluxDB HTTP API.
weight: 103
menu:
influxdb_cloud_serverless:
@ -12,8 +11,7 @@ related:
- /influxdb/cloud-serverless/reference/syntax/annotated-csv/extended/
---
The InfluxDB `/api/v2/query` API returns query results in annotated CSV format.
You can also write data to InfluxDB using annotated CSV and the `influx write` command,
You can write data to InfluxDB using annotated CSV and the InfluxDB HTTP API
or [upload a CSV file](/influxdb/cloud-serverless/write-data/csv/user-interface) in the InfluxDB UI.
CSV tables must be encoded in UTF-8 and Unicode Normal Form C as defined in [UAX15](http://www.unicode.org/reports/tr15/).
@ -111,29 +109,22 @@ Subsequent columns contain annotation values as shown in the table below.
| Annotation name | Values | Description |
|:-------- |:--------- | :------- |
| **datatype** | a [data type](#data-types) or [line protocol element](#line-protocol-elements) | Describes the type of data or which line protocol element the column represents. |
| **group** | boolean flag `true` or `false` | Indicates the column is part of the group key. |
| **datatype** | a [data type](#data-types) or [line protocol element](#line-protocol-elements) | Describes the type of data or which line protocol element the column represents. | |
| **default** | a value of the column's data type | Value to use for rows with an empty value. |
{{% note %}}
To encode a table with its [group key](/influxdb/cloud-serverless/reference/glossary/#group-key),
the `datatype`, `group`, and `default` annotations must be included.
If a table has no rows, the `default` annotation provides the group key values.
{{% /note %}}
## Data types
| Datatype | Flux type | Description |
| :-------- | :--------- | :---------- |
| boolean | bool | "true" or "false" |
| unsignedLong | uint | unsigned 64-bit integer |
| long | int | signed 64-bit integer |
| double | float | IEEE-754 64-bit floating-point number |
| string | string | UTF-8 encoded string |
| base64Binary | bytes | base64 encoded sequence of bytes as defined in RFC 4648 |
| dateTime | time | instant in time, may be followed with a colon : and a description of the format (number, RFC3339, RFC3339Nano) |
| duration | duration | length of time represented as an unsigned 64-bit integer number of nanoseconds |
| Datatype | Description |
| :-------- | :---------- |
| boolean | "true" or "false" |
| unsignedLong | unsigned 64-bit integer |
| long | signed 64-bit integer |
| double | IEEE-754 64-bit floating-point number |
| string | UTF-8 encoded string |
| base64Binary | base64 encoded sequence of bytes as defined in RFC 4648 |
| dateTime | instant in time, may be followed with a colon : and a description of the format (number, RFC3339, RFC3339Nano) |
| duration | length of time represented as an unsigned 64-bit integer number of nanoseconds |
## Line protocol elements

52
content/influxdb/cloud-serverless/write-data/best-practices/schema-design.md
View File

@ -266,7 +266,6 @@ matching or regular expressions to evaluate the `sensor` tag:
{{% code-tabs %}}
[SQL](#)
[InfluxQL](#)
[Flux](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
@ -281,18 +280,6 @@ SELECT * FROM home WHERE sensor LIKE '%id-1726ZA%'
SELECT * FROM home WHERE sensor =~ /id-1726ZA/
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
import "experimental/iox"
iox.from(bucket: "example-bucket")
|> range(start: -1y)
|> filter(fn: (r) => r._measurement == "home")
|> filter(fn: (r) => r.sensor =~ /id-1726ZA/)
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}
@ -329,7 +316,6 @@ simple equality expression:
{{< code-tabs-wrapper >}}
{{% code-tabs %}}
[SQL & InfluxQL](#)
[Flux](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
@ -337,18 +323,6 @@ simple equality expression:
SELECT * FROM home WHERE sensor_id = '1726ZA'
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
import "experimental/iox"
iox.from(bucket: "example-bucket")
|> range(start: -1y)
|> filter(fn: (r) => r._measurement == "home")
|> filter(fn: (r) => r.sensor_id == "1726ZA")
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}
@ -362,20 +336,9 @@ in measurement names, tag keys, and field keys.
- [SQL keywords](/influxdb/cloud-serverless/reference/sql/#keywords)
- [InfluxQL keywords](/influxdb/cloud-serverless/reference/syntax/influxql/spec/#keywords)
- [Flux keywords](/{{< latest "flux" >}}/spec/lexical-elements/#keywords)
When using SQL or InfluxQL to query measurements, tags, and fields with special
characters or keywords, you have to wrap these keys in **double quotes**.
In Flux, if using special characters in tag keys, you have to use
[bracket notation](/{{< latest "flux" >}}/data-types/composite/record/#bracket-notation)
to reference those columns.
{{< code-tabs-wrapper >}}
{{% code-tabs %}}
[SQL & InfluxQL](#)
[Flux](#)
{{% /code-tabs %}}
{{% code-tab-content %}}
```sql
SELECT
@ -385,18 +348,3 @@ FROM
WHERE
"tag@1-23" = 'ABC'
```
{{% /code-tab-content %}}
{{% code-tab-content %}}
```js
import "experimental/iox"
iox.from(bucket: "example-bucket")
|> range(start: -1y)
|> filter(fn: (r) => r._measurement == "example-measurement")
|> filter(fn: (r) => r["tag@1-23"] == "ABC")
```
{{% /code-tab-content %}}
{{< /code-tabs-wrapper >}}

9
content/influxdb/cloud-serverless/write-data/migrate-data/_index.md
View File

@ -9,6 +9,9 @@ menu:
parent: Write data
weight: 104
alt_engine: /influxdb/cloud/migrate-data/
aliases:
- /influxdb/cloud-serverless/reference/flux/
- /influxdb/cloud-serverless/query-data/sql/execute-queries/flux-sql/
---
Migrate data to InfluxDB Cloud Serverless powered by InfluxDB IOx from other
@ -69,12 +72,6 @@ in more regions around the world.
storage engine. Flux is optimized to work with the TSM storage engine, but these
optimizations do not apply to the on-disk structure of InfluxDB IOx.
To maintain performant Flux queries against the IOx storage engine, you need to
update Flux queries to use a mixture of both SQL and Flux—SQL to query the base
dataset and Flux to perform other transformations that SQL does not support.
For information about using SQL and Flux together for performant queries, see
[Use Flux and SQL to query data](/influxdb/cloud-serverless/query-data/flux-sql/).
---
## Data migration guides