- 对于嵌套查询，仅当内层查询会输出隐式时间戳列时有效。例如select elapsed(ts) from (select diff(value) from sub1)语句，diff函数会让内层查询输出隐式时间戳列，此为主键列，可以用于elapsed函数的第一个参数。相反，例如select elapsed(ts) from (select * from sub1) 语句，ts列输出到外层时已经没有了主键列的含义，无法使用elapsed函数。此外，elapsed函数作为一个与时间线强依赖的函数，形如select elapsed(ts) from (select diff(value) from st group by tbname)尽管会返回一条计算结果，但并无实际意义，这种用法后续也将被限制。
**功能说明**：返回跳过最后 offset_val 个，然后取连续 k 个记录，不忽略 NULL 值。offset_val 可以不输入。此时返回最后的 k 个记录。当有 offset_val 输入的情况下，该函数功能等效于 `order by ts desc LIMIT k OFFSET offset_val`。
**功能说明**：返回客户端当日零时的系统时间。
**参数范围**：k: [1,100] offset_val: [0,100]。
**返回结果数据类型**：TIMESTAMP 时间戳类型。
**返回结果数据类型**：同应用的字段。
**应用字段**：在 WHERE 或 INSERT 语句中使用时只能作用于 TIMESTAMP 类型的字段。
- 对于嵌套查询，仅当内层查询会输出隐式时间戳列时有效。例如select elapsed(ts) from (select diff(value) from sub1)语句，diff函数会让内层查询输出隐式时间戳列，此为主键列，可以用于elapsed函数的第一个参数。相反，例如select elapsed(ts) from (select * from sub1) 语句，ts列输出到外层时已经没有了主键列的含义，无法使用elapsed函数。此外，elapsed函数作为一个与时间线强依赖的函数，形如select elapsed(ts) from (select diff(value) from st group by tbname)尽管会返回一条计算结果，但并无实际意义，这种用法后续也将被限制。
SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause]
SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
```
```
**功能说明**：从源字符串 str 中的指定位置 pos 开始取一个长度为 len 的子串并返回。
**功能说明**：返回跳过最后 offset_val 个，然后取连续 k 个记录，不忽略 NULL 值。offset_val 可以不输入。此时返回最后的 k 个记录。当有 offset_val 输入的情况下，该函数功能等效于 `order by ts desc LIMIT k OFFSET offset_val`。
**返回结果类型**：同输入类型。
**参数范围**：k: [1,100] offset_val: [0,100]。
**适用数据类型**：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
**Description**: instantaneous rate on a specific column. The last two samples in the specified time range are used to calculate instantaneous rate. If the last sample value is smaller, then only the last sample value is used instead of the difference between the last two sample values.
**Description**: anti-tangent of a specific column
**Return value type**: Double precision floating number
**Description**: The anti-cosine of a specific column
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: Numeric types.
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**Applicable nested query**: Inner query and Outer query
- Since version 2.1.3.0, function IRATE can be used on stble with `GROUP BY`, i.e. timelines generated by `GROUP BY tbname` on a STable.
**More explanations**:
- Can't be used with aggregate functions
### SUM
#### CEIL
```
```
SELECT SUM(field_name) FROM tb_name [WHERE clause];
SELECT CEIL(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
```
**Description**: The sum of a specific column in a table or STable
**Description**: The rounded up value of a specific column
**Return value type**: Double precision floating number or long integer
**Return value type**: Same as the column being used
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: Numeric types.
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Examples**:
**Applicable nested query**: Inner query and outer query
```
taos> SELECT SUM(current), SUM(voltage), SUM(phase) FROM meters;
**Description**: Standard deviation of a specific column in a table or STable
**Description**: The cosine of a specific column
**Return value type**: Double precision floating number
**Description**: The anti-cosine of a specific column
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: Numeric types.
**Applicable table types**: table, STable (since version 2.0.15.1)
**Applicable table types**: table, STable
**Examples**:
**Applicable nested query**: Inner query and Outer query
```
**More explanations**:
taos> SELECT STDDEV(current) FROM d1001;
- Can't be used with aggregate functions
stddev(current) |
============================
1.020892909 |
Query OK, 1 row(s) in set (0.000915s)
```
### LEASTSQUARES
#### FLOOR
```
```
SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
```
**Description**: The linear regression function of the specified column and the timestamp column (primary key), `start_val` is the initial value and `step_val` is the step value.
**Description**: The rounded down value of a specific column
**Return value type**: A string in the format of "(slope, intercept)"
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable table types**: table only
**Examples**:
```
**More explanations**: The restrictions are same as those of the `CEIL` function.
taos> SELECT LEASTSQUARES(current, 1, 1) FROM d1001;
**Description**:The value which has the highest frequency of occurrence. NULL is returned if there are multiple values which have highest frequency of occurrence. It can't be used on timestamp column or tags.
**Description**: The log of a specific with `base` as the radix
**Return value type**:Same as the data type of the column being operated upon
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Applicable column types**:Data types except for timestamp
**Applicable data types**: Numeric types.
**More explanations**:Considering the number of returned result set is unpredictable, it's suggested to limit the number of unique values to 100,000, otherwise error will be returned.
**Applicable table types**: table, STable
**Applicable version**:Since version 2.6.0.0
**Applicable nested query**: Inner query and Outer query
**Description**: The power of a specific column with `power` as the index
```
SELECT HYPERLOGLOG(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
**Description**:The cardinal number of a specific column is returned by using hyperloglog algorithm.
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Return value type**:Integer
**Applicable data types**: Numeric types.
**Applicable column types**:Any data type
**Applicable table types**: table, STable
**More explanations**: The benefit of using hyperloglog algorithm is that the memory usage is under control when the data volume is huge. However, when the data volume is very small, the result may be not accurate, it's recommented to use `select count(data) from (select unique(col) as data from table)` in this case.
**Applicable nested query**: Inner query and Outer query
**Applicable versions**:Since version 2.6.0.0
**More explanations**:
- Can't be used with aggregate functions
**Examples**:
#### ROUND
```
```
taos> select dbig from shll;
SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
dbig |
========================
1 |
1 |
1 |
NULL |
2 |
19 |
NULL |
9 |
Query OK, 8 row(s) in set (0.003755s)
taos> select hyperloglog(dbig) from shll;
hyperloglog(dbig)|
========================
4 |
Query OK, 1 row(s) in set (0.008388s)
```
```
### HISTOGRAM
**Description**: The rounded value of a specific column.
```
**More explanations**: The restrictions are same as `CEIL` function.
SELECT HISTOGRAM(field_name，bin_type, bin_description, normalized) FROM tb_name [WHERE clause];
**Description**：`elapsed` function can be used to calculate the continuous time length in which there is valid data. If it's used with `INTERVAL` clause, the returned result is the calcualted time length within each time window. If it's used without `INTERVAL` caluse, the returned result is the calculated time length within the specified time range. Please be noted that the return value of `elapsed` is the number of `time_unit` in the calculated time length.
**Description**: The tangent of a specific column
**Return value type**：Double
**Description**: The anti-cosine of a specific column
**Applicable Column type**：Timestamp
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Applicable versions**：Sicne version 2.6.0.0
**Applicable data types**: Numeric types.
**Applicable tables**: table, STable, outter in nested query
**Applicable table types**: table, STable
**Explanations**：
**Applicable nested query**: Inner query and Outer query
-`field_name` parameter can only be the first column of a table, i.e. timestamp primary key.
- The minimum value of `time_unit` is the time precision of the database. If `time_unit` is not specified, the time precision of the database is used as the default ime unit.
**More explanations**:
- It can be used with `INTERVAL` to get the time valid time length of each time window. Please be noted that the return value is same as the time window for all time windows except for the first and the last time window.
- Can't be used with aggregate functions
-`order by asc/desc` has no effect on the result.
-`group by tbname` must be used together when `elapsed` is used against a STable.
-`group by` must NOT be used together when `elapsed` is used against a table or sub table.
- When used in nested query, it's only applicable when the inner query outputs an implicit timestamp column as the primary key. For example, `select elapsed(ts) from (select diff(value) from sub1)` is legal usage while `select elapsed(ts) from (select * from sub1)` is not.
- It can't be used with `leastsquares`, `diff`, `derivative`, `top`, `bottom`, `last_row`, `interp`.
## Selection Functions
### String Functions
When any select function is used, timestamp column or tag columns including `tbname` can be specified to show that the selected value are from which rows.
String functiosn take strings as input and output numbers or strings.
### MIN
#### CHAR_LENGTH
```
```
SELECT MIN(field_name) FROM {tb_name | stb_name} [WHERE clause];
SELECT CHAR_LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
```
```
**Description**: The minimum value of a specific column in a table or STable
**Description**: The length in number of characters of a string
**Return value type**: Same as the data type of the column being operated upon
**Return value type**: Integer
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Examples**:
**Applicable nested query**: Inner query and Outer query
```
**More explanations**
taos> SELECT MIN(current), MIN(voltage) FROM meters;
min(current) | min(voltage) |
======================================
10.20000 | 218 |
Query OK, 1 row(s) in set (0.001765s)
taos> SELECT MIN(current), MIN(voltage) FROM d1001;
- If the input value is NULL, the output is NULL too
min(current) | min(voltage) |
======================================
10.30000 | 218 |
Query OK, 1 row(s) in set (0.000950s)
```
### MAX
#### CONCAT
```
```sql
SELECT MAX(field_name) FROM { tb_name | stb_name } [WHERE clause];
**Description**: The maximum value of a specific column of a table or STable
**Description**: The concatenation result of two or more strings, the number of strings to be concatenated is at least 2 and at most 8
**Return value type**: Same as the data type of the column being operated upon
**Return value type**: If all input strings are VARCHAR type, the result is VARCHAR type too. If any one of input strings is NCHAR type, then the result is NCHAR.
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: VARCHAR, NCHAR. Can't be used on tag columns. At least 2 input strings are requird, and at most 8 input strings are allowed.
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Examples**:
**Applicable nested query**: Inner query and Outer query
```
taos> SELECT MAX(current), MAX(voltage) FROM meters;
max(current) | max(voltage) |
======================================
13.40000 | 223 |
Query OK, 1 row(s) in set (0.001123s)
taos> SELECT MAX(current), MAX(voltage) FROM d1001;
max(current) | max(voltage) |
======================================
12.60000 | 221 |
Query OK, 1 row(s) in set (0.000987s)
```
### FIRST
#### CONCAT_WS
```
```
SELECT FIRST(field_name) FROM { tb_name | stb_name } [WHERE clause];
**Description**: The first non-null value of a specific column in a table or STable
**Description**: The concatenation result of two or more strings with separator, the number of strings to be concatenated is at least 3 and at most 9
**Return value type**: Same as the column being operated upon
**Return value type**: If all input strings are VARCHAR type, the result is VARCHAR type too. If any one of input strings is NCHAR type, then the result is NCHAR.
**Applicable column types**: Any data type
**Applicable data types**: VARCHAR, NCHAR. Can't be used on tag columns. At least 3 input strings are requird, and at most 9 input strings are allowed.
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**More explanations**:
**More explanations**:
- FIRST(\*) can be used to get the first non-null value of all columns
- If the value of `separator` is NULL, the output is NULL. If the value of `separator` is not NULL but other input are all NULL, the output is empty string.
- NULL will be returned if all the values of the specified column are all NULL
- A result will NOT be returned if all the columns in the result set are all NULL
**Examples**:
#### LENGTH
```
```
taos> SELECT FIRST(*) FROM meters;
SELECT LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
**Description**: The last non-NULL value of a specific column in a table or STable
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table, STable
**Return value type**: Same as the column being operated upon
**Applicable nested query**: Inner query and Outer query
**Applicable column types**: Any data type
**More explanations**
**Applicable table types**: table, STable
- If the input value is NULL, the output is NULL too
**More explanations**:
#### LOWER
- LAST(\*) can be used to get the last non-NULL value of all columns
- If the values of a column in the result set are all NULL, NULL is returned for that column; if all columns in the result are all NULL, no result will be returned.
- When it's used on a STable, if there are multiple values with the timestamp in the result set, one of them will be returned randomly and it's not guaranteed that the same value is returned if the same query is run multiple times.
**Description**: The greatest _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
**Description**: Convert the input string to lower case
**Return value type**: Same as the column being operated upon
**Return value type**: Same as input
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**Applicable nested query**: Inner query and Outer query
- _k_ must be in range [1,100]
- The timestamp associated with the selected values are returned too
- Can't be used with `FILL`
**Examples**:
```
**More explanations**
taos> SELECT TOP(current, 3) FROM meters;
ts | top(current, 3) |
=================================================
2018-10-03 14:38:15.000 | 12.60000 |
2018-10-03 14:38:16.600 | 13.40000 |
2018-10-03 14:38:16.800 | 12.30000 |
Query OK, 3 row(s) in set (0.001548s)
taos> SELECT TOP(current, 2) FROM d1001;
- If the input value is NULL, the output is NULL too
SELECT LTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
```
```
**Description**: The least _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
**Description**: Remove the left leading blanks of a string
**Return value type**: Same as the column being operated upon
**Return value type**: Same as input
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**Applicable nested query**: Inner query and Outer query
- _k_ must be in range [1,100]
- The timestamp associated with the selected values are returned too
- Can't be used with `FILL`
**Examples**:
```
**More explanations**
taos> SELECT BOTTOM(voltage, 2) FROM meters;
ts | bottom(voltage, 2) |
===============================================
2018-10-03 14:38:15.000 | 218 |
2018-10-03 14:38:16.650 | 218 |
Query OK, 2 row(s) in set (0.001332s)
taos> SELECT BOTTOM(current, 2) FROM d1001;
- If the input value is NULL, the output is NULL too
ts | bottom(current, 2) |
=================================================
2018-10-03 14:38:05.000 | 10.30000 |
2018-10-03 14:38:16.800 | 12.30000 |
Query OK, 2 row(s) in set (0.000793s)
```
### PERCENTILE
#### RTRIM
```
```
SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
SELECT RTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
```
```
**Description**: The value whose rank in a specific column matches the specified percentage. If such a value matching the specified percentage doesn't exist in the column, an interpolation value will be returned.
**Description**: Remove the right tailing blanks of a string
**Return value type**: Double precision floating point
**Return value type**: Same as input
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table
**Applicable table types**: table, STable
**More explanations**: _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
**Applicable nested query**: Inner query and Outer query
**Examples**:
**More explanations**
```
- If the input value is NULL, the output is NULL too
taos> SELECT PERCENTILE(current, 20) FROM d1001;
percentile(current, 20) |
============================
11.100000191 |
Query OK, 1 row(s) in set (0.000787s)
```
### APERCENTILE
#### SUBSTR
```
```
SELECT APERCENTILE(field_name, P[, algo_type])
SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause]
FROM { tb_name | stb_name } [WHERE clause]
```
```
**Description**: Similar to `PERCENTILE`, but a simulated result is returned
**Description**: The sub-string starting from `pos` with length of `len` from the original string `str`
**Return value type**: Double precision floating point
**Return value type**: Same as input
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**
**Applicable nested query**: Inner query and Outer query
- _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
-**algo_type** can only be input as `default` or `t-digest`, if it's not specified `default` will be used, i.e. `apercentile(column_name, 50)` is same as `apercentile(column_name, 50, "default")`.
- When `t-digest` is used, `t-digest` sampling is used to calculate. It can be used from version 2.2.0.0.
**Nested query**: It can be used in both the outer query and inner query in a nested query.
```
taos> SELECT APERCENTILE(current, 20) FROM d1001;
apercentile(current, 20) |
============================
10.300000191 |
Query OK, 1 row(s) in set (0.000645s)
taos> select apercentile (count, 80, 'default') from stb1;
**More explanations**:
apercentile (c0, 80, 'default') |
==================================
601920857.210056424 |
Query OK, 1 row(s) in set (0.012363s)
taos> select apercentile (count, 80, 't-digest') from stb1;
- If the input is NULL, the output is NULL
apercentile (c0, 80, 't-digest') |
- Parameter `pos` can be an positive or negative integer; If it's positive, the starting position will be counted from the beginning of the string; if it's negative, the starting position will be counted from the end of the string.
===================================
- If `len` is not specified, it means from `pos` to the end.
605869120.966666579 |
Query OK, 1 row(s) in set (0.011639s)
```
### LAST_ROW
#### UPPER
```
```
SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
SELECT UPPER(str|column) FROM { tb_name | stb_name } [WHERE clause]
```
```
**Description**: The last row of a table or STable
**Description**: Convert the input string to upper case
**Return value type**: Same as the column being operated upon
**Return value type**: Same as input
**Applicable column types**: Any data type
**Applicable data types**: VARCHAR or NCHAR
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**Applicable nested query**: Inner query and Outer query
- When it's used against a STable, multiple rows with the same and largest timestamp may exist, in this case one of them is returned randomly and it's not guaranteed that the result is same if the query is run multiple times.
**More explanations**
- Can't be used with `INTERVAL`.
**Examples**:
- If the input value is NULL, the output is NULL too
```
### Conversion Functions
taos> SELECT LAST_ROW(current) FROM meters;
last_row(current) |
=======================
12.30000 |
Query OK, 1 row(s) in set (0.001238s)
taos> SELECT LAST_ROW(current) FROM d1002;
This kind of functions convert from one data type to another one.
last_row(current) |
=======================
10.30000 |
Query OK, 1 row(s) in set (0.001042s)
```
### INTERP [Since version 2.3.1]
#### CAST
```
```sql
SELECT INTERP(field_name) FROM { tb_name | stb_name } [WHERE where_condition] [ RANGE(timestamp1,timestamp2) ] [EVERY(interval)] [FILL ({ VALUE | PREV | NULL | LINEAR | NEXT})];
**Description**: The value that matches the specified timestamp range is returned, if existing; or an interpolation value is returned.
**Description**: It's used for type casting. The input parameter `expression` can be data columns, constants, scalar functions or arithmetic between them.
**Return value type**: Same as the column being operated upon
**Return value type**: The type specified by parameter `type_name`
-`INTERP` is used to get the value that matches the specified time slice from a column. If no such value exists an interpolation value will be returned based on `FILL` parameter.
**Applicable data types**:
- The input data of `INTERP` is the value of the specified column and a `where` clause can be used to filter the original data. If no `where` condition is specified then all original data is the input.
- The output time range of `INTERP` is specified by `RANGE(timestamp1,timestamp2)` parameter, with timestamp1<=timestamp2. timestamp1 is the starting point of the output time range and must be specified. timestamp2 is the ending point of the output time range and must be specified. If `RANGE` is not specified, then the timestamp of the first row that matches the filter condition is treated as timestamp1, the timestamp of the last row that matches the filter condition is treated as timestamp2.
- The number of rows in the result set of `INTERP` is determined by the parameter `EVERY`. Starting from timestamp1, one interpolation is performed for every time interval specified `EVERY` parameter. If `EVERY` parameter is not used, the time windows will be considered as no ending timestamp, i.e. there is only one time window from timestamp1.
- Interpolation is performed based on `FILL` parameter. No interpolation is performed if `FILL` is not used, that means either the original data that matches is returned or nothing is returned.
-`INTERP` can only be used to interpolate in single timeline. So it must be used with `group by tbname` when it's used on a STable. It can't be used with `GROUP BY` when it's used in the inner query of a nested query.
- The result of `INTERP` is not influenced by `ORDER BY TIMESTAMP`, which impacts the output order only..
**Examples**: Based on the `meters` schema used throughout the documents
- Parameter `expression` can be any data type except for JSON
- The output data type specified by `type_name` can only be one of BIGINT/VARCHAR(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED
- Single point linear interpolation between "2017-07-14 18:40:00" and "2017-07-14 18:40:00:
**More explanations**:
```
- Error will be reported for unsupported type casting
taos> SELECT INTERP(current) FROM t1 RANGE('2017-7-14 18:40:00','2017-7-14 18:40:00') FILL(LINEAR);
- NULL will be returned if the input value is NULL
```
- Some values of some supported data types may not be casted, below are known issues:
1）When casting VARCHAR/NCHAR to BIGINT/BIGINT UNSIGNED, some characters may be treated as illegal, for example "a" may be converted to 0.
2）There may be overflow when casting singed integer or TIMESTAMP to unsigned BIGINT
3）There may be overflow when casting unsigned BIGINT to BIGINT
4）There may be overflow when casting FLOAT/DOUBLE to BIGINT or UNSIGNED BIGINT
- Get original data every 5 seconds, no interpolation, between "2017-07-14 18:00:00" and "2017-07-14 19:00:00:
#### TO_ISO8601
```
```sql
taos> SELECT INTERP(current) FROM t1 RANGE('2017-7-14 18:00:00','2017-7-14 19:00:00') EVERY(5s);
**Description**: The value of a specific column that matches the specified time slice
**Description**: Convert a JSON string to a JSON body。
**Return value type**: Same as the column being operated upon
**Return value type**: JSON
**Applicable column types**: Numeric data type
**Applicable column types**: JSON string, in the format like '{ "literal" : literal }'. '{}' is NULL value. keys in the string must be string constants, values can be constants of numeric types, bool, string or NULL. Escaping characters are not allowed in the JSON string.
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**Applicable nested query**: Inner query and Outer query.
- Time slice must be specified. If there is no data matching the specified time slice, interpolation is performed based on `FILL` parameter. Conditions such as tags or `tbname` can be used `Where` clause can be used to filter data.
#### TO_UNIXTIMESTAMP
- The timestamp specified must be within the time range of the data rows of the table or STable. If it is beyond the valid time range, nothing is returned even with `FILL` parameter.
-`INTERP` can be used to query only single time point once. `INTERP` can be used with `EVERY` to get the interpolation value every time interval.
-**Examples**:
```
```sql
taos> SELECT INTERP(*) FROM meters WHERE ts='2017-7-14 18:40:00.004';
If there is no data corresponding to the specified timestamp, an interpolation value is returned if interpolation policy is specified by `FILL` parameter; or nothing is returned.
**Description**: UNIX timestamp converted from a string of date/time format
```
**Return value type**: Long integer
taos> SELECT INTERP(*) FROM meters WHERE tbname IN ('d636') AND ts='2017-7-14 18:40:00.005';
Query OK, 0 row(s) in set (0.004022s)
taos> SELECT INTERP(*) FROM meters WHERE tbname IN ('d636') AND ts='2017-7-14 18:40:00.005' FILL(PREV);
**Applicable column types**: Constant or column of VARCHAR/NCHAR
Interpolation is performed every 5 milliseconds between `['2017-7-14 18:40:00', '2017-7-14 18:40:00.014']`
**Applicable table types**: table, STable
```
**More explanations**:
taos> SELECT INTERP(current) FROM d636 WHERE ts>='2017-7-14 18:40:00' AND ts<='2017-7-14 18:40:00.014' EVERY(5a);
ts | interp(current) |
=================================================
2017-07-14 18:40:00.000 | 10.04179 |
2017-07-14 18:40:00.010 | 10.16123 |
Query OK, 2 row(s) in set (0.003487s)
```
### TAIL
- The input string must be compatible with ISO8601/RFC3339 standard, 0 will be returned if the string can't be converted
- The precision of the returned timestamp is same as the precision set for the current data base in use
```
### DateTime Functions
SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
```
**Description**: The next _k_ rows are returned after skipping the last `offset_val` rows, NULL values are not ignored. `offset_val` is optional parameter. When it's not specified, the last _k_ rows are returned. When `offset_val` is used, the effect is same as `order by ts desc LIMIT k OFFSET offset_val`.
This kind of functiosn oeprate on timestamp data. NOW(), TODAY() and TIMEZONE() are executed only once even though they may occurr multiple times in a single SQL statement.
**Parameter value range**: k: [1,100] offset_val: [0,100]
#### NOW
**Return value type**: Same as the column being operated upon
**Description**: The values that occur the first time in the specified column. The effect is similar to `distinct` keyword, but it can also be used to match tags or timestamp.
**Description**: The difference between two timestamps, and rounded to the time unit specified by `time_unit`
**Return value type**: Same as the column or tag being operated upon
**Return value type**: Long Integer
**Applicable column types**: Any data types except for timestamp
**Applicable column types**: UNIX timestamp constant, string constant of date/time format, or a column of TIMESTAMP type
**Applicable versions**: Since version 2.6.0.0
**Applicable table types**: table, STable
**More explanations**:
**More explanations**:
- It can be used against table or STable, but can't be used together with time window, like `interval`, `state_window` or `session_window` .
- Time unit specified by `time_unit` can be:
- Considering the number of result sets is unpredictable, it's suggested to limit the distinct values under 100,000 to control the memory usage, otherwise error will be returned.
**Description**: The different of each row with its previous row for a specific column. `ignore_negative` can be specified as 0 or 1, the default value is 1 if it's not specified. `1` means negative values are ignored.
**Description**: Truncate the input timestamp with unit specified by `time_unit`
**Return value type**: Same as the column being operated upon
**Return value type**: TIMESTAMP
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable column types**: UNIX timestamp constant, string constant of date/time format, or a column of timestamp
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**More explanations**:
- The number of result rows is the number of rows subtracted by one, no output for the first row
- Time unit specified by `time_unit` can be:
- Since version 2.1.30, `DIFF` can be used on STable with `GROUP by tbname`
**Description**: The derivative of a specific column. The time rage can be specified by parameter `time_interval`, the minimum allowed time range is 1 second (1s); the value of `ignore_negative` can be 0 or 1, 1 means negative values are ignored.
**Description**: The timestamp of 00:00:00 of the client side system
**Return value type**: Double precision floating point
**Return value type**: TIMESTAMP
**Applicable column types**: Data types except for timestamp, binary, nchar and bool
**Applicable column types**: TIMESTAMP only
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**More explanations**:
- It is available from version 2.1.3.0, the number of result rows is the number of total rows in the time range subtracted by one, no output for the first row.
- Add and Subtract operation can be performed, for example NOW() + 1s, the time unit can be:
- It can be used together with `GROUP BY tbname` against a STable.
- The precision of the returned timestamp is same as the precision set for the current data base in use
**Examples**:
## Aggregate Functions
```
Aggregate functions return single result row for each group in the query result set. Groups are determined by `GROUP BY` clause or time window clause if they are used; or the whole result is considered a group if neither of them is used.
**Description**：`elapsed` function can be used to calculate the continuous time length in which there is valid data. If it's used with `INTERVAL` clause, the returned result is the calcualted time length within each time window. If it's used without `INTERVAL` caluse, the returned result is the calculated time length within the specified time range. Please be noted that the return value of `elapsed` is the number of `time_unit` in the calculated time length.
- Arithmetic operation can be performed on the result of `ceil` function
- Can't be used with aggregate functions
### FLOOR
**Return value type**：Double
```
**Applicable Column type**：Timestamp
SELECT FLOOR(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
**Description**: The rounded down value of a specific column
**Applicable tables**: table, STable, outter in nested query
**More explanations**: The restrictions are same as those of the `CEIL` function.
**Explanations**：
### ROUND
-`field_name` parameter can only be the first column of a table, i.e. timestamp primary key.
- The minimum value of `time_unit` is the time precision of the database. If `time_unit` is not specified, the time precision of the database is used as the default ime unit.
- It can be used with `INTERVAL` to get the time valid time length of each time window. Please be noted that the return value is same as the time window for all time windows except for the first and the last time window.
-`order by asc/desc` has no effect on the result.
-`group by tbname` must be used together when `elapsed` is used against a STable.
-`group by` must NOT be used together when `elapsed` is used against a table or sub table.
- When used in nested query, it's only applicable when the inner query outputs an implicit timestamp column as the primary key. For example, `select elapsed(ts) from (select diff(value) from sub1)` is legal usage while `select elapsed(ts) from (select * from sub1)` is not.
- It can't be used with `leastsquares`, `diff`, `derivative`, `top`, `bottom`, `last_row`, `interp`.
### LEASTSQUARES
```
```
SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
SELECT LEASTSQUARES(field_name, start_val, step_val) FROM tb_name [WHERE clause];
```
```
**Description**: The rounded value of a specific column.
**Description**: The linear regression function of the specified column and the timestamp column (primary key), `start_val` is the initial value and `step_val` is the step value.
**More explanations**: The restrictions are same as `CEIL` function.
### CSUM
```sql
**Return value type**: A string in the format of "(slope, intercept)"
**Description**: The cumulative sum of each row for a specific column. The number of output rows is same as that of the input rows.
**Applicable column types**: Numeric types
**Return value type**: Long integer for integers; Double for floating points. Timestamp is returned for each row.
**Applicable table types**: table only
**Applicable data types**: Data types except for timestamp, binary, nchar, and bool
### MODE
**Applicable table types**: table, STable
```
SELECT MODE(field_name) FROM tb_name [WHERE clause];
```
**Applicable nested query**: Inner query and Outer query
**Description**:The value which has the highest frequency of occurrence. NULL is returned if there are multiple values which have highest frequency of occurrence. It can't be used on timestamp column.
**More explanations**:
**Return value type**:Same as the data type of the column being operated upon
- Can't be used on tags when it's used on STable
**Applicable column types**:Data types except for timestamp
- Arithmetic operation can't be performed on the result of `csum` function
- Can only be used with aggregate functions
-`Group by tbname` must be used together on a STable to force the result on a single timeline
**Applicable versions**: Since 2.3.0.x
**More explanations**:Considering the number of returned result set is unpredictable, it's suggested to limit the number of unique values to 100,000, otherwise error will be returned.
SELECT SPREAD(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
```
**Description**: The moving average of continuous _k_ values of a specific column. If the number of input rows is less than _k_, nothing is returned. The applicable range is _k_ is [1,1000].
**Description**: The difference between the max and the min of a specific column
**Return value type**: Double precision floating point
**Return value type**: Double precision floating point
**Applicable data types**: Data types except for timestamp, binary, nchar, and bool
**Applicable column types**: Numeric types
**Applicable nested query**: Inner query and Outer query
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**More explanations**:
**More explanations**: Can be used on a column of TIMESTAMP type, the result is the time range size.
- Arithmetic operation can't be performed on the result of `MAVG`.
- Can only be used with data columns, can't be used with tags.
- Can't be used with aggregate functions.
- Must be used with `GROUP BY tbname` when it's used on a STable to force the result on each single timeline.
SELECT HYPERLOGLOG(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
```
**Description**: The anti-cosine of a specific column
**Description**:The cardinal number of a specific column is returned by using hyperloglog algorithm.
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Applicable data types**: Data types except for timestamp, binary, nchar, bool
**Return value type**:Integer
**Applicable table types**: table, STable
**Applicable column types**:Any data type
**Applicable nested query**: Inner query and Outer query
**More explanations**: The benefit of using hyperloglog algorithm is that the memory usage is under control when the data volume is huge. However, when the data volume is very small, the result may be not accurate, it's recommented to use `select count(data) from (select unique(col) as data from table)` in this case.
**Applicable versions**: From 2.6.0.0
### HISTOGRAM
**More explanations**:
```
SELECT HISTOGRAM(field_name，bin_type, bin_description, normalized) FROM tb_name [WHERE clause];
```
- Can't be used with tags
**Description**：Returns count of data points in user-specified ranges.
- Can't be used with aggregate functions
### ATAN
**Return value type**：Double or INT64, depends on normalized parameter settings.
"infinity" - whether to add（-inf, inf）as start/end point in generated range of bins.
The above "log_bin" descriptor generates a set of bins:[-inf, 1.0, 2.0, 4.0, 8.0, 16.0, +inf].
**Applicable versions**: From 2.6.0.0
3. normalized: setting to 1/0 to turn on/off result normalization.
**More explanations**:
## Selector Functions
- Can't be used with tags
Selector functiosn choose one or more rows in the query result set to retrun according toe the semantics. You can specify to output ts column and other columns including tbname and tags so that you can easily know which rows the selected values belong to.
**Description**: Similar to `PERCENTILE`, but a simulated result is returned
**Description**: The anti-cosine of a specific column
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Return value type**: Double precision floating point
**Applicable data types**: Data types except for timestamp, binary, nchar, bool
**Applicable column types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**More explanations**
**Applicable versions**: From 2.6.0.0
**More explanations**:
- _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
-**algo_type** can only be input as `default` or `t-digest`, if it's not specified `default` will be used, i.e. `apercentile(column_name, 50)` is same as `apercentile(column_name, 50, "default")`.
- When `t-digest` is used, `t-digest` sampling is used to calculate.
- Can't be used with tags
**Nested query**: It can be used in both the outer query and inner query in a nested query.
**Description**: The least _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
**Description**: The anti-cosine of a specific column
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Return value type**: Same as the column being operated upon
**Applicable data types**: Data types except for timestamp, binary, nchar, bool
**Applicable column types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**More explanations**:
**More explanations**:
- Can't be used with tags
- _k_ must be in range [1,100]
- Can't be used with aggregate functions
- The timestamp associated with the selected values are returned too
-`INTERP` is used to get the value that matches the specified time slice from a column. If no such value exists an interpolation value will be returned based on `FILL` parameter.
- Can't be used with aggregate functions
- The input data of `INTERP` is the value of the specified column and a `where` clause can be used to filter the original data. If no `where` condition is specified then all original data is the input.
- The output time range of `INTERP` is specified by `RANGE(timestamp1,timestamp2)` parameter, with timestamp1<=timestamp2. timestamp1 is the starting point of the output time range and must be specified. timestamp2 is the ending point of the output time range and must be specified. If `RANGE` is not specified, then the timestamp of the first row that matches the filter condition is treated as timestamp1, the timestamp of the last row that matches the filter condition is treated as timestamp2.
- The number of rows in the result set of `INTERP` is determined by the parameter `EVERY`. Starting from timestamp1, one interpolation is performed for every time interval specified `EVERY` parameter. If `EVERY` parameter is not used, the time windows will be considered as no ending timestamp, i.e. there is only one time window from timestamp1.
- Interpolation is performed based on `FILL` parameter. No interpolation is performed if `FILL` is not used, that means either the original data that matches is returned or nothing is returned.
-`INTERP` can only be used to interpolate in single timeline. So it must be used with `group by tbname` when it's used on a STable. It can't be used with `GROUP BY` when it's used in the inner query of a nested query.
- The result of `INTERP` is not influenced by `ORDER BY TIMESTAMP`, which impacts the output order only..
SELECT LAST(field_name) FROM { tb_name | stb_name } [WHERE clause];
```
```
**Description**: The log of a specific with `base` as the radix
**Description**: The last non-NULL value of a specific column in a table or STable
**Return value type**: Double if the input value is not NULL; or NULL if the input value is NULL
**Return value type**: Same as the column being operated upon
**Applicable data types**: Data types except for timestamp, binary, nchar, bool
**Applicable column types**: Any data type
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**More explanations**:
**More explanations**:
- Can't be used with tags
- LAST(\*) can be used to get the last non-NULL value of all columns
- Can't be used with aggregate functions
- If the values of a column in the result set are all NULL, NULL is returned for that column; if all columns in the result are all NULL, no result will be returned.
- When it's used on a STable, if there are multiple values with the timestamp in the result set, one of them will be returned randomly and it's not guaranteed that the same value is returned if the same query is run multiple times.
SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
```
```
**Description**: The absolute of a specific column
**Description**: The last row of a table or STable
**Return value type**: UBIGINT if the input value is integer; DOUBLE if the input value is FLOAT/DOUBLE
**Return value type**: Same as the column being operated upon
**Applicable data types**: Data types except for timestamp, binary, nchar, bool
**Applicable column types**: Any data type
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**More explanations**:
**More explanations**:
-Can't be used with tags
-When it's used against a STable, multiple rows with the same and largest timestamp may exist, in this case one of them is returned randomly and it's not guaranteed that the result is same if the query is run multiple times.
**Description**: It's used for type casting. The input parameter `expression` can be data columns, constants, scalar functions or arithmetic between them. Can't be used with tags, and can only be used in `select` clause.
### PERCENTILE
**Return value type**: The type specified by parameter `type_name`
```
SELECT PERCENTILE(field_name, P) FROM { tb_name } [WHERE clause];
```
**Applicable data types**:
**Description**: The value whose rank in a specific column matches the specified percentage. If such a value matching the specified percentage doesn't exist in the column, an interpolation value will be returned.
- Parameter `expression` can be any data type except for JSON, more specifically it can be any of BOOL/TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/BINARY(M)/TIMESTAMP/NCHAR(M)/TINYINT UNSIGNED/SMALLINT UNSIGNED/INT UNSIGNED/BIGINT UNSIGNED
**Return value type**: Double precision floating point
- The output data type specified by `type_name` can only be one of BIGINT/BINARY(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED
**Applicable versions**: From 2.6.0.0
**Applicable column types**: Numeric types
**More explanations**:
**Applicable table types**: table
- Error will be reported for unsupported type casting
**More explanations**: _P_ is in range [0,100], when _P_ is 0, the result is same as using function MIN; when _P_ is 100, the result is same as function MAX.
- NULL will be returned if the input value is NULL
- Some values of some supported data types may not be casted, below are known issues:
1）When casting BINARY/NCHAR to BIGINT/BIGINT UNSIGNED, some characters may be treated as illegal, for example "a" may be converted to 0.
2）There may be overflow when casting singed integer or TIMESTAMP to unsigned BIGINT
3）There may be overflow when casting unsigned BIGINT to BIGINT
4）There may be overflow when casting FLOAT/DOUBLE to BIGINT or UNSIGNED BIGINT
SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
```
```
**Description**: The concatenation result of two or more strings, the number of strings to be concatenated is at least 2 and at most 8
**Description**: The next _k_ rows are returned after skipping the last `offset_val` rows, NULL values are not ignored. `offset_val` is optional parameter. When it's not specified, the last _k_ rows are returned. When `offset_val` is used, the effect is same as `order by ts desc LIMIT k OFFSET offset_val`.
**Return value type**: Same as the columns being operated, BINARY or NCHAR; or NULL if all the input are NULL
**Applicable data types**: The input data must be in either all BINARY or in all NCHAR; can't be used on tag columns
**Applicable table types**: table, STable
**Parameter value range**: k: [1,100] offset_val: [0,100]
**Applicable nested query**: Inner query and Outer query
**Return value type**: Same as the column being operated upon
**Applicable versions**: From 2.6.0.0
**Applicable column types**: Any data type except form timestamp, i.e. the primary key
**Description**: The concatenation result of two or more strings with separator, the number of strings to be concatenated is at least 3 and at most 9
**Description**: The greatest _k_ values of a specific column in a table or STable. If a value has multiple occurrences in the column but counting all of them in will exceed the upper limit _k_, then a part of them will be returned randomly.
**Return value type**: Same as the columns being operated, BINARY or NCHAR; or NULL if all the input are NULL
**Return value type**: Same as the column being operated upon
**Applicable data types**: The input data must be in either all BINARY or in all NCHAR; can't be used on tag columns
**Applicable column types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**More explanations**:
**More explanations**:
- If the value of `separator` is NULL, the output is NULL. If the value of `separator` is not NULL but other input are all NULL, the output is empty string.
- _k_ must be in range [1,100]
- The timestamp associated with the selected values are returned too
- Can't be used with `FILL`
### LENGTH
### UNIQUE
```
```
SELECT LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
SELECT UNIQUE(field_name) FROM {tb_name | stb_name} [WHERE clause];
```
```
**Description**: The length in bytes of a string
**Description**: The values that occur the first time in the specified column. The effect is similar to `distinct` keyword, but it can also be used to match tags or timestamp.
**Return value type**: Integer
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Return value type**: Same as the column or tag being operated upon
**Applicable table types**: table, STable
**Applicable column types**: Any data types except for timestamp
**Applicable nested query**: Inner query and Outer query
**More explanations**:
**Applicable versions**: From 2.6.0.0
- It can be used against table or STable, but can't be used together with time window, like `interval`, `state_window` or `session_window` .
- Considering the number of result sets is unpredictable, it's suggested to limit the distinct values under 100,000 to control the memory usage, otherwise error will be returned.
**More explanations**
## Time-Series Specific Functions
- If the input value is NULL, the output is NULL too
TDengine provides a set of time-series specific functions to better meet the requirements in querying time-series data. In general databases, similar functionalities can only be achieved with much more complex syntax and much worse performance. TDengine provides these functionalities in builtin functions so that the burden on user side is minimized.
### CHAR_LENGTH
### CSUM
```
```sql
SELECT CHAR_LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
**Description**: The length in number of characters of a string
**Description**: The cumulative sum of each row for a specific column. The number of output rows is same as that of the input rows.
**Return value type**: Integer
**Return value type**: Long integer for integers; Double for floating points. Timestamp is returned for each row.
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Applicable data types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**More explanations**:
- Arithmetic operation can't be performed on the result of `csum` function
**More explanations**
- Can only be used with aggregate functions
-`Group by tbname` must be used together on a STable to force the result on a single timeline
- If the input value is NULL, the output is NULL too
### LOWER
### DERIVATIVE
```
```
SELECT LOWER(str|column) FROM { tb_name | stb_name } [WHERE clause]
SELECT DERIVATIVE(field_name, time_interval, ignore_negative) FROM tb_name [WHERE clause];
```
```
**Description**: Convert the input string to lower case
**Description**: The derivative of a specific column. The time rage can be specified by parameter `time_interval`, the minimum allowed time range is 1 second (1s); the value of `ignore_negative` can be 0 or 1, 1 means negative values are ignored.
**Return value type**: Same as input
**Return value type**: Double precision floating point
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Applicable column types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**More explanations**:
**Applicable versions**: From 2.6.0.0
**More explanations**
- If the input value is NULL, the output is NULL too
- The number of result rows is the number of total rows in the time range subtracted by one, no output for the first row.
- It can be used together with `GROUP BY tbname` against a STable.
### UPPER
### DIFF
```
```sql
SELECT UPPER(str|column) FROM { tb_name | stb_name } [WHERE clause]
**Description**: Convert the input string to upper case
**Description**: The different of each row with its previous row for a specific column. `ignore_negative` can be specified as 0 or 1, the default value is 1 if it's not specified. `1` means negative values are ignored.
**Return value type**: Same as input
**Return value type**: Same as the column being operated upon
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Applicable column types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**More explanations**:
**Applicable versions**: From 2.6.0.0
**More explanations**
- If the input value is NULL, the output is NULL too
- The number of result rows is the number of rows subtracted by one, no output for the first row
- It can be used on STable with `GROUP by tbname`
### LTRIM
### IRATE
```
```
SELECT LTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
SELECT IRATE(field_name) FROM tb_name WHERE clause;
```
```
**Description**: Remove the left leading blanks of a string
**Description**: instantaneous rate on a specific column. The last two samples in the specified time range are used to calculate instantaneous rate. If the last sample value is smaller, then only the last sample value is used instead of the difference between the last two sample values.
**Return value type**: Same as input
**Return value type**: Double precision floating number
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Applicable column types**: Numeric types
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**More explanations**:
**Applicable versions**: From 2.6.0.0
**More explanations**
- If the input value is NULL, the output is NULL too
- It can be used on stble with `GROUP BY`, i.e. timelines generated by `GROUP BY tbname` on a STable.
### RTRIM
### MAVG
```
```sql
SELECT RTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
**Description**: Remove the right tailing blanks of a string
**Description**: The moving average of continuous _k_ values of a specific column. If the number of input rows is less than _k_, nothing is returned. The applicable range of _k_ is [1,1000].
**Return value type**: Same as input
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Return value type**: Double precision floating point
**Applicable table types**: table, STable
**Applicable data types**: Numeric types
**Applicable nested query**: Inner query and Outer query
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**Applicable table types**: table, STable
**More explanations**
**More explanations**:
- If the input value is NULL, the output is NULL too
- Arithmetic operation can't be performed on the result of `MAVG`.
- Can't be used with aggregate functions.
- Must be used with `GROUP BY tbname` when it's used on a STable to force the result on each single timeline.
### SUBSTR
### SAMPLE
```
```sql
SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause]
**Description**: The sub-string starting from `pos` with length of `len` from the original string `str`
**Description**: _k_ sampling values of a specific column. The applicable range of _k_ is [1,10000]
**Return value type**: Same as input
**Return value type**: Same as the column being operated plus the associated timestamp
**Applicable data types**: BINARY or NCHAR, can't be used on tags
**Applicable data types**: Any data type except for tags of STable
**Applicable table types**: table, STable
**Applicable table types**: table, STable
**Applicable nested query**: Inner query and Outer query
**Applicable nested query**: Inner query and Outer query
**Applicable versions**: From 2.6.0.0
**More explanations**:
**More explanations**:
- If the input is NULL, the output is NULL
- Arithmetic operation can't be operated on the result of `SAMPLE` function
- Parameter `pos` can be an positive or negative integer; If it's positive, the starting position will be counted from the beginning of the string; if it's negative, the starting position will be counted from the end of the string.
- Must be used with `Group by tbname` when it's used on a STable to force the result on each single timeline
- If `len` is not specified, it means from `pos` to the end.
**Description**: The ISO8601 date/time format converted from a UNIX timestamp, plus the timezone of the client side system
**Description**：Return the current database being used. If the user doesn't specify database when logon and doesn't use `USE` SQL command to switch the datbase, this function returns NULL.
**Return value type**: BINARY
**Applicable column types**: TIMESTAMP, constant or a column
**Applicable table types**: table, STable
**More explanations**:
- If the input is UNIX timestamp constant, the precision of the returned value is determined by the digits of the input timestamp
- If the input is a column of TIMESTAMP type, The precision of the returned value is same as the precision set for the current data base in use
