Overview

This chapter describes the operators and functions supported by IoTDB. IoTDB provides a wealth of built-in operators and functions to meet your computing needs, and supports extensions through the User-Defined Function.

A list of all available functions, both built-in and custom, can be displayed with SHOW FUNCTIONS command.

See the documentation Select-Expression for the behavior of operators and functions in SQL.

OPERATORS

Arithmetic Operators

OperatorMeaning
+positive (unary operator)
-negative (unary operator)
*multiplication
/division
%modulo
+addition
-subtraction

For details and examples, see the document Arithmetic Operators and Functions.

Comparison Operators

OperatorMeaning
>greater than
>=greater than or equal to
<less than
<=less than or equal to
==equal to
!= / <>not equal to
BETWEEN … AND …within the specified range
NOT BETWEEN … AND …not within the specified range
LIKEmatch simple pattern
NOT LIKEcannot match simple pattern
REGEXPmatch regular expression
NOT REGEXPcannot match regular expression
IS NULLis null
IS NOT NULLis not null
IN / CONTAINSis a value in the specified list
NOT IN / NOT CONTAINSis not a value in the specified list

For details and examples, see the document Comparison Operators and Functions.

Logical Operators

OperatorMeaning
NOT / !logical negation (unary operator)
AND / & / &&logical AND
OR/ | / ||logical OR

For details and examples, see the document Logical Operators.

Operator Precedence

The precedence of operators is arranged as shown below from high to low, and operators on the same row have the same precedence.

  1. !, - (unary operator), + (unary operator)
  2. *, /, DIV, %, MOD
  3. -, +
  4. =, ==, <=>, >=, >, <=, <, <>, !=
  5. LIKE, REGEXP, NOT LIKE, NOT REGEXP
  6. BETWEEN ... AND ..., NOT BETWEEN ... AND ...
  7. IS NULL, IS NOT NULL
  8. IN, CONTAINS, NOT IN, NOT CONTAINS
  9. AND, &, &&
  10. OR, |, ||

BUILT-IN FUNCTIONS

The built-in functions can be used in IoTDB without registration, and the functions in the data quality function library need to be registered by referring to the registration steps in the next chapter before they can be used.

Aggregate Functions

Function NameDescriptionAllowed Input Series Data TypesRequired AttributesOutput Series Data Type
SUMSummation.INT32 INT64 FLOAT DOUBLE/DOUBLE
COUNTCounts the number of data points.All types/INT
AVGAverage.INT32 INT64 FLOAT DOUBLE/DOUBLE
EXTREMEFinds the value with the largest absolute value. Returns a positive value if the maximum absolute value of positive and negative values is equal.INT32 INT64 FLOAT DOUBLE/Consistent with the input data type
MAX_VALUEFind the maximum value.INT32 INT64 FLOAT DOUBLE/Consistent with the input data type
MIN_VALUEFind the minimum value.INT32 INT64 FLOAT DOUBLE/Consistent with the input data type
FIRST_VALUEFind the value with the smallest timestamp.All data types/Consistent with input data type
LAST_VALUEFind the value with the largest timestamp.All data types/Consistent with input data type
MAX_TIMEFind the maximum timestamp.All data Types/Timestamp
MIN_TIMEFind the minimum timestamp.All data Types/Timestamp
COUNT_IFFind the number of data points that continuously meet a given condition and the number of data points that meet the condition (represented by keep) meet the specified threshold.BOOLEAN[keep >=/>/=/!=/</<=]threshold:The specified threshold or threshold condition, it is equivalent to keep >= threshold if threshold is used alone, type of threshold is INT64 ignoreNull:Optional, default value is true;If the value is true, null values are ignored, it means that if there is a null value in the middle, the value is ignored without interrupting the continuity. If the value is true, null values are not ignored, it means that if there are null values in the middle, continuity will be brokenINT64
TIME_DURATIONFind the difference between the timestamp of the largest non-null value and the timestamp of the smallest non-null value in a columnAll data Types/INT64
MODEFind the mode. Note: 1.Having too many different values in the input series risks a memory exception; 2.If all the elements have the same number of occurrences, that is no Mode, return the value with earliest time; 3.If there are many Modes, return the Mode with earliest time.All data Types/Consistent with the input data type

For details and examples, see the document Aggregate Functions.

Arithmetic Functions

Function NameAllowed Input Series Data TypesOutput Series Data TypeRequired AttributesCorresponding Implementation in the Java Standard Library
SININT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#sin(double)
COSINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#cos(double)
TANINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#tan(double)
ASININT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#asin(double)
ACOSINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#acos(double)
ATANINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#atan(double)
SINHINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#sinh(double)
COSHINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#cosh(double)
TANHINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#tanh(double)
DEGREESINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#toDegrees(double)
RADIANSINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#toRadians(double)
ABSINT32 / INT64 / FLOAT / DOUBLESame type as the input series/Math#abs(int) / Math#abs(long) /Math#abs(float) /Math#abs(double)
SIGNINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#signum(double)
CEILINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#ceil(double)
FLOORINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#floor(double)
ROUNDINT32 / INT64 / FLOAT / DOUBLEDOUBLE‘places’ : Round the significant number, positive number is the significant number after the decimal point, negative number is the significant number of whole numberMath#rint(Math#pow(10,places))/Math#pow(10,places)
EXPINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#exp(double)
LNINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#log(double)
LOG10INT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#log10(double)
SQRTINT32 / INT64 / FLOAT / DOUBLEDOUBLE/Math#sqrt(double)

For details and examples, see the document Arithmetic Operators and Functions.

Comparison Functions

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
ON_OFFINT32 / INT64 / FLOAT / DOUBLEthreshold: a double type variateBOOLEANReturn ts_value >= threshold.
IN_RANGRINT32 / INT64 / FLOAT / DOUBLElower: DOUBLE type upper: DOUBLE typeBOOLEANReturn ts_value >= lower && value <= upper.

For details and examples, see the document Comparison Operators and Functions.

String Processing Functions

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
STRING_CONTAINSTEXTs: string to search forBOOLEANChecks whether the substring s exists in the string.
STRING_MATCHESTEXTregex: Java standard library-style regular expressions.BOOLEANJudges whether a string can be matched by the regular expression regex.
LENGTHTEXT/INT32Get the length of input series.
LOCATETEXTtarget: The substring to be located.
reverse: Indicates whether reverse locate is required. The default value is false, means left-to-right locate.
INT32Get the position of the first occurrence of substring target in input series. Returns -1 if there are no target in input.
STARTSWITHTEXTtarget: The prefix to be checked.BOOLEANCheck whether input series starts with the specified prefix target.
ENDSWITHTEXTtarget: The suffix to be checked.BOOLEANCheck whether input series ends with the specified suffix target.
CONCATTEXTtargets: a series of K-V, key needs to start with target and be not duplicated, value is the string you want to concat.
series_behind: Indicates whether series behind targets. The default value is false.
TEXTConcatenate input string and target string.
SUBSTRINGTEXTfrom: Indicates the start position of substring.
for: Indicates how many characters to stop after of substring.
TEXTExtracts a substring of a string, starting with the first specified character and stopping after the specified number of characters.The index start at 1.
REPLACETEXTfirst parameter: The target substring to be replaced.
second parameter: The substring to replace with.
TEXTReplace a substring in the input sequence with the target substring.
UPPERTEXT/TEXTGet the string of input series with all characters changed to uppercase.
LOWERTEXT/TEXTGet the string of input series with all characters changed to lowercase.
TRIMTEXT/TEXTGet the string whose value is same to input series, with all leading and trailing space removed.
STRCMPTEXT/TEXTGet the compare result of two input series. Returns 0 if series value are the same, a negative integer if value of series1 is smaller than series2,
a positive integer if value of series1 is more than series2.

For details and examples, see the document String Processing.

Data Type Conversion Function

Function NameRequired AttributesOutput Series Data TypeDescription
CASTtype: Output data type, INT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXTdetermined by typeConvert the data to the type specified by the type parameter.

For details and examples, see the document Data Type Conversion Function.

Constant Timeseries Generating Functions

Function NameRequired AttributesOutput Series Data TypeDescription
CONSTvalue: the value of the output data point type: the type of the output data point, it can only be INT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXTDetermined by the required attribute typeOutput the user-specified constant timeseries according to the attributes value and type.
PINoneDOUBLEData point value: a double value of π, the ratio of the circumference of a circle to its diameter, which is equals to Math.PI in the Java Standard Library.
ENoneDOUBLEData point value: a double value of e, the base of the natural logarithms, which is equals to Math.E in the Java Standard Library.

For details and examples, see the document Constant Timeseries Generating Functions.

Selector Functions

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
TOP_KINT32 / INT64 / FLOAT / DOUBLE / TEXTk: the maximum number of selected data points, must be greater than 0 and less than or equal to 1000Same type as the input seriesReturns k data points with the largest values in a time series.
BOTTOM_KINT32 / INT64 / FLOAT / DOUBLE / TEXTk: the maximum number of selected data points, must be greater than 0 and less than or equal to 1000Same type as the input seriesReturns k data points with the smallest values in a time series.

For details and examples, see the document Selector Functions.

Continuous Interval Functions

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
ZERO_DURATIONINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:Optional with default value 0L max:Optional with default value Long.MAX_VALUELongReturn intervals’ start times and duration times in which the value is always 0(false), and the duration time t satisfy t >= min && t <= max. The unit of t is ms
NON_ZERO_DURATIONINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:Optional with default value 0L max:Optional with default value Long.MAX_VALUELongReturn intervals’ start times and duration times in which the value is always not 0, and the duration time t satisfy t >= min && t <= max. The unit of t is ms
ZERO_COUNTINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:Optional with default value 1L max:Optional with default value Long.MAX_VALUELongReturn intervals’ start times and the number of data points in the interval in which the value is always 0(false). Data points number n satisfy n >= min && n <= max
NON_ZERO_COUNTINT32/ INT64/ FLOAT/ DOUBLE/ BOOLEANmin:Optional with default value 1L max:Optional with default value Long.MAX_VALUELongReturn intervals’ start times and the number of data points in the interval in which the value is always not 0(false). Data points number n satisfy n >= min && n <= max

For details and examples, see the document Continuous Interval Functions.

Variation Trend Calculation Functions

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
TIME_DIFFERENCEINT32 / INT64 / FLOAT / DOUBLE / BOOLEAN / TEXT/INT64Calculates the difference between the time stamp of a data point and the time stamp of the previous data point. There is no corresponding output for the first data point.
DIFFERENCEINT32 / INT64 / FLOAT / DOUBLE/Same type as the input seriesCalculates the difference between the value of a data point and the value of the previous data point. There is no corresponding output for the first data point.
NON_NEGATIVE_DIFFERENCEINT32 / INT64 / FLOAT / DOUBLE/Same type as the input seriesCalculates the absolute value of the difference between the value of a data point and the value of the previous data point. There is no corresponding output for the first data point.
DERIVATIVEINT32 / INT64 / FLOAT / DOUBLE/DOUBLECalculates the rate of change of a data point compared to the previous data point, the result is equals to DIFFERENCE / TIME_DIFFERENCE. There is no corresponding output for the first data point.
NON_NEGATIVE_DERIVATIVEINT32 / INT64 / FLOAT / DOUBLE/DOUBLECalculates the absolute value of the rate of change of a data point compared to the previous data point, the result is equals to NON_NEGATIVE_DIFFERENCE / TIME_DIFFERENCE. There is no corresponding output for the first data point.
DIFFINT32 / INT64 / FLOAT / DOUBLEignoreNull:optional,default is true. If is true, the previous data point is ignored when it is null and continues to find the first non-null value forwardly. If the value is false, previous data point is not ignored when it is null, the result is also null because null is used for subtractionDOUBLECalculates the difference between the value of a data point and the value of the previous data point. There is no corresponding output for the first data point, so output is null

For details and examples, see the document Variation Trend Calculation Functions.

Sample Functions

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
EQUAL_SIZE_BUCKET_RANDOM_SAMPLEINT32 / INT64 / FLOAT / DOUBLEproportion The value range is (0, 1], the default is 0.1INT32 / INT64 / FLOAT / DOUBLEReturns a random sample of equal buckets that matches the sampling ratio
EQUAL_SIZE_BUCKET_AGG_SAMPLEINT32 / INT64 / FLOAT / DOUBLEproportion The value range is (0, 1], the default is 0.1
type: The value types are avg, max, min, sum, extreme, variance, the default is avg
INT32 / INT64 / FLOAT / DOUBLEReturns equal bucket aggregation samples that match the sampling ratio
EQUAL_SIZE_BUCKET_M4_SAMPLEINT32 / INT64 / FLOAT / DOUBLEproportion The value range is (0, 1], the default is 0.1INT32 / INT64 / FLOAT / DOUBLEReturns equal bucket M4 samples that match the sampling ratio
EQUAL_SIZE_BUCKET_OUTLIER_SAMPLEINT32 / INT64 / FLOAT / DOUBLEThe value range of proportion is (0, 1], the default is 0.1
The value of type is avg or stendis or cos or prenextdis, the default is avg
The value of number should be greater than 0, the default is 3
INT32 / INT64 / FLOAT / DOUBLEReturns outlier samples in equal buckets that match the sampling ratio and the number of samples in the bucket
M4INT32 / INT64 / FLOAT / DOUBLEDifferent attributes used by the size window and the time window. The size window uses attributes windowSize and slidingStep. The time window uses attributes timeInterval, slidingStep, displayWindowBegin, and displayWindowEnd. More details see below.INT32 / INT64 / FLOAT / DOUBLEReturns the first, last, bottom, top points in each sliding window. M4 sorts and deduplicates the aggregated points within the window before outputting them.

For details and examples, see the document Sample Functions.

Change Points Function

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeDescription
CHANGE_POINTSINT32 / INT64 / FLOAT / DOUBLE/Same type as the input seriesRemove consecutive identical values from an input sequence.

For details and examples, see the document Time-Series.

DATA QUALITY FUNCTION LIBRARY

About

For applications based on time series data, data quality is vital. UDF Library is IoTDB User Defined Functions (UDF) about data quality, including data profiling, data quality evalution and data repairing. It effectively meets the demand for data quality in the industrial field.

Quick Start

The functions in this function library are not built-in functions, and must be loaded into the system before use.

  1. DownloadOperator and Expression - 图1open in new window the JAR with all dependencies and the script of registering UDF.
  2. Copy the JAR package to ext\udf under the directory of IoTDB system (Please put JAR to this directory of all DataNodes if you use Cluster).
  3. Run sbin\start-server.bat (for Windows) or sbin\start-server.sh (for Linux or MacOS) to start IoTDB server.
  4. Copy the script to the directory of IoTDB system (under the root directory, at the same level as sbin), modify the parameters in the script if needed and run it to register UDF.

Implemented Functions

  1. Data Quality related functions, such as Completeness. For details and examples, see the document Data-Quality.
  2. Data Profiling related functions, such as ACF. For details and examples, see the document Data-Profiling.
  3. Anomaly Detection related functions, such as IQR. For details and examples, see the document Anomaly-Detection.
  4. Frequency Domain Analysis related functions, such as Conv. For details and examples, see the document Frequency-Domain.
  5. Data Matching related functions, such as DTW. For details and examples, see the document Data-Matching.
  6. Data Repairing related functions, such as TimestampRepair. For details and examples, see the document Data-Repairing.
  7. Series Discovery related functions, such as ConsecutiveSequences. For details and examples, see the document Series-Discovery.
  8. Machine Learning related functions, such as AR. For details and examples, see the document Machine-Learning.

LAMBDA EXPRESSION

Function NameAllowed Input Series Data TypesRequired AttributesOutput Series Data TypeSeries Data Type Description
JEXLINT32 / INT64 / FLOAT / DOUBLE / TEXT / BOOLEANexpr is a lambda expression that supports standard one or multi arguments in the form x -> {…} or (x, y, z) -> {…}, e.g. x -> {x 2}, (x, y, z) -> {x + y z}INT32 / INT64 / FLOAT / DOUBLE / TEXT / BOOLEANReturns the input time series transformed by a lambda expression

For details and examples, see the document Lambda.

CONDITIONAL EXPRESSION

Expression NameDescription
CASEsimilar to “if else”

For details and examples, see the document Conditional Expressions.

SELECT EXPRESSION

The SELECT clause specifies the output of the query, consisting of several selectExpr. Each selectExpr defines one or more columns in the query result.

**selectExpr is an expression consisting of time series path suffixes, constants, functions, and operators. That is, selectExpr can contain: **

  • Time series path suffix (wildcards are supported)
  • operator
    • Arithmetic operators
    • comparison operators
    • Logical Operators
  • function
    • aggregate functions
    • Time series generation functions (including built-in functions and user-defined functions)
  • constant

Use Alias

Since the unique data model of IoTDB, lots of additional information like device will be carried before each sensor. Sometimes, we want to query just one specific device, then these prefix information show frequently will be redundant in this situation, influencing the analysis of result set. At this time, we can use AS function provided by IoTDB, assign an alias to time series selected in query.

For example:

  1. select s1 as temperature, s2 as speed from root.ln.wf01.wt01;

The result set is:

Timetemperaturespeed

Operator

See chapter 1 of this documentation for a list of operators supported in IoTDB.

Function

Aggregate Functions

Aggregate functions are many-to-one functions. They perform aggregate calculations on a set of values, resulting in a single aggregated result.

A query that contains an aggregate function is called an aggregate query, otherwise, it is called a time series query.

Please note that mixed use of Aggregate Query and Timeseries Query is not allowed. Below are examples for queries that are not allowed.

  1. select a, count(a) from root.sg
  2. select sin(a), count(a) from root.sg
  3. select a, count(a) from root.sg group by ([10,100),10ms)

For the aggregation functions supported by IoTDB, see chapter 2.1 of this documentation.

Time Series Generation Function

A time series generation function takes several raw time series as input and produces a list of time series as output. Unlike aggregate functions, time series generators have a timestamp column in their result sets.

All time series generation functions accept * as input, and all can be mixed with raw time series queries.

Built-in Time Series Generation Functions

See chapter 2 of this documentation for a list of built-in functions supported in IoTDB.

User-Defined Time Series Generation Functions

IoTDB supports function extension through User Defined Function (click for User-Defined Function) capability.

Nested Expressions

IoTDB supports the calculation of arbitrary nested expressions. Since time series query and aggregation query can not be used in a query statement at the same time, we divide nested expressions into two types, which are nested expressions with time series query and nested expressions with aggregation query.

The following is the syntax definition of the select clause:

  1. selectClause
  2. : SELECT resultColumn (',' resultColumn)*
  3. ;
  4. resultColumn
  5. : expression (AS ID)?
  6. ;
  7. expression
  8. : '(' expression ')'
  9. | '-' expression
  10. | expression ('*' | '/' | '%') expression
  11. | expression ('+' | '-') expression
  12. | functionName '(' expression (',' expression)* functionAttribute* ')'
  13. | timeSeriesSuffixPath
  14. | number
  15. ;

Nested Expressions with Time Series Query

IoTDB supports the calculation of arbitrary nested expressions consisting of numbers, time series, time series generating functions (including user-defined functions) and arithmetic expressions in the select clause.

Example

Input1:

  1. select a,
  2. b,
  3. ((a + 1) * 2 - 1) % 2 + 1.5,
  4. sin(a + sin(a + sin(b))),
  5. -(a + b) * (sin(a + b) * sin(a + b) + cos(a + b) * cos(a + b)) + 1
  6. from root.sg1;

Result1:

  1. +-----------------------------+----------+----------+----------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
  2. | Time|root.sg1.a|root.sg1.b|((((root.sg1.a + 1) * 2) - 1) % 2) + 1.5|sin(root.sg1.a + sin(root.sg1.a + sin(root.sg1.b)))|(-root.sg1.a + root.sg1.b * ((sin(root.sg1.a + root.sg1.b) * sin(root.sg1.a + root.sg1.b)) + (cos(root.sg1.a + root.sg1.b) * cos(root.sg1.a + root.sg1.b)))) + 1|
  3. +-----------------------------+----------+----------+----------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
  4. |1970-01-01T08:00:00.010+08:00| 1| 1| 2.5| 0.9238430524420609| -1.0|
  5. |1970-01-01T08:00:00.020+08:00| 2| 2| 2.5| 0.7903505371876317| -3.0|
  6. |1970-01-01T08:00:00.030+08:00| 3| 3| 2.5| 0.14065207680386618| -5.0|
  7. |1970-01-01T08:00:00.040+08:00| 4| null| 2.5| null| null|
  8. |1970-01-01T08:00:00.050+08:00| null| 5| null| null| null|
  9. |1970-01-01T08:00:00.060+08:00| 6| 6| 2.5| -0.7288037411970916| -11.0|
  10. +-----------------------------+----------+----------+----------------------------------------+---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------+
  11. Total line number = 6
  12. It costs 0.048s

Input2:

  1. select (a + b) * 2 + sin(a) from root.sg

Result2:

  1. +-----------------------------+----------------------------------------------+
  2. | Time|((root.sg.a + root.sg.b) * 2) + sin(root.sg.a)|
  3. +-----------------------------+----------------------------------------------+
  4. |1970-01-01T08:00:00.010+08:00| 59.45597888911063|
  5. |1970-01-01T08:00:00.020+08:00| 100.91294525072763|
  6. |1970-01-01T08:00:00.030+08:00| 139.01196837590714|
  7. |1970-01-01T08:00:00.040+08:00| 180.74511316047935|
  8. |1970-01-01T08:00:00.050+08:00| 219.73762514629607|
  9. |1970-01-01T08:00:00.060+08:00| 259.6951893788978|
  10. |1970-01-01T08:00:00.070+08:00| 300.7738906815579|
  11. |1970-01-01T08:00:00.090+08:00| 39.45597888911063|
  12. |1970-01-01T08:00:00.100+08:00| 39.45597888911063|
  13. +-----------------------------+----------------------------------------------+
  14. Total line number = 9
  15. It costs 0.011s

Input3:

  1. select (a + *) / 2 from root.sg1

Result3:

  1. +-----------------------------+-----------------------------+-----------------------------+
  2. | Time|(root.sg1.a + root.sg1.a) / 2|(root.sg1.a + root.sg1.b) / 2|
  3. +-----------------------------+-----------------------------+-----------------------------+
  4. |1970-01-01T08:00:00.010+08:00| 1.0| 1.0|
  5. |1970-01-01T08:00:00.020+08:00| 2.0| 2.0|
  6. |1970-01-01T08:00:00.030+08:00| 3.0| 3.0|
  7. |1970-01-01T08:00:00.040+08:00| 4.0| null|
  8. |1970-01-01T08:00:00.060+08:00| 6.0| 6.0|
  9. +-----------------------------+-----------------------------+-----------------------------+
  10. Total line number = 5
  11. It costs 0.011s

Input4:

  1. select (a + b) * 3 from root.sg, root.ln

Result4:

  1. +-----------------------------+---------------------------+---------------------------+---------------------------+---------------------------+
  2. | Time|(root.sg.a + root.sg.b) * 3|(root.sg.a + root.ln.b) * 3|(root.ln.a + root.sg.b) * 3|(root.ln.a + root.ln.b) * 3|
  3. +-----------------------------+---------------------------+---------------------------+---------------------------+---------------------------+
  4. |1970-01-01T08:00:00.010+08:00| 90.0| 270.0| 360.0| 540.0|
  5. |1970-01-01T08:00:00.020+08:00| 150.0| 330.0| 690.0| 870.0|
  6. |1970-01-01T08:00:00.030+08:00| 210.0| 450.0| 570.0| 810.0|
  7. |1970-01-01T08:00:00.040+08:00| 270.0| 240.0| 690.0| 660.0|
  8. |1970-01-01T08:00:00.050+08:00| 330.0| null| null| null|
  9. |1970-01-01T08:00:00.060+08:00| 390.0| null| null| null|
  10. |1970-01-01T08:00:00.070+08:00| 450.0| null| null| null|
  11. |1970-01-01T08:00:00.090+08:00| 60.0| null| null| null|
  12. |1970-01-01T08:00:00.100+08:00| 60.0| null| null| null|
  13. +-----------------------------+---------------------------+---------------------------+---------------------------+---------------------------+
  14. Total line number = 9
  15. It costs 0.014s
Explanation
  • Only when the left operand and the right operand under a certain timestamp are not null, the nested expressions will have an output value. Otherwise this row will not be included in the result.
    • In Result1 of the Example part, the value of time series root.sg.a at time 40 is 4, while the value of time series root.sg.b is null. So at time 40, the value of nested expressions (a + b) * 2 + sin(a) is null. So in Result2, this row is not included in the result.
  • If one operand in the nested expressions can be translated into multiple time series (For example, *), the result of each time series will be included in the result (Cartesian product). Please refer to Input3, Input4 and corresponding Result3 and Result4 in Example.
Note

Please note that Aligned Time Series has not been supported in Nested Expressions with Time Series Query yet. An error message is expected if you use it with Aligned Time Series selected in a query statement.

Nested Expressions Query with Aggregations

IoTDB supports the calculation of arbitrary nested expressions consisting of numbers, aggregations and arithmetic expressions in the select clause.

Example

Aggregation query without GROUP BY.

Input1:

  1. select avg(temperature),
  2. sin(avg(temperature)),
  3. avg(temperature) + 1,
  4. -sum(hardware),
  5. avg(temperature) + sum(hardware)
  6. from root.ln.wf01.wt01;

Result1:

  1. +----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+--------------------------------------------------------------------+
  2. |avg(root.ln.wf01.wt01.temperature)|sin(avg(root.ln.wf01.wt01.temperature))|avg(root.ln.wf01.wt01.temperature) + 1|-sum(root.ln.wf01.wt01.hardware)|avg(root.ln.wf01.wt01.temperature) + sum(root.ln.wf01.wt01.hardware)|
  3. +----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+--------------------------------------------------------------------+
  4. | 15.927999999999999| -0.21826546964855045| 16.927999999999997| -7426.0| 7441.928|
  5. +----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+--------------------------------------------------------------------+
  6. Total line number = 1
  7. It costs 0.009s

Input2:

  1. select avg(*),
  2. (avg(*) + 1) * 3 / 2 -1
  3. from root.sg1

Result2:

  1. +---------------+---------------+-------------------------------------+-------------------------------------+
  2. |avg(root.sg1.a)|avg(root.sg1.b)|(avg(root.sg1.a) + 1) * 3 / 2 - 1 |(avg(root.sg1.b) + 1) * 3 / 2 - 1 |
  3. +---------------+---------------+-------------------------------------+-------------------------------------+
  4. | 3.2| 3.4| 5.300000000000001| 5.6000000000000005|
  5. +---------------+---------------+-------------------------------------+-------------------------------------+
  6. Total line number = 1
  7. It costs 0.007s

Aggregation with GROUP BY.

Input3:

  1. select avg(temperature),
  2. sin(avg(temperature)),
  3. avg(temperature) + 1,
  4. -sum(hardware),
  5. avg(temperature) + sum(hardware) as custom_sum
  6. from root.ln.wf01.wt01
  7. GROUP BY([10, 90), 10ms);

Result3:

  1. +-----------------------------+----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+----------+
  2. | Time|avg(root.ln.wf01.wt01.temperature)|sin(avg(root.ln.wf01.wt01.temperature))|avg(root.ln.wf01.wt01.temperature) + 1|-sum(root.ln.wf01.wt01.hardware)|custom_sum|
  3. +-----------------------------+----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+----------+
  4. |1970-01-01T08:00:00.010+08:00| 13.987499999999999| 0.9888207947857667| 14.987499999999999| -3211.0| 3224.9875|
  5. |1970-01-01T08:00:00.020+08:00| 29.6| -0.9701057337071853| 30.6| -3720.0| 3749.6|
  6. |1970-01-01T08:00:00.030+08:00| null| null| null| null| null|
  7. |1970-01-01T08:00:00.040+08:00| null| null| null| null| null|
  8. |1970-01-01T08:00:00.050+08:00| null| null| null| null| null|
  9. |1970-01-01T08:00:00.060+08:00| null| null| null| null| null|
  10. |1970-01-01T08:00:00.070+08:00| null| null| null| null| null|
  11. |1970-01-01T08:00:00.080+08:00| null| null| null| null| null|
  12. +-----------------------------+----------------------------------+---------------------------------------+--------------------------------------+--------------------------------+----------+
  13. Total line number = 8
  14. It costs 0.012s
Explanation
  • Only when the left operand and the right operand under a certain timestamp are not null, the nested expressions will have an output value. Otherwise this row will not be included in the result. But for nested expressions with GROUP BY clause, it is better to show the result of all time intervals. Please refer to Input3 and corresponding Result3 in Example.
  • If one operand in the nested expressions can be translated into multiple time series (For example, *), the result of each time series will be included in the result (Cartesian product). Please refer to Input2 and corresponding Result2 in Example.