Query and transform data on Grafana Labs

Write expression queries

Fri, 03 Apr 2026 12:35:46 -0500

Write expression queries

Server-side expressions enable you to manipulate data returned from queries with math and other operations. Expressions create new data and do not manipulate the data returned by data sources.

About expressions

Server-side expressions allow you to manipulate data returned from queries with math and other operations. Expressions create new data and do not manipulate the data returned by data sources, aside from some minor data restructuring to make the data acceptable input for expressions.

Using expressions

Expressions are most commonly used for Grafana Alerting. The processing is done server-side, so expressions can operate without a browser session. However, expressions can also be used with backend data sources and visualization.

Note
Expressions do not work with legacy dashboard alerts.

Expressions are meant to augment data sources by enabling queries from different data sources to be combined or by providing operations unavailable in a data source.

Note
When possible, you should do data processing inside the data source. Copying data from storage to the Grafana server for processing is inefficient, so expressions are targeted at lightweight data processing.

Expressions work with data source queries that return time series or number data. They also operate on multiple-dimensional data. For example, a query that returns multiple series, where each series is identified by labels or tags.

An individual expression takes one or more queries or other expressions as input and adds data to the result. Each individual expression or query is represented by a variable that is a named identifier known as its RefID (e.g., the default letter A or B).

To reference the output of an individual expression or a data source query in another expression, this identifier is used as a variable.

Types of expressions

Expressions work with two types of data.

A collection of time series.
A collection of numbers, where each number is an item.

Each collection is returned from a single data source query or expression and represented by the RefID. Each collection is a set, where each item in the set is uniquely identified by its dimensions which are stored as labels or key-value pairs.

Data source queries

Server-side expressions only support data source queries for backend data sources. The data is generally assumed to be labeled time series data. In the future we intend to add an assertion of the query return type (number or time series) data so expressions can handle errors better.

Data source queries, when used with expressions, are executed by the expression engine. When it does this, it restructures data to be either one time series or one number per data frame. So for example if using a data source that returns multiple series on one frame in the table view, you might notice it looks different when executed with expressions.

Currently, the only non-time series format (number) is supported when you’re using data frames and you have a table response that returns a data frame with no time, string columns, and one number column:

Loc	Host	Avg_CPU
MIA	A	1
NYC	B	2

The example above will produce a number that works with expressions. The string columns become labels and the number column the corresponding value. For example {"Loc": "MIA", "Host": "A"} with a value of 1.

Operations

You can use the following operations in expressions: math, reduce, and resample.

Math

Math is for free-form math formulas on time series or number data. Math operations take numbers and time series as input and change them to different numbers and time series.

Data from other queries or expressions are referenced with the RefID prefixed with a dollar sign, for example $A. If the variable has spaces in the name, then you can use a brace syntax like ${my variable}.

Numeric constants may be in decimal (2.24), octal (with a leading zero like 072), or hex (with a leading 0x like 0x2A). Exponentials and signs are also supported (e.g., -0.8e-2).

Operators

The arithmetic (+, binary and unary -, *, /, %, exponent **), relational (<, >, ==, !=, >=, <=), and logical (&&, ||, and unary !) operators are supported.

How the operation behaves with data depends on if it is a number or time series data.

With binary operations, such as $A + $B or $A || $B, the operator is applied in the following ways depending on the type of data:

If both $A and $B are a number, then the operation is performed between the two numbers.
If one variable is a number, and the other variable is a time series, then the operation between the value of each point in the time series and the number is performed.
If both $A and $B are time series data, then the operation between each value in the two series is performed for each time stamp that exists in both $A and $B. The Resample operation can be used to line up time stamps. (Note: in the future, we plan to add options to the Math operation for different behaviors).

Summary:

Number OP number = number
Number OP series = series
Series OP series = series

Because expressions work with multiple series or numbers represented by a single variable, binary operations also perform a union (join) between the two variables. This is done based on the identifying labels associated with each individual series or number.

So if you have numbers with labels like {host=web01} in $A and another number in $B with the same labels then the operation is performed between those two items within each variable, and the result will share the same labels. The rules for the behavior of this union are as follows:

An item with no labels will join to anything.
If both $A and $B each contain only one item (one series, or one number), they will join.
If labels are exact match they will join.
If labels are a subset of the other, for example and item in $A is labeled {host=A,dc=MIA} and item in $B is labeled {host=A} they will join.
Currently, if within a variable such as $A there are different tag keys for each item, the join behavior is undefined.

The relational and logical operators return 0 for false 1 for true.

Math Functions

While most functions exist in the own expression operations, the math operation does have some functions similar to math operators or symbols. When functions can take either numbers or series, than the same type as the argument will be returned. When it is a series, the operation of performed for the value of each point in the series.

abs

abs returns the absolute value of its argument which can be a number or a series. For example abs(-1) or abs($A).

is_inf

is_inf takes a number or a series and returns 1 for Inf values (negative or positive) and 0 for other values. For example is_inf($A).

Note
If you need to specifically check for negative infinity for example, you can do a comparison like $A == infn().

is_nan

is_nan takes a number or a series and returns 1 for NaN values and 0 for other values. For example is_nan($A). This function exists because NaN is not equal to NaN.

is_null

is_null takes a number or a series and returns 1 for null values and 0 for other values. For example is_null($A).

is_number

is_number takes a number or a series and returns 1 for all real number values and 0 for other values (which are null, Inf+, Inf-, and NaN). For example is_number($A).

log

Log returns the natural logarithm of of its argument which can be a number or a series. If the value is less than 0, NaN is returned. For example log(-1) or log($A).

inf, infn, nan, and null

The inf, infn, nan, and null functions all return a single value of the name. They primarily exist for testing. Example: null().

round

Round returns a rounded integer value. For example, round(3.123) or round($A). (This function should probably take an argument so it can add precision to the rounded value).

ceil

Ceil rounds the number up to the nearest integer value. For example, ceil(3.123) returns 4.

floor

Floor rounds the number down to the nearest integer value. For example, floor(3.123) returns 3.

Reduce

Reduce takes one or more time series returned from a query or an expression and turns each series into a single number. The labels of the time series are kept as labels on each outputted reduced number.

Fields:

Function - The reduction function to use
Input - The variable (refID (such as A)) to resample
Mode - Allows control behavior of reduction function when a series contains non-numerical values (null, NaN, +-Inf)

Reduction Functions

Count

Count returns the number of points in each series.

Mean

Mean returns the total of all values in each series divided by the number of points in that series. In strict mode if any values in the series are null or nan, or if the series is empty, NaN is returned.

Min and Max

Min and Max return the smallest or largest value in the series respectively. In strict mode if any values in the series are null or nan, or if the series is empty, NaN is returned.

Sum

Sum returns the total of all values in the series. If series is of zero length, the sum will be 0. In strict mode if there are any NaN or Null values in the series, NaN is returned.

Last

Last returns the last number in the series. If the series has no values then returns NaN.

Reduction Modes

Strict

In Strict mode the input series is processed as is. If any values in the series are non-numeric (null, NaN or +-Inf), NaN is returned.

Drop Non-Numeric

In this mode all non-numeric values (null, NaN or +-Inf) in the input series are filtered out before executing the reduction function.

Replace Non-Numeric

In this mode all non-numeric values are replaced by a pre-defined value.

Resample

Resample changes the time stamps in each time series to have a consistent time interval. The main use case is so you can resample time series that do not share the same timestamps so math can be performed between them. This can be done by resample each of the two series, and then in a Math operation referencing the resampled variables.

Fields:

Input - The variable of time series data (refID (such as A)) to resample
Resample to - The duration of time to resample to, for example 10s. Units may be s seconds, m for minutes, h for hours, d for days, w for weeks, and y of years.
Downsample - The reduction function to use when there are more than one data point per window sample. See the reduction operation for behavior details.
Upsample - The method to use to fill a window sample that has no data points.
- pad fills with the last know value
- backfill with next known value
- fillna to fill empty sample windows with NaNs

Write an expression

If your data source supports them, then Grafana displays the Expression button and shows any existing expressions in the query editor list.

For more information about expressions, refer to About expressions.

Open the panel.
Below the query, click Expression.
In the Operation field, select the type of expression you want to write.

For more information about expression operations, refer to About expressions.
Write the expression.
Click Apply.

Special cases

When any queried data source returns no series or numbers, the expression engine returns NoData. For example, if a request contains two data source queries that are merged by an expression, if NoData is returned by at least one of the data source queries, then the returned result for the entire query is NoData.

For more information about how Grafana Alerting processes NoData results, refer to No data and error handling.

In the case of using an expression on multiple queries, the expression engine requires that all of the queries return an identical timestamp. For example, if using math to combine the results of multiple SQL queries which each use SELECT NOW() AS "time", the expression will only work if all queries evaluate NOW() to an identical timestamp; which does not always happen. To resolve this, you can replace NOW() with an arbitrary time, such as SELECT 1 AS "time", or any other valid UNIX timestamp.

SQL expressions

Fri, 03 Apr 2026 12:35:46 -0500

SQL expressions

Note
SQL expressions is currently in public preview. Grafana Labs offers limited support, and breaking changes might occur prior to the feature being made generally available.

SQL Expressions are server-side expressions that manipulate and transform the results of data source queries using MySQL-like syntax. They allow you to easily query and transform your data after it has been queried, using SQL, which provides a familiar and powerful syntax that can handle everything from simple filters to highly complex, multi-step transformations.

In Grafana, a server-side expression is a way to transform or calculate data after it has been retrieved from the data source, but before it is sent to the frontend for visualization. Grafana evaluates these expressions on the server, not in the browser or at the data source.

For general information on Grafana expressions, refer to Write expression queries.

Before you begin

Enable SQL expressions under the feature toggle sqlExpressions.
- If you self-host Grafana, you can find feature toggles in the configuration file grafana.ini.

[feature_toggles]
enable = sqlExpressions

If you are using Grafana Cloud, contact Support to enable this feature.

Transform data with SQL expressions

SQL expressions allow you to:

Shape, transform, and modify query results without changing the original query.
JOIN data from multiple tables.
Create alerts or recording rules based on transformed data.
Perform final-stage modifications to datasets, including:
- Show, hide, or rename columns.
- Filter rows based on conditions.
- Aggregate data (for example: sum, average, count).
Write subqueries and Common Table Expressions (CTEs) to support more complex logic:
- Subqueries are nested queries used for filtering, calculations, or transformations.
- CTEs are temporary named result sets that help make complex queries more readable and reusable.

A key capability of SQL expressions is the ability to JOIN data from multiple tables. This allows users to combine and transform data in a predictable, user-friendly way—even for complex use cases. You can JOIN data from an unlimited number of data source queries.

To work with SQL expressions, you must use data from a backend data source. In Grafana, a backend data source refers to a data source plugin or integration that communicates with a database, service, or API through the Grafana server, rather than directly from the browser (frontend).

Compatible data sources

The following are compatible data sources:

Full support: Grafana supports all query types for each of these data sources.

Elasticsearch
MySQL
Loki
Graphite
Google Sheets
Amazon Athena

Partial support: The following data sources have limited or conditional support. Some support multiple query types depending on the service. For example, Azure Monitor can query multiple services, each with its own query format. In some cases, you can also switch the query type within a panel.

InfluxDB
Infinity
Azure Monitor
TestData
Tempo
Prometheus
Cloudwatch
GitHub
BigQuery

Create SQL expressions

To create a SQL expression, complete the following steps:

Navigate to Dashboards in the left-side menu.
Select a dashboard and open a dashboard panel.
Click the ellipsis in the upper right and select Edit .
Click + Expression.
Select SQL from the drop-down.

After you have added a SQL expression, you can select from other data source queries by referencing the RefIDs of the queries in your SQL expression as if they were tables in a SQL database.

Note
The RefID is a unique identifier assigned to each query within a Grafana panel that serves as a reference name for that query’s data.

Workflow to build SQL expressions

Use the following workflow to create a SQL expression:

Build your base queries. Create the individual query and give it a meaningful name. Create the queries (A, B, etc.) that provide the data you want to combine or transform using SQL Expressions.
Hide your base queries. Click the 👁️ Eye icon next to each base query to hide them from visualization. This keeps your panel clean while still making the data available to the SQL Expression.
Switch to table view. Set the panel visualization to Table to inspect and review the structure and output of your SQL expression as you build and refine it.
Add a SQL Expression. Add a new query and add select SQL Expression as its type.
Inspect inputs. Start with simple test queries to understand the shape of your input frames.
SQL
```
SELECT * FROM A LIMIT 10
```
This lets you see the available columns and sample rows from query A. Repeat this for each input query you want to use (e.g., SELECT * FROM B LIMIT 10).
Inspect your data. Repeat this for each input query to understand the column structure and data types you’re working with.
SQL
```
SELECT * FROM <B, C, D, etc> LIMIT 10
```
Construct the SQL expression. Once you understand your data, you can write your SQL expression to join, filter, or otherwise transform the data.
Validate and iterate. Click Refresh every time you update your SQL query to re-evaluate and see the updated result.

When selecting a visualization type, ensure your SQL expression returns data in the required shape. For example, time series panels require a column with a time field (e.g., timestamp) and a numeric value column (e.g., __value__). If the output is not shaped correctly, your visualization may appear empty or fail to render.

The SQL expression workflow in Grafana is designed with the following behaviors:

Unhidden queries are visualized automatically. If an input query is not hidden, Grafana will attempt to render it alongside your SQL expression. This can clutter the output, especially in table visualizations.
SQL expression results may not be immediately visible. You might need to use the data frame selector (dropdown at the bottom of the table panel) to switch between the raw query and the SQL expression result.
Non-tabular or incorrectly shaped data will not render in certain panels. Visualizations such as graphs or gauges require properly structured data. Mismatched formats will result in rendering issues or missing data.

SQL conversion rules

When you reference a RefID within a SQL statement (e.g., SELECT * FROM A), the system invokes a distinct SQL conversion process.

The SQL conversion path:

The query result appears as a single data frame, without labels, and is mapped directly to a tabular format.
If the frame type is present and is either numeric, wide time series, or multi-frame time series (for example: labeled formats), Grafana automatically converts the data into a table structure.

Supported functions

Grafana maintains a complete list of supported SQL keywords, operators, and functions in the SQL expressions query validator implementation.

For the most up-to-date reference of all supported SQL functionality, refer to the allowedNode and allowedFunction definitions in the Grafana codebase.

Alerting and recording rules

SQL expressions integrates alerting and recording rules, allowing you to define complex conditions and metrics using standard SQL queries. The system processes your query results and automatically creates alert instances or recorded metrics based on the returned data structure.

For SQL Expressions to work properly with alerting and recording rules, your query must return:

One numeric column - required. This contains the value that triggers alerts or gets recorded.
Unique string column combinations - required. Each row must have a unique combination of string column values.
One or more string columns - optional. These become labels for the alert instances or metrics. Examples: service, region.

Consider the following query results:

error_count,service,region
25,auth-service,us-east
0,payment-service,us-west
15,user-service,eu-west

This query returns:

the numeric column error_count (values: 25, 0, 15)
the string columns service and region

For alert rules, this creates three alert instances:

First instance with labels {service=auth-service, region=us-east} and value 25 (triggers alert - high error count)
Second instance with labels {service=payment-service, region=us-west} and value 0 (no alert - zero errors)
Third instance with labels {service=user-service, region=eu-west} and value 15 (triggers alert - elevated error count)

For recording rules, creates one metric with three series:

First series: error_count_total{service=auth-service, region=us-east} 25
Second series: error_count_total{service=payment-service, region=us-west} 0
Third series: error_count_total{service=user-service, region=eu-west} 15

Following are some best practices for alerting and recording rules:

Keep numeric values meaningful (for example: error counts, request duration).
Use clear, descriptive column names - these become your labels.
Keep string values short and consistent.
Avoid too many unique label combinations, as this can result in high cardinality.
Always use GROUP BY to avoid duplicate label errors.
Aggregate numeric values logically (for example: SUM(error_count)).

Supported data source formats

Grafana supports three types of data source response formats:

Single Table-like Frame:
This refers to data returned in a standard tabular structure, where all values are organized into rows and columns, similar to what you’d get from a SQL query.
- Example: Any query against a SQL data source (e.g., PostgreSQL, MySQL) with the format set to Table.
Dataplane: Time Series Format:
This format represents time series data with timestamps and associated values. It is typically returned from monitoring data sources.
- Example: Prometheus or Loki Range Queries (queries that return a set of values over time).
Dataplane: Numeric Long Format:
This format is used for point-in-time (instant) metric queries that return a single value (or a set of values) at a specific moment.
- Example: Prometheus or Loki Instant Queries (queries that return the current value of a metric).

For more information on Dataplane formats, refer to Grafana Dataplane Documentation.

The following non-tabular formats are automatically converted to a tabular format (FullLong) when used in SQL expressions:

Time Series Wide: Label keys become column names.
Time Series Multi: Label values become the values in each row (or null if a label is missing).
Numeric Wide: The value column contains the numeric metric value.
Numeric Multi: If a display name exists, it will appear in the display_name column.

During conversion:

Label keys become column names.
Label values populate the corresponding rows (null if a label is missing).
The value column contains the numeric metric.
If available, the display_name column contains a human-readable name.
The metric_name column stores the raw metric identifier.
For time series data, Grafana includes a time column with timestamps

Known limitations

Currently, only one SQL expression is supported per panel or alert.
Grafana supports certain data sources. Refer to compatible data sources for a current list.
Autocomplete is available, but column/field autocomplete is only available after enabling the sqlExpressionsColumnAutoComplete feature toggle, which is provided on an experimental basis.

Regular expression limitations in SQL expressions

SQL expressions depend on a third-party SQL engine that uses cgo by default for full regular expression compatibility with MySQL. However, Grafana is built without cgo, which limits regular expression support.

SQL expressions that use regular expression functions have limitations such as:

Lack of back-references.
No before/after text matching.
Differences in handling carriage return (\r) characters.

There may be other minor differences as well.

For implementation context, refer to the go-mysql-server regular expression compatibility notes.

Schema changes and missing data

SQL expressions have known limitations that may cause queries to fail or return unexpected results. These constraints are inherent to how the feature is implemented and should be understood when building queries.

The following situations are affected:

Error responses – When a data source query returns an error, SQL expressions cannot interpret the result.
No data responses – If a query returns no rows, the SQL expression engine cannot infer a schema.
Dynamic schema responses – If the set of columns or labels changes between query executions, SQL expressions may fail because it treats column changes as schema changes.

SQL expressions are powered by an embedded SQL engine where each query result is treated as a table. The schema of that table is derived from the columns returned by the underlying data source.

Unlike traditional SQL databases, where schemas are usually fixed, many Grafana data sources (for example, Prometheus) can return results with varying label sets or no data at all.

When this happens:

A missing column appears to the SQL engine as if it doesn’t exist.
A completely empty result provides no schema for subsequent SQL operations.
Error responses break the assumption that the query returns tabular data.

As a result, SQL expressions can’t gracefully handle changes in schema or no-data conditions, since these cases violate the static schema model that SQL relies on.

Workarounds

You can mitigate these issues in the following ways:

Avoid SELECT * – Explicitly select only the columns you expect to exist.
Ensure a consistent schema – If possible, configure your query to always return columns, even when no data is present.

Example: Handling Prometheus no data

When joining results from the same Prometheus query across different data source instances, you can use this pattern:

-- Prometheus query
sum by (cluster) (up{job=~".*zruler.*"})
or on (cluster) (
  (0/0) *
  (
    label_replace(vector(1), "cluster", "fake", "", "")
  )
)

-- SQL expression
SELECT
    COALESCE(a.time, b.time) AS time,
    COALESCE(a.cluster, b.cluster) AS cluster,
    COALESCE(a.up, 0) + COALESCE(b.up, 0) AS unified_up
FROM (
    SELECT time, cluster, __value__ AS up
    FROM A
    WHERE cluster != 'fake'
    ORDER BY time
    LIMIT 5
) a
FULL OUTER JOIN (
    SELECT time, cluster, __value__ AS up
    FROM B
    WHERE cluster != 'fake'
    ORDER BY time
    LIMIT 5
) b ON a.time = b.time;

This approach ensures that a schema exists even when one query returns no data.

SQL expressions examples

Create the following Prometheus query:
promql
```
sum(
  rate(go_cpu_classes_gc_total_cpu_seconds_total{namespace=~".*(namespace).*5."}[$__rate_interval])
) by (namespace)
```
The panel displays the CPU usage by Go garbage collection (GC) over time, broken down by namespace.
Add the SQL expression SELECT * from A. After you add a SQL expression that selects from RefID A, Grafana converts it to a table response:

LLM integration

The Grafana LLM plugin seamlessly integrates AI-powered assistance into your SQL expressions workflow.

Note
The Grafana LLM plugin is currently in public preview, meaning Grafana offers limited support, and breaking changes might occur prior to the feature being made generally available.

To use this integration, first install and configure the LLM plugin. After installation, open your dashboard and select Edit to open the panel editor. Navigate to the Queries tab and scroll to the bottom where you’ll find two new buttons positioned to the right of the Run query button in your SQL Expressions query.

Click Explain query to open a drawer that displays a detailed explanation of your query, including its interpreted business meaning and performance statistics. Once the explanation is generated, the button changes to View explanation.

Click Improve query to open a suggestions drawer that contains performance and reliability enhancements, column naming best practices, and guidance on panel optimization. Click Apply to implement a suggestion. After you’ve interacted with the interface, you’ll see a Suggestions button for quick access. Newer suggestions appear at the top, with older ones listed below, creating a history of improvements. If your SQL query has a parsing error, such as a syntax issue, the LLM will attempt to provide a corrected version. The LLM automatically identifies errors and helps you rewrite the query correctly.

Share query results with another panel

Fri, 03 Apr 2026 12:35:46 -0500

Grafana lets you use the query result from one panel for any other panel in the dashboard. Sharing query results across panels reduces the number of queries made to your data source, which can improve the performance of your dashboard.

The Dashboard data source lets you select a panel in your dashboard that contains the queries ‌you want to share the results for. Instead of sending a separate query for each panel, Grafana sends one query and other panels use the query results to construct visualizations.

This strategy can drastically reduce the number of queries being made when you for example have several panels visualizing the same data.

Create a dashboard.
Create a panel.
Change the panel title to “Source panel”. You’ll use this panel as a source for the other panels.
Define the query or queries that you want share.

If you don’t have a data source available, use the Grafana data source, which returns a random time series that you can use for testing.
Add a new panel and select the Dashboard data source in the query editor.
In the Use results from panel list, select the first panel you created.

All queries defined in the source panel are now available to the new panel. Queries defined in the source panel can be shared with multiple panels.

You can click on any of the queries to go to the panel where they are defined.

Transform data

Fri, 03 Apr 2026 12:35:46 -0500

Transform data

Transformations are a powerful way to manipulate data returned by a query before the system applies a visualization. Using transformations, you can:

Rename fields
Join time series/SQL-like data
Perform mathematical operations across queries
Use the output of one transformation as the input to another transformation

Start your learning experience with Grafana Learning Paths

Grafana Learning Paths provide a clear, structured path that leads you from beginner concepts to advanced use cases. Learn about this Grafana feature on Transform data in a Grafana Cloud dashboard.

Start learning

For users that rely on multiple views of the same dataset, transformations offer an efficient method of creating and maintaining numerous dashboards.

You can also use the output of one transformation as the input to another transformation, which results in a performance gain.

Sometimes the system cannot graph transformed data. When that happens, click the Table view toggle above the visualization to switch to a table view of the data. This can help you understand the final result of your transformations.

Transformation types

Grafana provides a number of ways that you can transform data. For a complete list of transformations, refer to Transformation functions.

Order of transformations

When there are multiple transformations, Grafana applies them in the order they are listed. Each transformation creates a result set that then passes on to the next transformation in the processing pipeline.

The order in which Grafana applies transformations directly impacts the results. For example, if you use a Reduce transformation to condense all the results of one column into a single value, then you can only apply transformations to that single value.

Dashboard variables in transformations

All text input fields in transformations accept variable syntax:

When you use dashboard variables in transformations, the variables are automatically interpolated before the transformations are applied to the data.

For an example, refer to Use a dashboard variable in the Filter fields by name transformation.

Add a transformation function to data

The following steps guide you in adding a transformation to data. This documentation does not include steps for each type of transformation. For a complete list of transformations, refer to Transformation functions.

Navigate to the panel where you want to add one or more transformations.
Hover over any part of the panel to display the actions menu on the top right corner.
Click the menu and select Edit.
Click the Transform tab.
Click a transformation. A transformation row appears where you configure the transformation options. For more information about how to configure a transformation, refer to Transformation functions. For information about available calculations, refer to Calculation types.
To apply another transformation, click Add transformation. This transformation acts on the result set returned by the previous transformation.

Debug a transformation

To see the input and the output result sets of the transformation, click the bug icon on the right side of the transformation row.

The input and output results sets can help you debug a transformation.

Disable a transformation

You can disable or hide one or more transformations by clicking on the eye icon on the top right side of the transformation row. This disables the applied actions of that specific transformation and can help to identify issues when you change several transformations one after another.

Filter a transformation

If your panel uses more than one query, you can filter these and apply the selected transformation to only one of the queries. To do this, click the filter icon on the top right of the transformation row. This opens a drop-down with a list of queries used on the panel. From here, you can select the query you want to transform.

You can also filter by annotations (which includes exemplars) to apply transformations to them. When you do so, the list of fields changes to reflect those in the annotation or exemplar tooltip.

The filter icon is always displayed if your panel has more than one query or source of data (that is, panel or annotation data) but it may not work if previous transformations for merging the queries’ outputs are applied. This is because one transformation takes the output of the previous one.

Delete a transformation

We recommend that you remove transformations that you don’t need. When you delete a transformation, you remove the data from the visualization.

Before you begin:

Identify all dashboards that rely on the transformation and inform impacted dashboard users.

To delete a transformation:

Open a panel for editing.
Click the Transform tab.
Click the trash icon next to the transformation you want to delete.

Transformation functions

You can perform the following transformations on your data.

Add field from calculation

Use this transformation to add a new field calculated from two other fields. Each transformation allows you to add one new field.

Mode - Select a mode:
- Reduce row - Apply selected calculation on each row of selected fields independently.
- Binary operation - Apply basic binary operations (for example, sum or multiply) on values in a single row from two selected fields.
- Unary operation - Apply basic unary operations on values in a single row from a selected field. The available operations are:
  - Absolute value (abs) - Returns the absolute value of a given expression. It represents its distance from zero as a positive number.
  - Natural exponential (exp) - Returns e raised to the power of a given expression.
  - Natural logarithm (ln) - Returns the natural logarithm of a given expression.
  - Floor (floor) - Returns the largest integer less than or equal to a given expression.
  - Ceiling (ceil) - Returns the smallest integer greater than or equal to a given expression.
- Cumulative functions - Apply functions on the current row and all preceding rows.
  - Total - Calculates the cumulative total up to and including the current row.
  - Mean - Calculates the mean up to and including the current row.
- Window functions - Apply window functions. The window can either be trailing or centered. With a trailing window the current row will be the last row in the window. With a centered window the window will be centered on the current row. For even window sizes, the window will be centered between the current row, and the previous row.
  - Mean - Calculates the moving mean or running average.
  - Stddev - Calculates the moving standard deviation.
  - Variance - Calculates the moving variance.
- Row index - Insert a field with the row index.
Field name - Select the names of fields you want to use in the calculation for the new field.
Calculation - If you select Reduce row mode, then the Calculation field appears. Click in the field to see a list of calculation choices you can use to create the new field. For information about available calculations, refer to Calculation types.
Operation - If you select Binary operation or Unary operation mode, then the Operation fields appear. These fields allow you to apply basic math operations on values in a single row from selected fields. You can also use numerical values for binary operations.
- All number fields - Set the left side of a Binary operation to apply the calculation to all number fields.
As percentile - If you select Row index mode, then the As percentile switch appears. This switch allows you to transform the row index as a percentage of the total number of rows.
Alias - (Optional) Enter the name of your new field. If you leave this blank, then the field will be named to match the calculation.

Note: If a variable is used in this transformation, the default alias will be interpolated with the value of the variable. If you want an alias to be unaffected by variable changes, explicitly define the alias.
Replace all fields - (Optional) Select this option if you want to hide all other fields and display only your calculated field in the visualization.

In the example below, we added two fields together and named them Sum.

Concatenate fields

Use this transformation to combine all fields from all frames into one result.

For example, if you have separate queries retrieving temperature and uptime data (Query A) and air quality index and error information (Query B), applying the concatenate transformation yields a consolidated data frame with all relevant information in one view.

Consider the following:

Query A:

Temp	Uptime
15.4	1230233

Query B:

AQI	Errors
3.2	5

After you concatenate the fields, the data frame would be:

Temp	Uptime	AQI	Errors
15.4	1230233	3.2	5

This transformation simplifies the process of merging data from different sources, providing a comprehensive view for analysis and visualization.

Config from query results

Use this transformation to select a query and extract standard options, such as Min, Max, Unit, and Thresholds, and apply them to other query results. This feature enables dynamic visualization configuration based on the data returned by a specific query.

Options

Config query - Select the query that returns the data you want to use as configuration.
Apply to - Select the fields or series to which the configuration should be applied.
Apply to options - Specify a field type or use a field name regex, depending on your selection in Apply to.

Field mapping table

Below the configuration options, you’ll find the field mapping table. This table lists all fields found in the data returned by the config query, along with Use as and Select options. It provides control over mapping fields to config properties, and for multiple rows, it allows you to choose which value to select.

Example

Input[0] (From query: A, name: ServerA)

Time	Value
1626178119127	10
1626178119129	30

Input[1] (From query: B)

Time	Value
1626178119127	100
1626178119129	100

Output (Same as Input[0] but now with config on the Value field)

Time	Value (config: Max=100)
1626178119127	10
1626178119129	30

Each row in the source data becomes a separate field. Each field now has a maximum configuration option set. Options such as Min, Max, Unit, and Thresholds are part of the field configuration. If set, they are used by the visualization instead of any options manually configured in the panel editor options pane.

Value mappings

You can also transform a query result into value mappings. With this option, every row in the configuration query result defines a single value mapping row. See the following example.

Config query result:

Value	Text	Color
L	Low	blue
M	Medium	green
H	High	red

In the field mapping specify:

Field	Use as	Select
Value	Value mappings / Value	All values
Text	Value mappings / Text	All values
Color	Value mappings / Color	All values

Grafana builds value mappings from your query result and applies them to the real data query results. You should see values being mapped and colored according to the config query results.

Note: When you use this transformation for thresholds, the visualization continues to use the panel’s base threshold.

Convert field type

Use this transformation to modify the field type of a specified field.

This transformation has the following options:

Field - Select from available fields
as - Select the FieldType to convert to
- Numeric - attempts to make the values numbers
- String - will make the values strings
- Time - attempts to parse the values as time
  - The input will be parsed according to the Moment.js parsing format
  - It will parse the numeric input as a Unix epoch timestamp in milliseconds. You must multiply your input by 1000 if it’s in seconds.
  - Will show an option to specify a DateFormat as input by a string like yyyy-mm-dd or DD MM YYYY hh:mm:ss
- Boolean - will make the values booleans
- Enum - will make the values enums
  - Will show a table to manage the enums
- Other - attempts to parse the values as JSON

For example, consider the following query that could be modified by selecting the time field as Time and specifying Date Format as YYYY.

Sample Query

Time	Mark	Value
2017-07-01	above	25
2018-08-02	below	22
2019-09-02	below	29
2020-10-04	above	22

The result:

Transformed Query

Time	Mark	Value
2017-01-01 00:00:00	above	25
2018-01-01 00:00:00	below	22
2019-01-01 00:00:00	below	29
2020-01-01 00:00:00	above	22

This transformation allows you to flexibly adapt your data types, ensuring compatibility and consistency in your visualizations.

Extract fields

Use this transformation to select a source of data and extract content from it in different formats. This transformation has the following fields:

Source - Select the field for the source of data.
Format - Choose one of the following:
- JSON - Parse JSON content from the source.
- Key+value pairs - Parse content in the format ‘a=b’ or ‘c:d’ from the source.
- RegExp - Parse content using a regular expression with named capturing group(s) like /(?<NewField>.*)/.
- Auto - Discover fields automatically.
Replace All Fields - (Optional) Select this option to hide all other fields and display only your calculated field in the visualization.
Keep Time - (Optional) Available only if Replace All Fields is true. Keeps the time field in the output.

Consider the following dataset:

Dataset Example

Timestamp	json_data
1636678740000000000	{“value”: 1}
1636678680000000000	{“value”: 5}
1636678620000000000	{“value”: 12}

You could prepare the data to be used by a Time series panel with this configuration:

Source: json_data
Format: JSON
- Field: value
- Alias: my_value
Replace all fields: true
Keep time: true

This will generate the following output:

Transformed Data

Timestamp	my_value
1636678740000000000	1
1636678680000000000	5
1636678620000000000	12

This transformation allows you to extract and format data in various ways. You can customize the extraction format based on your specific data needs.

Lookup fields from resource

Use this transformation to enrich a field value by looking up additional fields from an external source.

This transformation has the following fields:

Field - Select a text field from your dataset.
Lookup - Choose from Countries, USA States, and Airports.

This transformation currently supports spatial data.

For example, if you have this data:

Dataset Example

Location	Values
AL	0
AK	10
Arizona	5
Arkansas	1
Somewhere	5

With this configuration:

Field: location
Lookup: USA States

You’ll get the following output:

Transformed Data

Location	ID	Name	Lng	Lat	Values
AL	AL	Alabama	-80.891064	12.448457	0
AK	AK	Arkansas	-100.891064	24.448457	10
Arizona					5
Arkansas					1
Somewhere					5

This transformation lets you augment your data by fetching additional information from external sources, providing a more comprehensive dataset for analysis and visualization.

Filter data by query refId

Use this transformation to hide one or more queries in panels that have multiple queries.

Grafana displays the query identification letters in dark gray text. Click a query identifier to toggle filtering. If the query letter is white, then the results are displayed. If the query letter is dark, then the results are hidden.

Note: This transformation is not available for Graphite because this data source does not support correlating returned data with queries.

In the example below, the panel has three queries (A, B, C). We removed the B query from the visualization.

Filter data by values

Use this transformation to selectively filter data points directly within your visualization. This transformation provides options to include or exclude data based on one or more conditions applied to a selected field.

This transformation is very useful if your data source does not natively filter by values. You might also use this to narrow values to display if you are using a shared query.

The available conditions for all fields are:

Is Null - Match if the value is null.
Is Not Null - Match if the value is not null.
Equal - Match if the value is equal to the specified value.
Not Equal - Match if the value is not equal to the specified value.
Regex - Match a regex expression.

The available conditions for string fields are:

Contains substring - Match if the value contains the specified substring (case insensitive).
Does not contain substring - Match if the value doesn’t contain the specified substring (case insensitive).

The available conditions for number fields are:

Greater - Match if the value is greater than the specified value.
Lower - Match if the value is lower than the specified value.
Greater or equal - Match if the value is greater or equal.
Lower or equal - Match if the value is lower or equal.
In between - Match a range between a specified minimum and maximum, min and max included.

The available conditions for time fields are:

In between - Match a range between a specified minimum and maximum. The min and max values will pre-populate with variables to filter by selected time.

Consider the following dataset:

Dataset Example

Time	Temperature	Altitude
2020-07-07 11:34:23	32	101
2020-07-07 11:34:22	28	125
2020-07-07 11:34:21	26	110
2020-07-07 11:34:20	23	98
2020-07-07 10:32:24	31	95
2020-07-07 10:31:22	20	85
2020-07-07 09:30:57	19	101

If you Include the data points that have a temperature below 30°C, the configuration will look as follows:

Filter Type: ‘Include’
Condition: Rows where ‘Temperature’ matches ‘Lower Than’ ‘30’

And you will get the following result, where only the temperatures below 30°C are included:

Transformed Data

Time	Temperature	Altitude
2020-07-07 11:34:22	28	125
2020-07-07 11:34:21	26	110
2020-07-07 11:34:20	23	98
2020-07-07 10:31:22	20	85
2020-07-07 09:30:57	19	101

You can add more than one condition to the filter. For example, you might want to include the data only if the altitude is greater than 100. To do so, add that condition to the following configuration:

Filter type: ‘Include’ rows that ‘Match All’ conditions
Condition 1: Rows where ‘Temperature’ matches ‘Lower’ than ‘30’
Condition 2: Rows where ‘Altitude’ matches ‘Greater’ than ‘100’

When you have more than one condition, you can choose if you want the action (include/exclude) to be applied on rows that Match all conditions or Match any of the conditions you added.

In the example above, we chose Match all because we wanted to include the rows that have a temperature lower than 30°C AND an altitude higher than 100. If we wanted to include the rows that have a temperature lower than 30°C OR an altitude higher than 100 instead, then we would select Match any. This would include the first row in the original data, which has a temperature of 32°C (does not match the first condition) but an altitude of 101 (which matches the second condition), so it is included.

Conditions that are invalid or incompletely configured are ignored.

This versatile data filtering transformation lets you to selectively include or exclude data points based on specific conditions. Customize the criteria to tailor your data presentation to meet your unique analytical needs.

Filter fields by name

Use this transformation to selectively remove parts of your query results. There are three ways to filter field names:

Use a regular expression

When you filter using a regular expression, field names that match the regular expression are included.

For example, from the input data:

Time	dev-eu-west	dev-eu-north	prod-eu-west	prod-eu-north
2023-03-04 23:56:23	23.5	24.5	22.2	20.2
2023-03-04 23:56:23	23.6	24.4	22.1	20.1

The result from using the regular expression ‘prod.*’ would be:

Time	prod-eu-west	prod-eu-north
2023-03-04 23:56:23	22.2	20.2
2023-03-04 23:56:23	22.1	20.1

The regular expression can include an interpolated dashboard variable by using the ${variableName} syntax.

Manually select included fields

Click and uncheck the field names to remove them from the result. Fields that are matched by the regular expression are still included, even if they’re unchecked.

Use a dashboard variable

Enable ‘From variable’ to let you select a dashboard variable that’s used to include fields. By setting up a dashboard variable with multiple choices, the same fields can be displayed across multiple visualizations.

Here’s the table after we applied the transformation to remove the Min field.

Here is the same query using a Stat visualization.

This transformation provides flexibility in tailoring your query results to focus on the specific fields you need for effective analysis and visualization.

Format string

Use this transformation to customize the output of a string field. This transformation has the following fields:

Upper case - Formats the entire string in uppercase characters.
Lower case - Formats the entire string in lowercase characters.
Sentence case - Formats the first character of the string in uppercase.
Title case - Formats the first character of each word in the string in uppercase.
Pascal case - Formats the first character of each word in the string in uppercase and doesn’t include spaces between words.
Camel case - Formats the first character of each word in the string in uppercase, except the first word, and doesn’t include spaces between words.
Snake case - Formats all characters in the string in lowercase and uses underscores instead of spaces between words.
Kebab case - Formats all characters in the string in lowercase and uses dashes instead of spaces between words.
Trim - Removes all leading and trailing spaces from the string.
Substring - Returns a substring of the string, using the specified start and end positions.

This transformation provides a convenient way to standardize and tailor the presentation of string data for better visualization and analysis.

Format time

Use this transformation to customize the output of a time field. Output can be formatted using Moment.js format strings. For example, if you want to display only the year of a time field, the format string ‘YYYY’ can be used to show the calendar year (for example, 1999 or 2012).

Before Transformation:

Timestamp	Event
1636678740000000000	System Start
1636678680000000000	User Login
1636678620000000000	Data Updated

After applying ‘YYYY-MM-DD HH:mm:ss’:

Timestamp	Event
2021-11-12 14:25:40	System Start
2021-11-12 14:24:40	User Login
2021-11-12 14:23:40	Data Updated

This transformation lets you tailor the time representation in your visualizations, providing flexibility and precision in displaying temporal data.

Note: This transformation is available in Grafana 10.1+ as an alpha feature.

Group by

Use this transformation to group the data by a specified field (column) value and process calculations on each group. Click to see a list of calculation choices. For information about available calculations, refer to Calculation types.

Here’s an example of original data.

Time	Server ID	CPU Temperature	Server Status
2020-07-07 11:34:20	server 1	80	Shutdown
2020-07-07 11:34:20	server 3	62	OK
2020-07-07 10:32:20	server 2	90	Overload
2020-07-07 10:31:22	server 3	55	OK
2020-07-07 09:30:57	server 3	62	Rebooting
2020-07-07 09:30:05	server 2	88	OK
2020-07-07 09:28:06	server 1	80	OK
2020-07-07 09:25:05	server 2	88	OK
2020-07-07 09:23:07	server 1	86	OK

This transformation goes in two steps. First you specify one or multiple fields to group the data by. This will group all the same values of those fields together, as if you sorted them. For instance if we group by the Server ID field, then it would group the data this way:

Time	Server ID	CPU Temperature	Server Status
2020-07-07 11:34:20	server 1	80	Shutdown
2020-07-07 09:28:06	server 1	80	OK
2020-07-07 09:23:07	server 1	86	OK
2020-07-07 10:32:20	server 2	90	Overload
2020-07-07 09:30:05	server 2	88	OK
2020-07-07 09:25:05	server 2	88	OK
2020-07-07 11:34:20	*server 3*	62	OK
2020-07-07 10:31:22	*server 3*	55	OK
2020-07-07 09:30:57	*server 3*	62	Rebooting

All rows with the same value of Server ID are grouped together. Optionally, you can add a count of how may values fall in the selected group.

After choosing which field you want to group your data by, you can add various calculations on the other fields, and apply the calculation to each group of rows. For instance, we could want to calculate the average CPU temperature for each of those servers. So we can add the mean calculation applied on the CPU Temperature field to get the following:

Server ID	CPU Temperature (mean)
server 1	82
server 2	88.6
server 3	59.6

If you had added the count stat to the group by transformation, there would be an extra column showing that the count of each server from above was 3.

Server ID	CPU Temperature (mean)	Server ID (count)
server 1	82	3
server 2	88.6	3
server 3	59.6	3

And we can add more than one calculation. For instance:

For field Time, we can calculate the Last value, to know when the last data point was received for each server
For field Server Status, we can calculate the Last value to know what is the last state value for each server
For field Temperature, we can also calculate the Last value to know what is the latest monitored temperature for each server

We would then get:

Server ID	CPU Temperature (mean)	CPU Temperature (last)	Time (last)	Server Status (last)
server 1	82	80	2020-07-07 11:34:20	Shutdown
server 2	88.6	90	2020-07-07 10:32:20	Overload
server 3	59.6	62	2020-07-07 11:34:20	OK

This transformation allows you to extract essential information from your time series and present it conveniently.

Grouping to matrix

Use this transformation to combine three fields—which are used as input for the Column, Row, and Cell value fields from the query output—and generate a matrix. The matrix is calculated as follows:

Original data

Server ID	CPU Temperature	Server Status
server 1	82	OK
server 2	88.6	OK
server 3	59.6	Shutdown

We can generate a matrix using the values of ‘Server Status’ as column names, the ‘Server ID’ values as row names, and the ‘CPU Temperature’ as content of each cell. The content of each cell will appear for the existing column (‘Server Status’) and row combination (‘Server ID’). For the rest of the cells, you can select which value to display between: Null, True, False, or Empty.

Output

Server IDServer Status	OK	Shutdown
server 1	82
server 2	88.6
server 3		59.6

Use this transformation to construct a matrix by specifying fields from your query results. The matrix output reflects the relationships between the unique values in these fields. This helps you present complex relationships in a clear and structured matrix format.

Group to nested tables

Use this transformation to group the data by a specified field (column) value and process calculations on each group. Records are generated that share the same grouped field value, to be displayed in a nested table.

To calculate a statistic for a field, click the selection box next to it and select the Calculate option:

Once Calculate has been selected, another selection box will appear next to the respective field which will allow statistics to be selected:

For information about available calculations, refer to Calculation types.

Here’s an example of original data:

Time	Server ID	CPU Temperature	Server Status
2020-07-07 11:34:20	server 1	80	Shutdown
2020-07-07 11:34:20	server 3	62	OK
2020-07-07 10:32:20	server 2	90	Overload
2020-07-07 10:31:22	server 3	55	OK
2020-07-07 09:30:57	server 3	62	Rebooting
2020-07-07 09:30:05	server 2	88	OK
2020-07-07 09:28:06	server 1	80	OK
2020-07-07 09:25:05	server 2	88	OK
2020-07-07 09:23:07	server 1	86	OK

This transformation has two steps. First, specify one or more fields by which to group the data. This groups all the same values of those fields together, as if you sorted them. For instance, if you group by the Server ID field, Grafana groups the data this way:

Server ID

server 1


Time	CPU Temperature	Server Status
2020-07-07 11:34:20	80	Shutdown
2020-07-07 09:28:06	80	OK
2020-07-07 09:23:07	86	OK

server 2


Time	CPU Temperature	Server Status
2020-07-07 10:32:20	90	Overload
2020-07-07 09:30:05	88	OK
2020-07-07 09:25:05	88	OK

server 3


Time	CPU Temperature	Server Status
2020-07-07 11:34:20	62	OK
2020-07-07 10:31:22	55	OK
2020-07-07 09:30:57	62	Rebooting

After choosing the field by which you want to group your data, you can add various calculations on the other fields and apply the calculation to each group of rows. For instance, you might want to calculate the average CPU temperature for each of those servers. To do so, add the mean calculation applied on the CPU Temperature field to get the following result:

Server ID

CPU Temperatute (mean)

server 1


Time	Server Status
2020-07-07 11:34:20	Shutdown
2020-07-07 09:28:06	OK
2020-07-07 09:23:07	OK

server 2

88.6


Time	Server Status
2020-07-07 10:32:20	Overload
2020-07-07 09:30:05	OK
2020-07-07 09:25:05	OK

server 3

59.6


Time	Server Status
2020-07-07 11:34:20	OK
2020-07-07 10:31:22	OK
2020-07-07 09:30:57	Rebooting

Create heatmap

Use this transformation to prepare histogram data for visualizing trends over time. Similar to the heatmap visualization, this transformation converts histogram metrics into temporal buckets.

X Bucket

This setting determines how the x-axis is split into buckets.

Size - Specify a time interval in the input field. For example, a time range of ‘1h’ creates cells one hour wide on the x-axis.
Count - For non-time-related series, use this option to define the number of elements in a bucket.

Y Bucket

This setting determines how the y-axis is split into buckets.

Linear
Logarithmic - Choose between log base 2 or log base 10.
Symlog - Uses a symmetrical logarithmic scale. Choose between log base 2 or log base 10, allowing for negative values.

Assume you have the following dataset:

Timestamp	Value
2023-01-01 12:00:00	5
2023-01-01 12:15:00	10
2023-01-01 12:30:00	15
2023-01-01 12:45:00	8

With X Bucket set to ‘Size: 15m’ and Y Bucket as ‘Linear’, the histogram organizes values into time intervals of 15 minutes on the x-axis and linearly on the y-axis.
For X Bucket as ‘Count: 2’ and Y Bucket as ‘Logarithmic (base 10)’, the histogram groups values into buckets of two on the x-axis and use a logarithmic scale on the y-axis.

Histogram

Use this transformation to generate a histogram based on input data, allowing you to visualize the distribution of values.

Bucket size - The range between the lowest and highest items in a bucket (xMin to xMax).
Bucket offset - The offset for non-zero-based buckets.
Combine series - Create a unified histogram using all available series.

Original data

Series 1:

A	B	C
1	3	5
2	4	6
3	5	7
4	6	8
5	7	9

Series 2:

C
5
6
7
8
9

Output

xMin	xMax	A	B	C	C
1	2	1	0	0	0
2	3	1	0	0	0
3	4	1	1	0	0
4	5	1	1	0	0
5	6	1	1	1	1
6	7	0	1	1	1
7	8	0	1	1	1
8	9	0	0	1	1
9	10	0	0	1	1

Visualize the distribution of values using the generated histogram, providing insights into the data’s spread and density.

Join by field

Use this transformation to merge multiple results into a single table, enabling the consolidation of data from different queries.

This is especially useful for converting multiple time series results into a single wide table with a shared time field.

Inner join (for Time Series or SQL-like data)

An inner join merges data from multiple tables where all tables share the same value from the selected field. This type of join excludes data where values do not match in every result.

Use this transformation to combine the results from multiple queries (combining on a passed join field or the first time column) into one result, and drop rows where a successful join cannot occur. This is not optimized for large Time Series datasets.

In the following example, two queries return Time Series data. It is visualized as two separate tables before applying the inner join transformation.

Query A:

Time	Job	Uptime
2020-07-07 11:34:20	node	25260122
2020-07-07 11:24:20	postgre	123001233
2020-07-07 11:14:20	postgre	345001233

Query B:

Time	Server	Errors
2020-07-07 11:34:20	server 1	15
2020-07-07 11:24:20	server 2	5
2020-07-07 11:04:20	server 3	10

The result after applying the inner join transformation looks like the following:

Time	Job	Uptime	Server	Errors
2020-07-07 11:34:20	node	25260122	server 1	15
2020-07-07 11:24:20	postgre	123001233	server 2	5

This works in the same way for non-Time Series tabular data as well.

Students

StudentID	Name	Major
1	John	Computer Science
2	Emily	Mathematics
3	Michael	Physics
4	Jennifer	Chemistry

Enrollments

StudentID	CourseID	Grade
1	CS101	A
1	CS102	B
2	MATH201	A
3	PHYS101	B
5	HIST101	B

The result after applying the inner join transformation looks like the following:

StudentID	Name	Major	CourseID	Grade
1	John	Computer Science	CS101	A
1	John	Computer Science	CS102	B
2	Emily	Mathematics	MATH201	A
3	Michael	Physics	PHYS101	B

The inner join only includes rows where there is a match between the “StudentID” in both tables. In this case, the result does not include “Jennifer” from the “Students” table because there are no matching enrollments for her in the “Enrollments” table.

Outer join (for Time Series data)

An outer join includes all data from an inner join and rows where values do not match in every input. While the inner join joins Query A and Query B on the time field, the outer join includes all rows that don’t match on the time field.

In the following example, two queries return table data. It is visualized as two tables before applying the outer join transformation.

Query A:

Time	Job	Uptime
2020-07-07 11:34:20	node	25260122
2020-07-07 11:24:20	postgre	123001233
2020-07-07 11:14:20	postgre	345001233

Query B:

Time	Server	Errors
2020-07-07 11:34:20	server 1	15
2020-07-07 11:24:20	server 2	5
2020-07-07 11:04:20	server 3	10

The result after applying the outer join transformation looks like the following:

Time	Job	Uptime	Server	Errors
2020-07-07 11:04:20			server 3	10
2020-07-07 11:14:20	postgre	345001233
2020-07-07 11:34:20	node	25260122	server 1	15
2020-07-07 11:24:20	postgre	123001233	server 2	5

In the following example, a template query displays time series data from multiple servers in a table visualization. The results of only one query can be viewed at a time.

I applied a transformation to join the query results using the time field. Now I can run calculations, combine, and organize the results in this new table.

Outer join (for SQL-like data)

A tabular outer join combining tables so that the result includes matched and unmatched rows from either or both tables.

StudentID	Name	Major
1	John	Computer Science
2	Emily	Mathematics
3	Michael	Physics
4	Jennifer	Chemistry

Can now be joined with:

StudentID	CourseID	Grade
1	CS101	A
1	CS102	B
2	MATH201	A
3	PHYS101	B
5	HIST101	B

The result after applying the outer join transformation looks like the following:

StudentID	Name	Major	CourseID	Grade
1	John	Computer Science	CS101	A
1	John	Computer Science	CS102	B
2	Emily	Mathematics	MATH201	A
3	Michael	Physics	PHYS101	B
4	Jennifer	Chemistry	NULL	NULL
5	NULL	NULL	HIST101	B

Combine and analyze data from various queries with table joining for a comprehensive view of your information.

Join by labels

Use this transformation to join multiple results into a single table.

This is especially useful for converting multiple time series results into a single wide table with a shared Label field.

Join - Select the label to join by between the labels available or common across all time series.
Value - The name for the output result.

Example

Input

series1{what=“Temp”, cluster=“A”, job=“J1”}

Time	Value
1	10
2	200

series2{what=“Temp”, cluster=“B”, job=“J1”}

Time	Value
1	10
2	200

series3{what=“Speed”, cluster=“B”, job=“J1”}

Time	Value
22	22
28	77

Config

value: “what”

Output

cluster	job	Temp	Speed
A	J1	10
A	J1	200
B	J1	10	22
B	J1	200	77

Combine and organize time series data effectively with this transformation for comprehensive insights.

Labels to fields

Use this transformation to convert time series results with labels or tags into a table, including each label’s keys and values in the result. Display labels as either columns or row values for enhanced data visualization.

Given a query result of two time series:

Series 1: labels Server=Server A, Datacenter=EU
Series 2: labels Server=Server B, Datacenter=EU

In “Columns” mode, the result looks like this:

Time	Server	Datacenter	Value
2020-07-07 11:34:20	Server A	EU	1
2020-07-07 11:34:20	Server B	EU	2

In “Rows” mode, the result has a table for each series and show each label value like this:

label	value
Server	Server A
Datacenter	EU

label	value
Server	Server B
Datacenter	EU

Value field name

If you selected Server as the Value field name, then you would get one field for every value of the Server label.

Time	Datacenter	Server A	Server B
2020-07-07 11:34:20	EU	1	2

Merging behavior

The labels to fields transformer is internally two separate transformations. The first acts on single series and extracts labels to fields. The second is the merge transformation that joins all the results into a single table. The merge transformation tries to join on all matching fields. This merge step is required and cannot be turned off.

To illustrate this, here is an example where you have two queries that return time series with no overlapping labels.

Series 1: labels Server=ServerA
Series 2: labels Datacenter=EU

This will first result in these two tables:

Time	Server	Value
2020-07-07 11:34:20	ServerA	10

Time	Datacenter	Value
2020-07-07 11:34:20	EU	20

After merge:

Time	Server	Value	Datacenter
2020-07-07 11:34:20	ServerA	10
2020-07-07 11:34:20		20	EU

Convert your time series data into a structured table format for a clearer and more organized representation.

Limit

Use this transformation to restrict the number of rows displayed, providing a more focused view of your data. This is particularly useful when dealing with large datasets.

Below is an example illustrating the impact of the Limit transformation on a response from a data source:

Time	Metric	Value
2020-07-07 11:34:20	Temperature	25
2020-07-07 11:34:20	Humidity	22
2020-07-07 10:32:20	Humidity	29
2020-07-07 10:31:22	Temperature	22
2020-07-07 09:30:57	Humidity	33
2020-07-07 09:30:05	Temperature	19

Here is the result after adding a Limit transformation with a value of ‘3’:

Time	Metric	Value
2020-07-07 11:34:20	Temperature	25
2020-07-07 11:34:20	Humidity	22
2020-07-07 10:32:20	Humidity	29

Using a negative number, you can keep values from the end of the set. Here is the result after adding a Limit transformation with a value of ‘-3’:

Time	Metric	Value
2020-07-07 10:31:22	Temperature	22
2020-07-07 09:30:57	Humidity	33
2020-07-07 09:30:05	Temperature	19

This transformation helps you tailor the visual presentation of your data to focus on the most relevant information.

Merge series/tables

Use this transformation to combine the results from multiple queries into a single result, which is particularly useful when using the table panel visualization. This transformation merges values into the same row if the shared fields contain the same data.

Here’s an example illustrating the impact of the Merge series/tables transformation on two queries returning table data:

Query A:

Time	Job	Uptime
2020-07-07 11:34:20	node	25260122
2020-07-07 11:24:20	postgre	123001233

Query B:

Time	Job	Errors
2020-07-07 11:34:20	node	15
2020-07-07 11:24:20	postgre	5

Here is the result after applying the Merge transformation.

Time	Job	Errors	Uptime
2020-07-07 11:34:20	node	15	25260122
2020-07-07 11:24:20	postgre	5	123001233

This transformation combines values from Query A and Query B into a unified table, enhancing the presentation of data for better insights.

Organize fields by name

Use this transformation to provide the flexibility to rename, reorder, or hide fields returned by a single query in your panel. This transformation is applicable only to panels with a single query. If your panel has multiple queries, consider using an “Outer join” transformation or removing extra queries.

Transforming fields

Grafana displays a list of fields returned by the query, allowing you to perform the following actions:

Set field order mode - If the mode is Manual, you can change the field order by hovering the cursor over a field and dragging the field to its new position. If it’s Auto, use the OFF, ASC, and DESC options to order by any labels on the field or by the field name. For any field that is sorted ASC or DESC, you can drag the option to set the priority of the sorting.
Change field order - Hover over a field, and when your cursor turns into a hand, drag the field to its new position.
Hide or show a field - Use the eye icon next to the field name to toggle the visibility of a specific field.
Rename fields - Type a new name in the “Rename ” box to customize field names.

Example:

Original Query Result

Time	Metric	Value
2020-07-07 11:34:20	Temperature	25
2020-07-07 11:34:20	Humidity	22
2020-07-07 10:32:20	Humidity	29

After Applying Field Overrides

Time	Sensor	Reading
2020-07-07 11:34:20	Temperature	25
2020-07-07 11:34:20	Humidity	22
2020-07-07 10:32:20	Humidity	29

This transformation lets you to tailor the display of query results, ensuring a clear and insightful representation of your data in Grafana.

Partition by values

Use this transformation to streamline the process of graphing multiple series without the need for multiple queries with different ‘WHERE’ clauses.

This is particularly useful when dealing with a metrics SQL table, as illustrated below:

Time	Region	Value
2022-10-20 12:00:00	US	1520
2022-10-20 12:00:00	EU	2936
2022-10-20 01:00:00	US	1327
2022-10-20 01:00:00	EU	912

With the Partition by values transformation, you can issue a single query and split the results by unique values in one or more columns (fields) of your choosing. The following example uses ‘Region’:

‘SELECT Time, Region, Value FROM metrics WHERE Time > “2022-10-20”’

Time	Region	Value
2022-10-20 12:00:00	US	1520
2022-10-20 01:00:00	US	1327

Time	Region	Value
2022-10-20 12:00:00	EU	2936
2022-10-20 01:00:00	EU	912

This transformation simplifies the process and enhances the flexibility of visualizing multiple series within the same time series visualization.

Prepare time series

Use this transformation to address issues when a data source returns time series data in a format that isn’t compatible with the desired visualization. This transformation allows you to convert time series data between wide and long formats, providing flexibility in data frame structures.

Available options

Wide time series

Select this option to transform the time series data frame from the long format to the wide format. If your data source returns time series data in a long format and your visualization requires a wide format, this transformation simplifies the process.

A wide time series combines data into a single frame with one shared, ascending time field. Time fields do not repeat and multiple values extend in separate columns.

Example: Converting from long to wide format

Timestamp	Variable	Value
2023-01-01 00:00:00	Value1	10
2023-01-01 00:00:00	Value2	20
2023-01-01 01:00:00	Value1	15
2023-01-01 01:00:00	Value2	25

Transformed to:

Timestamp	Value1	Value2
2023-01-01 00:00:00	10	20
2023-01-01 01:00:00	15	25

Multi-frame time series

Multi-frame time series break data into multiple frames that all contain two fields: a time field and a numeric value field. Time is always ascending. String values are represented as field labels.

Long time series

A long time series combines data into one frame, with the first field being an ascending time field. The time field might have duplicates. String values are in separate fields, and there might be more than one.

Example: Converting to long format

Value1	Value2	Timestamp
10	20	2023-01-03 00:00:00
30	40	2023-01-02 00:00:00
50	60	2023-01-01 00:00:00
70	80	2023-01-01 00:00:00

Transformed to:

Timestamp	Value1	Value2
2023-01-01 00:00:00	70	80
2023-01-01 01:00:00	50	60
2023-01-02 01:00:00	30	40
2023-01-03 01:00:00	10	20

Reduce

Use this transformation to apply a calculation to each field in the data frame and return a single value. This transformation is particularly useful for consolidating multiple time series data into a more compact, summarized format. Time fields are removed when applying this transformation.

Consider the input:

Query A:

Time	Temp	Uptime
2020-07-07 11:34:20	12.3	256122
2020-07-07 11:24:20	15.4	1230233

Query B:

Time	AQI	Errors
2020-07-07 11:34:20	6.5	15
2020-07-07 11:24:20	3.2	5

The reduce transformer has two modes:

Series to rows - Creates a row for each field and a column for each calculation.
Reduce fields - Keeps the existing frame structure, but collapses each field into a single value.

For example, if you used the First and Last calculation with a Series to rows transformation, then the result would be:

Field	First	Last
Temp	12.3	15.4
Uptime	256122	1230233
AQI	6.5	3.2
Errors	15	5

The Reduce fields with the Last calculation, results in two frames, each with one row:

Query A:

Temp	Uptime
15.4	1230233

Query B:

AQI	Errors
3.2	5

This flexible transformation simplifies the process of consolidating and summarizing data from multiple time series into a more manageable and organized format.

Rename by regex

Use this transformation to rename parts of the query results using a regular expression and replacement pattern.

You can specify a regular expression, which is only applied to matches, along with a replacement pattern that support back references. For example, let’s imagine you’re visualizing CPU usage per host and you want to remove the domain name. You could set the regex to ‘/^([^.]+).*/’ and the replacement pattern to ‘$1’, ‘web-01.example.com’ would become ‘web-01’.

Note: The Rename by regex transformation was improved in Grafana v9.0.0 to allow global patterns of the form ‘//g’. Depending on the regex match used, this may cause some transformations to behave slightly differently. You can guarantee the same behavior as before by wrapping the match string in forward slashes ‘(/)’, e.g. ‘(.)’ would become ‘/(.)/’.

In the following example, we are stripping the ‘A-’ prefix from field names. In the before image, you can see everything is prefixed with ‘A-’:

With the transformation applied, you can see we are left with just the remainder of the string.

This transformation lets you to tailor your data to meet your visualization needs, making your dashboards more informative and user-friendly.

Rows to fields

Use this transformation to convert rows into separate fields. This can be useful because fields can be styled and configured individually. It can also use additional fields as sources for dynamic field configuration or map them to field labels. The additional labels can then be used to define better display names for the resulting fields.

This transformation includes a field table which lists all fields in the data returned by the configuration query. This table gives you control over what field should be mapped to each configuration property (the Use as option). You can also choose which value to select if there are multiple rows in the returned data.

This transformation requires:

One field to use as the source of field names.

By default, the transform uses the first string field as the source. You can override this default setting by selecting Field name in the Use as column for the field you want to use instead.
One field to use as the source of values.

By default, the transform uses the first number field as the source. But you can override this default setting by selecting Field value in the Use as column for the field you want to use instead.

Useful when visualizing data in:

Gauge
Stat
Pie chart

Map extra fields to labels

If a field does not map to config property Grafana will automatically use it as source for a label on the output field-

Example:

Name	DataCenter	Value
ServerA	US	100
ServerB	EU	200

Output:

ServerA (labels: DataCenter: US)	ServerB (labels: DataCenter: EU)
10	20

The extra labels can now be used in the field display name provide more complete field names.

If you want to extract config from one query and apply it to another you should use the config from query results transformation.

Example

Input:

Name	Value	Max
ServerA	10	100
ServerB	20	200
ServerC	30	300

Output:

ServerA (config: max=100)	ServerB (config: max=200)	ServerC (config: max=300)
10	20	30

As you can see each row in the source data becomes a separate field. Each field now also has a max config option set. Options like Min, Max, Unit and Thresholds are all part of field configuration and if set like this will be used by the visualization instead of any options manually configured in the panel editor options pane.

This transformation enables the conversion of rows into individual fields, facilitates dynamic field configuration, and maps additional fields to labels.

Series to rows

Use this transformation to combine the result from multiple time series data queries into one single result. This is helpful when using the table panel visualization.

The result from this transformation will contain three columns: Time, Metric, and Value. The Metric column is added so you easily can see from which query the metric originates from. Customize this value by defining Label on the source query.

In the example below, we have two queries returning time series data. It is visualized as two separate tables before applying the transformation.

Query A:

Time	Temperature
2020-07-07 11:34:20	25
2020-07-07 10:31:22	22
2020-07-07 09:30:05	19

Query B:

Time	Humidity
2020-07-07 11:34:20	24
2020-07-07 10:32:20	29
2020-07-07 09:30:57	33

Here is the result after applying the Series to rows transformation.

Time	Metric	Value
2020-07-07 11:34:20	Temperature	25
2020-07-07 11:34:20	Humidity	22
2020-07-07 10:32:20	Humidity	29
2020-07-07 10:31:22	Temperature	22
2020-07-07 09:30:57	Humidity	33
2020-07-07 09:30:05	Temperature	19

This transformation facilitates the consolidation of results from multiple time series queries, providing a streamlined and unified dataset for efficient analysis and visualization in a tabular format.

Sort by

Use this transformation to sort each frame within a query result based on a specified field, making your data easier to understand and analyze. By configuring the desired field for sorting, you can control the order in which the data is presented in the table or visualization.

Use the Reverse switch to inversely order the values within the specified field. This functionality is particularly useful when you want to quickly toggle between ascending and descending order to suit your analytical needs.

For example, in a scenario where time-series data is retrieved from a data source, the Sort by transformation can be applied to arrange the data frames based on the timestamp, either in ascending or descending order, depending on the analytical requirements. This capability ensures that you can easily navigate and interpret time-series data, gaining valuable insights from the organized and visually coherent presentation.

Spatial

Use this transformation to apply spatial operations to query results.

Action - Select an action:
- Prepare spatial field - Set a geometry field based on the results of other fields.
  - Location mode - Select a location mode (these options are shared by the Calculate value and Transform modes):
    - Auto - Automatically identify location data based on default field names.
    - Coords - Specify latitude and longitude fields.
    - Geohash - Specify a geohash field.
    - Lookup - Specify Gazetteer location fields.
- Calculate value - Use the geometry to define a new field (heading/distance/area).
  - Function - Choose a mathematical operation to apply to the geometry:
    - Heading - Calculate the heading (direction) between two points.
    - Area - Calculate the area enclosed by a polygon defined by the geometry.
    - Distance - Calculate the distance between two points.
- Transform - Apply spatial operations to the geometry.
  - Operation - Choose an operation to apply to the geometry:
    - As line - Create a single line feature with a vertex at each row.
    - Line builder - Create a line between two points.

This transformation allows you to manipulate and analyze geospatial data, enabling operations such as creating lines between points, calculating spatial properties, and more.

Time series to table transform

Use this transformation to convert time series results into a table, transforming a time series data frame into a Trend field which can then be used with the sparkline cell type. If there are multiple time series queries, each will result in a separate table data frame. These can be joined using join or merge transforms to produce a single table with multiple sparklines per row.

For each generated Trend field value, a calculation function can be selected. This value is displayed next to the sparkline and will be used for sorting table rows.

Note: This transformation is available in Grafana 9.5+ as an opt-in beta feature. Modify the Grafana configuration file to use it.

Transpose

Use this transformation to pivot the data frame, converting rows into columns and columns into rows. This transformation is particularly useful when you want to switch the orientation of your data to better suit your visualization needs. If you have multiple types, it will default to string type. You can select how empty cells should be represented.

Before Transformation:

env	January	February
prod	1	2
dev	3	4

After applying transpose transformation:

Field	prod	dev
January	1	3
February	2	4

Trendline

Use this transformation to create a new data frame containing values predicted by a statistical model. This is useful for finding a trend in chaotic data. It works by fitting a mathematical function to the data, using either linear or polynomial regression. The data frame can then be used in a visualization to display a trendline.

There are two different models:

Linear - Fits a linear function to the data.
Polynomial - Fits a polynomial function to the data.

Note: This transformation was previously called regression analysis.

Smoothing

Use this transformation to reduce noise in time series data through adaptive smoothing. This transformation creates smoother, cleaner visualizations while preserving all original time points and important trends and patterns in your data.

The smoothing transformation uses the ASAP (Automatic Smoothing for Attention Prioritization) algorithm internally to generate a smoothed curve, which is then interpolated back onto all original time points. This ensures your visualization maintains continuous lines without gaps while reducing noise.

Available options

Resolution - Controls smoothing intensity (1-1000). Lower values create more aggressive smoothing, while higher values preserve more detail. The output preserves all original time points.

When to use smoothing

This transformation is useful for:

Noisy time series data that obscures underlying trends
Clearer trend analysis and pattern recognition

Example

Consider noisy sensor data with thousands of points:

Before smoothing:

Time	Temperature
2020-07-07 10:00:00	23.1
2020-07-07 10:00:01	23.3
2020-07-07 10:00:02	22.9
2020-07-07 10:00:03	23.2
… (thousands more)	…

After smoothing (Resolution: 100):

Time	Temperature (smoothed)
2020-07-07 10:00:00	23.1
2020-07-07 10:00:01	23.1
2020-07-07 10:00:02	23.0
2020-07-07 10:00:03	23.0
… (same count)	…

The transformation preserves all original time points while reducing noise, resulting in smoother curves that maintain continuous lines without gaps.

Troubleshoot queries

Fri, 03 Apr 2026 12:35:46 -0500

Troubleshoot queries

This page provides information to solve common dashboard problems.

I get different results when I rearrange my functions

Function order is very important. Just like in math, the order that you place your functions can affect the result.

Inspect your query request and response

The most common problems are related to the query and response from your data source. Even if it looks like a bug or visualization issue in Grafana, it is almost always a problem with the data source query or the data source response. Start by inspecting your panel query and response.

For more information, refer to Inspect request and response data.

My query is slow

How many data points is your query returning? A query that returns lots of data points will be slow. Try this:

In Query options, limit the Max data points returned.
In Query options, increase the Min interval time.
In your query, use a group by function.

Calculation types

Fri, 03 Apr 2026 12:35:46 -0500

Calculation types

The following table contains a list of calculations you can perform in Grafana. You can find these calculations in the Transform tab and in the bar gauge, gauge, stat, and table visualizations.

Calculation	Description
1st % - 99th %	1st - 99th percentile value.
All nulls	True when all values are null
All unique values	Array with all unique values
All values	Array with all values
All zeros	True when all values are 0
Change count	Number of times the field’s value changes
Count	Number of values in a field
Delta	Cumulative change in value, only counts increments
Difference	Difference between first and last value of a field
Difference percent	Percentage change between first and last value of a field
Distinct count	Number of unique values in a field
First	First value in a field
First* (not null)	First, not null value in a field (also excludes NaNs)
Last	Last value in a field
Last* (not null)	Last, not null value in a field (also excludes NaNs)
Max	Maximum value of a field
Median	Median value of all values in a field
Mean	Mean value of all values in a field
Min	Minimum value of a field
Min (above zero)	Minimum, positive value of a field
Range	Difference between maximum and minimum values of a field
StdDev	Standard deviation of all values in a field
Step	Minimal interval between values of a field
Total	Sum of all values in a field
Variance	Variance of all values in a field