SQL Reference

In this part, we will introduce you IoTDB’s Query Language. IoTDB offers you a SQL-like query language for interacting with IoTDB, the query language can be devided into 4 major parts:

  • Schema Statement: statements about schema management are all listed in this section.
  • Data Management Statement: statements about data management (such as: data insertion, data query, etc.) are all listed in this section.
  • Database Management Statement: statements about database management and authentication are all listed in this section.
  • Functions: functions that IoTDB offers are all listed in this section.

All of these statements are write in IoTDB’s own syntax, for details about the syntax composition, please check the Reference section.

Show Version

  1. show version
  1. +---------------------------------------------------------------------------+
  2. | 0.9.3|
  3. +---------------------------------------------------------------------------+
  4. It costs 0.001s

Schema Statement

  • Set Storage Group
  1. SET STORAGE GROUP TO <PrefixPath>
  2. Eg: IoTDB > SET STORAGE GROUP TO root.ln.wf01.wt01
  3. Note: PrefixPath can not include `*`
  • Delete Storage Group
  1. DELETE STORAGE GROUP <PrefixPath> [COMMA <PrefixPath>]*
  2. Eg: IoTDB > DELETE STORAGE GROUP root.ln.wf01.wt01
  3. Eg: IoTDB > DELETE STORAGE GROUP root.ln.wf01.wt01, root.ln.wf01.wt02
  4. Note: PrefixPath can not include `*`
  • Create Timeseries Statement
  1. CREATE TIMESERIES <Timeseries> WITH <AttributeClauses>
  2. AttributeClauses : DATATYPE=<DataTypeValue> COMMA ENCODING=<EncodingValue> [COMMA <ExtraAttributeClause>]*
  3. DataTypeValue: BOOLEAN | DOUBLE | FLOAT | INT32 | INT64 | TEXT
  4. EncodingValue: GORILLA | PLAIN | RLE | TS_2DIFF | REGULAR
  5. ExtraAttributeClause: {
  6. COMPRESSOR = <CompressorValue>
  7. MAX_POINT_NUMBER = Integer
  8. }
  9. CompressorValue: UNCOMPRESSED | SNAPPY
  10. Eg: IoTDB > CREATE TIMESERIES root.ln.wf01.wt01.status WITH DATATYPE=BOOLEAN, ENCODING=PLAIN
  11. Eg: IoTDB > CREATE TIMESERIES root.ln.wf01.wt01.temperature WITH DATATYPE=FLOAT, ENCODING=RLE
  12. Eg: IoTDB > CREATE TIMESERIES root.ln.wf01.wt01.temperature WITH DATATYPE=FLOAT, ENCODING=RLE, COMPRESSOR=SNAPPY, MAX_POINT_NUMBER=3
  13. Note: Datatype and encoding type must be corresponding. Please check Chapter 3 Encoding Section for details.
  • Delete Timeseries Statement
  1. DELETE TIMESERIES <PrefixPath> [COMMA <PrefixPath>]*
  2. Eg: IoTDB > DELETE TIMESERIES root.ln.wf01.wt01.status
  3. Eg: IoTDB > DELETE TIMESERIES root.ln.wf01.wt01.status, root.ln.wf01.wt01.temperature
  4. Eg: IoTDB > DELETE TIMESERIES root.ln.wf01.wt01.*
  • Show All Timeseries Statement
  1. SHOW TIMESERIES
  2. Eg: IoTDB > SHOW TIMESERIES
  3. Note: This statement can only be used in IoTDB Client. If you need to show all timeseries in JDBC, please use `DataBaseMetadata` interface.
  • Show Specific Timeseries Statement
  1. SHOW TIMESERIES <Path>
  2. Eg: IoTDB > SHOW TIMESERIES root
  3. Eg: IoTDB > SHOW TIMESERIES root.ln
  4. Eg: IoTDB > SHOW TIMESERIES root.ln.*.*.status
  5. Eg: IoTDB > SHOW TIMESERIES root.ln.wf01.wt01.status
  6. Note: The path can be prefix path, star path or timeseries path
  7. Note: This statement can be used in IoTDB Client and JDBC.
  • Show Storage Group Statement
  1. SHOW STORAGE GROUP
  2. Eg: IoTDB > SHOW STORAGE GROUP
  3. Note: This statement can be used in IoTDB Client and JDBC.
  • Count Timeseries Statement
  1. COUNT TIMESERIES <Path>
  2. Eg: IoTDB > COUNT TIMESERIES root
  3. Eg: IoTDB > COUNT TIMESERIES root.ln
  4. Eg: IoTDB > COUNT TIMESERIES root.ln.*.*.status
  5. Eg: IoTDB > COUNT TIMESERIES root.ln.wf01.wt01.status
  6. Note: The path can be prefix path, star path or timeseries path.
  7. Note: This statement can be used in IoTDB Client and JDBC.
  1. COUNT TIMESERIES <Path> GROUP BY LEVEL=<INTEGER>
  2. Eg: IoTDB > COUNT TIMESERIES root GROUP BY LEVEL=1
  3. Eg: IoTDB > COUNT TIMESERIES root.ln GROUP BY LEVEL=2
  4. Eg: IoTDB > COUNT TIMESERIES root.ln.wf01 GROUP BY LEVEL=3
  5. Note: The path can be prefix path or timeseries path.
  6. Note: This statement can be used in IoTDB Client and JDBC.
  • Count Nodes Statement
  1. COUNT NODES <Path> LEVEL=<INTEGER>
  2. Eg: IoTDB > COUNT NODES root LEVEL=2
  3. Eg: IoTDB > COUNT NODES root.ln LEVEL=2
  4. Eg: IoTDB > COUNT NODES root.ln.wf01 LEVEL=3
  5. Note: The path can be prefix path or timeseries path.
  6. Note: This statement can be used in IoTDB Client and JDBC.
  • Show All Devices Statement
  1. SHOW Devices
  2. Eg: IoTDB > SHOW Devices
  3. Note: This statement can be used in IoTDB Client and JDBC.
  • Show Specific Devices Statement
  1. SHOW DEVICES <PrefixPath>
  2. Eg: IoTDB > SHOW DEVICES root
  3. Eg: IoTDB > SHOW DEVICES root.ln
  4. Eg: IoTDB > SHOW DEVICES root.*.wf01
  5. Note: The path can be prefix path or star path.
  6. Note: This statement can be used in IoTDB Client and JDBC.
  • Show Child Paths of Root Statement
  1. SHOW CHILD PATHS
  2. Eg: IoTDB > SHOW CHILD PATHS
  3. Note: This statement can be used in IoTDB Client and JDBC.
  • Show Child Paths Statement
  1. SHOW CHILD PATHS <Path>
  2. Eg: IoTDB > SHOW CHILD PATHS root
  3. Eg: IoTDB > SHOW CHILD PATHS root.ln
  4. Eg: IoTDB > SHOW CHILD PATHS root.ln.wf01
  5. Note: The path can only be prefix path.
  6. Note: This statement can be used in IoTDB Client and JDBC.

Data Management Statement

  • Insert Record Statement
  1. INSERT INTO <PrefixPath> LPAREN TIMESTAMP COMMA <Sensor> [COMMA <Sensor>]* RPAREN VALUES LPAREN <TimeValue>, <PointValue> [COMMA <PointValue>]* RPAREN
  2. Sensor : Identifier
  3. Eg: IoTDB > INSERT INTO root.ln.wf01.wt01(timestamp,status) values(1509465600000,true)
  4. Eg: IoTDB > INSERT INTO root.ln.wf01.wt01(timestamp,status) VALUES(NOW(), false)
  5. Eg: IoTDB > INSERT INTO root.ln.wf01.wt01(timestamp,temperature) VALUES(2017-11-01T00:17:00.000+08:00,24.22028)
  6. Eg: IoTDB > INSERT INTO root.ln.wf01.wt01(timestamp, status, temperature) VALUES (1509466680000, false, 20.060787);
  7. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  8. Note: The order of Sensor and PointValue need one-to-one correspondence
  • Update Record Statement
  1. UPDATE <UpdateClause> SET <SetClause> WHERE <WhereClause>
  2. UpdateClause: <prefixPath>
  3. SetClause: <SetExpression>
  4. SetExpression: <Path> EQUAL <PointValue>
  5. WhereClause : <Condition> [(AND | OR) <Condition>]*
  6. Condition : <Expression> [(AND | OR) <Expression>]*
  7. Expression : [NOT | !]? TIME PrecedenceEqualOperator <TimeValue>
  8. Eg: IoTDB > UPDATE root.ln.wf01.wt01 SET temperature = 23 WHERE time < NOW() and time > 2017-11-1T00:15:00+08:00
  9. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • Delete Record Statement
  1. DELETE FROM <PrefixPath> [COMMA <PrefixPath>]* WHERE TIME LESSTHAN <TimeValue>
  2. Eg: DELETE FROM root.ln.wf01.wt01.temperature WHERE time < 2017-11-1T00:05:00+08:00
  3. Eg: DELETE FROM root.ln.wf01.wt01.status, root.ln.wf01.wt01.temperature WHERE time < NOW()
  4. Eg: DELETE FROM root.ln.wf01.wt01.* WHERE time < 1509466140000
  • Select Record Statement
  1. SELECT <SelectClause> FROM <FromClause> [WHERE <WhereClause>]?
  2. SelectClause : <SelectPath> (COMMA <SelectPath>)*
  3. SelectPath : <FUNCTION> LPAREN <Path> RPAREN | <Path>
  4. FUNCTION : COUNT , MIN_TIME’, MAX_TIME’, MIN_VALUE’, MAX_VALUE
  5. FromClause : <PrefixPath> (COMMA <PrefixPath>)?
  6. WhereClause : <Condition> [(AND | OR) <Condition>]*
  7. Condition : <Expression> [(AND | OR) <Expression>]*
  8. Expression : [NOT | !]? <TimeExpr> | [NOT | !]? <SensorExpr>
  9. TimeExpr : TIME PrecedenceEqualOperator (<TimeValue> | <RelativeTime>)
  10. RelativeTimeDurationUnit = Integer ('Y'|'MO'|'W'|'D'|'H'|'M'|'S'|'MS'|'US'|'NS')
  11. RelativeTime : (now() | <TimeValue>) [(+|-) RelativeTimeDurationUnit]+
  12. SensorExpr : (<Timeseries> | <Path>) PrecedenceEqualOperator <PointValue>
  13. Eg: IoTDB > SELECT status, temperature FROM root.ln.wf01.wt01 WHERE temperature < 24 and time > 2017-11-1 0:13:00
  14. Eg. IoTDB > SELECT * FROM root
  15. Eg. IoTDB > SELECT * FROM root where time > now() - 5m
  16. Eg. IoTDB > SELECT COUNT(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 25
  17. Eg. IoTDB > SELECT MIN_TIME(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 25
  18. Eg. IoTDB > SELECT MAX_TIME(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature > 24
  19. Eg. IoTDB > SELECT MIN_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature > 23
  20. Eg. IoTDB > SELECT MAX_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 25
  21. Note: the statement needs to satisfy this constraint: <Path>(SelectClause) + <PrefixPath>(FromClause) = <Timeseries>
  22. Note: If the <SensorExpr>(WhereClause) is started with <Path> and not with ROOT, the statement needs to satisfy this constraint: <PrefixPath>(FromClause) + <Path>(SensorExpr) = <Timeseries>
  23. Note: In Version 0.7.0, if <WhereClause> includes `OR`, time filter can not be used.
  24. Note: There must be a space on both sides of the plus and minus operator appearing in the time expression
  • Group By Statement
  1. SELECT <SelectClause> FROM <FromClause> WHERE <WhereClause> GROUP BY <GroupByClause>
  2. SelectClause : <Function> [COMMA < Function >]*
  3. Function : <AggregationFunction> LPAREN <Path> RPAREN
  4. FromClause : <PrefixPath>
  5. WhereClause : <Condition> [(AND | OR) <Condition>]*
  6. Condition : <Expression> [(AND | OR) <Expression>]*
  7. Expression : [NOT | !]? <TimeExpr> | [NOT | !]? <SensorExpr>
  8. TimeExpr : TIME PrecedenceEqualOperator (<TimeValue> | <RelativeTime>)
  9. RelativeTimeDurationUnit = Integer ('Y'|'MO'|'W'|'D'|'H'|'M'|'S'|'MS'|'US'|'NS')
  10. RelativeTime : (now() | <TimeValue>) [(+|-) RelativeTimeDurationUnit]+
  11. SensorExpr : (<Timeseries> | <Path>) PrecedenceEqualOperator <PointValue>
  12. GroupByClause : LPAREN <TimeUnit> (COMMA TimeValue)? COMMA <TimeInterval> (COMMA <TimeInterval>)* RPAREN
  13. TimeUnit : Integer <DurationUnit>
  14. DurationUnit : "ms" | "s" | "m" | "h" | "d" | "w"
  15. TimeInterval: LBRACKET <TimeValue> COMMA <TimeValue> RBRACKET
  16. Eg: SELECT COUNT(status), COUNT(temperature) FROM root.ln.wf01.wt01 where temperature < 24 GROUP BY(5m, [1509465720000, 1509466380000])
  17. Eg. SELECT COUNT (status), MAX_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE time < 1509466500000 GROUP BY(5m, 1509465660000, [1509465720000, 1509466380000])
  18. Eg. SELECT MIN_TIME(status), MIN_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE temperature < 25 and time < 1509466800000 GROUP BY (3m, 1509465600000, [1509466140000, 1509466380000], [1509466440000, 1509466620000])
  19. Note: the statement needs to satisfy this constraint: <Path>(SelectClause) + <PrefixPath>(FromClause) = <Timeseries>
  20. Note: If the <SensorExpr>(WhereClause) is started with <Path> and not with ROOT, the statement needs to satisfy this constraint: <PrefixPath>(FromClause) + <Path>(SensorExpr) = <Timeseries>
  21. Note: <TimeValue>(TimeInterval) needs to be greater than 0
  22. Note: First <TimeValue>(TimeInterval) in needs to be smaller than second <TimeValue>(TimeInterval)
  • Fill Statement
  1. SELECT <SelectClause> FROM <FromClause> WHERE <WhereClause> FILL <FillClause>
  2. SelectClause : <Path> [COMMA <Path>]*
  3. FromClause : < PrefixPath > [COMMA < PrefixPath >]*
  4. WhereClause : <WhereExpression>
  5. WhereExpression : TIME EQUAL <TimeValue>
  6. FillClause : LPAREN <TypeClause> [COMMA <TypeClause>]* RPAREN
  7. TypeClause : <Int32Clause> | <Int64Clause> | <FloatClause> | <DoubleClause> | <BoolClause> | <TextClause>
  8. Int32Clause: INT32 LBRACKET (<LinearClause> | <PreviousClause>) RBRACKET
  9. Int64Clause: INT64 LBRACKET (<LinearClause> | <PreviousClause>) RBRACKET
  10. FloatClause: FLOAT LBRACKET (<LinearClause> | <PreviousClause>) RBRACKET
  11. DoubleClause: DOUBLE LBRACKET (<LinearClause> | <PreviousClause>) RBRACKET
  12. BoolClause: BOOLEAN LBRACKET (<LinearClause> | <PreviousClause>) RBRACKET
  13. TextClause: TEXT LBRACKET (<LinearClause> | <PreviousClause>) RBRACKET
  14. PreviousClause : PREVIOUS [COMMA <ValidPreviousTime>]?
  15. LinearClause : LINEAR [COMMA <ValidPreviousTime> COMMA <ValidBehindTime>]?
  16. ValidPreviousTime, ValidBehindTime: <TimeUnit>
  17. TimeUnit : Integer <DurationUnit>
  18. DurationUnit : "ms" | "s" | "m" | "h" | "d" | "w"
  19. Eg: SELECT temperature FROM root.ln.wf01.wt01 WHERE time = 2017-11-01T16:37:50.000 FILL(float[previous, 1m])
  20. Eg: SELECT temperature,status FROM root.ln.wf01.wt01 WHERE time = 2017-11-01T16:37:50.000 FILL (float[linear, 1m, 1m], boolean[previous, 1m])
  21. Eg: SELECT temperature,status,hardware FROM root.ln.wf01.wt01 WHERE time = 2017-11-01T16:37:50.000 FILL (float[linear, 1m, 1m], boolean[previous, 1m], text[previous])
  22. Eg: SELECT temperature,status,hardware FROM root.ln.wf01.wt01 WHERE time = 2017-11-01T16:37:50.000 FILL (float[linear], boolean[previous, 1m], text[previous])
  23. Note: the statement needs to satisfy this constraint: <PrefixPath>(FromClause) + <Path>(SelectClause) = <Timeseries>
  24. Note: Integer in <TimeUnit> needs to be greater than 0
  • Limit Statement
  1. SELECT <SelectClause> FROM <FromClause> [WHERE <WhereClause>] [LIMIT <LIMITClause>] [SLIMIT <SLIMITClause>]
  2. SelectClause : [<Path> | Function]+
  3. Function : <AggregationFunction> LPAREN <Path> RPAREN
  4. FromClause : <Path>
  5. WhereClause : <Condition> [(AND | OR) <Condition>]*
  6. Condition : <Expression> [(AND | OR) <Expression>]*
  7. Expression: [NOT|!]?<TimeExpr> | [NOT|!]?<SensorExpr>
  8. TimeExpr : TIME PrecedenceEqualOperator (<TimeValue> | <RelativeTime>)
  9. RelativeTimeDurationUnit = Integer ('Y'|'MO'|'W'|'D'|'H'|'M'|'S'|'MS'|'US'|'NS')
  10. RelativeTime : (now() | <TimeValue>) [(+|-) RelativeTimeDurationUnit]+
  11. SensorExpr : (<Timeseries>|<Path>) PrecedenceEqualOperator <PointValue>
  12. LIMITClause : <N> [OFFSETClause]?
  13. N : PositiveInteger
  14. OFFSETClause : OFFSET <OFFSETValue>
  15. OFFSETValue : NonNegativeInteger
  16. SLIMITClause : <SN> [SOFFSETClause]?
  17. SN : PositiveInteger
  18. SOFFSETClause : SOFFSET <SOFFSETValue>
  19. SOFFSETValue : NonNegativeInteger
  20. NonNegativeInteger:= ('+')? Digit+
  21. Eg: IoTDB > SELECT status, temperature FROM root.ln.wf01.wt01 WHERE temperature < 24 and time > 2017-11-1 0:13:00 LIMIT 3 OFFSET 2
  22. Eg. IoTDB > SELECT COUNT (status), MAX_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE time < 1509466500000 GROUP BY(5m, 1509465660000, [1509465720000, 1509466380000]) LIMIT 3
  23. Note: The order of <LIMITClause> and <SLIMITClause> does not affect the grammatical correctness.
  24. Note: <FillClause> can not use <LIMITClause> but not <SLIMITClause>.
  • Group By Device Statement
  1. GroupbyDeviceClause : GROUP BY DEVICE
  2. Rules:
  3. 1. Both uppercase and lowercase are ok.
  4. Correct example: select * from root.sg1 group by device
  5. Correct example: select * from root.sg1 GROUP BY DEVICE
  6. 2. GroupbyDeviceClause can only be used at the end of a query statement.
  7. Correct example: select * from root.sg1 where time > 10 group by device
  8. Wrong example: select * from root.sg1 group by device where time > 10
  9. 3. The paths of the SELECT clause can only be single level. In other words, the paths of the SELECT clause can only be measurements or STAR, without DOT.
  10. Correct example: select s0,s1 from root.sg1.* group by device
  11. Correct example: select s0,s1 from root.sg1.d0, root.sg1.d1 group by device
  12. Correct example: select * from root.sg1.* group by device
  13. Correct example: select * from root group by device
  14. Correct example: select s0,s1,* from root.*.* group by device
  15. Wrong example: select d0.s1, d0.s2, d1.s0 from root.sg1 group by device
  16. Wrong example: select *.s0, *.s1 from root.* group by device
  17. Wrong example: select *.*.* from root group by device
  18. 4. The data types of the same measurement column should be the same across devices.
  19. Note that when it comes to aggregated paths, the data type of the measurement column will reflect
  20. the aggregation function rather than the original timeseries.
  21. Correct example: select s0 from root.sg1.d0,root.sg1.d1 group by device
  22. root.sg1.d0.s0 and root.sg1.d1.s0 are both INT32.
  23. Correct example: select count(s0) from root.sg1.d0,root.sg1.d1 group by device
  24. count(root.sg1.d0.s0) and count(root.sg1.d1.s0) are both INT64.
  25. Wrong example: select s0 from root.sg1.d0, root.sg2.d3 group by device
  26. root.sg1.d0.s0 is INT32 while root.sg2.d3.s0 is FLOAT.
  27. 5. The display principle of the result table is that only when the column (or row) has existing data will the column (or row) be shown, with nonexistent cells being null.
  28. For example, "select s0,s1,s2 from root.sg.d0, root.sg.d1, root.sg.d2 group by device". Suppose that the actual existing timeseries are as follows:
  29. - root.sg.d0.s0
  30. - root.sg.d0.s1
  31. - root.sg.d1.s0
  32. Then the header of the result table will be: [Time, Device, s0, s1].
  33. And you could expect a table like:
  34. | Time | Device | s0 | s1 |
  35. | --- | --- | ---| ---|
  36. | 1 |root.sg.d0| 20 | 2.5|
  37. | 2 |root.sg.d0| 23 | 3.1|
  38. | ... | ... | ...| ...|
  39. | 1 |root.sg.d1| 12 |null|
  40. | 2 |root.sg.d1| 19 |null|
  41. | ... | ... | ...| ...|
  42. Note that the cells of measurement 's0' and device 'root.sg.d1' are all null.
  43. Also note that the column of 's2' and the rows of 'root.sg.d2' are not existent.
  44. 6. The duplicated devices in the prefix paths are neglected.
  45. For example, "select s0,s1 from root.sg.d0,root.sg.d0,root.sg.d1 group by device" is equal to "select s0,s1 from root.sg.d0,root.sg.d1 group by device".
  46. For example. "select s0,s1 from root.sg.*,root.sg.d0 group by device" is equal to "select s0,s1 from root.sg.* group by device".
  47. 7. The duplicated measurements in the suffix paths are not neglected.
  48. For example, "select s0,s0,s1 from root.sg.* group by device" is not equal to "select s0,s1 from root.sg.* group by device".
  49. 8. More correct examples:
  50. - select * from root.vehicle group by device
  51. - select s0,s0,s1 from root.vehicle.* group by device
  52. - select s0,s1 from root.vehicle.* limit 10 offset 1 group by device
  53. - select * from root.vehicle slimit 10 soffset 2 group by device
  54. - select * from root.vehicle where time > 10 group by device
  55. - select * from root.vehicle where root.vehicle.d0.s0>0 group by device
  56. - select count(*) from root.vehicle group by device
  57. - select sum(*) from root.vehicle GROUP BY (20ms,0,[2,50]) group by device
  58. - select * from root.vehicle where time = 3 Fill(int32[previous, 5ms]) group by device

Database Management Statement

  • Create User
  1. CREATE USER <userName> <password>;
  2. userName:=identifier
  3. password:=string
  4. Eg: IoTDB > CREATE USER thulab 'pwd';
  • Delete User
  1. DROP USER <userName>;
  2. userName:=identifier
  3. Eg: IoTDB > DROP USER xiaoming;
  • Create Role
  1. CREATE ROLE <roleName>;
  2. roleName:=identifie
  3. Eg: IoTDB > CREATE ROLE admin;
  • Delete Role
  1. DROP ROLE <roleName>;
  2. roleName:=identifier
  3. Eg: IoTDB > DROP ROLE admin;
  • Grant User Privileges
  1. GRANT USER <userName> PRIVILEGES <privileges> ON <nodeName>;
  2. userName:=identifier
  3. nodeName:=identifier (DOT identifier)*
  4. privileges:= string (COMMA string)*
  5. Eg: IoTDB > GRANT USER tempuser PRIVILEGES 'DELETE_TIMESERIES' on root.ln;
  • Grant Role Privileges
  1. GRANT ROLE <roleName> PRIVILEGES <privileges> ON <nodeName>;
  2. privileges:= string (COMMA string)*
  3. roleName:=identifier
  4. nodeName:=identifier (DOT identifier)*
  5. Eg: IoTDB > GRANT ROLE temprole PRIVILEGES 'DELETE_TIMESERIES' ON root.ln;
  • Grant User Role
  1. GRANT <roleName> TO <userName>;
  2. roleName:=identifier
  3. userName:=identifier
  4. Eg: IoTDB > GRANT temprole TO tempuser;
  • Revoke User Privileges
  1. REVOKE USER <userName> PRIVILEGES <privileges> ON <nodeName>;
  2. privileges:= string (COMMA string)*
  3. userName:=identifier
  4. nodeName:=identifier (DOT identifier)*
  5. Eg: IoTDB > REVOKE USER tempuser PRIVILEGES 'DELETE_TIMESERIES' on root.ln;
  • Revoke Role Privileges
  1. REVOKE ROLE <roleName> PRIVILEGES <privileges> ON <nodeName>;
  2. privileges:= string (COMMA string)*
  3. roleName:= identifier
  4. nodeName:=identifier (DOT identifier)*
  5. Eg: IoTDB > REVOKE ROLE temprole PRIVILEGES 'DELETE_TIMESERIES' ON root.ln;
  • Revoke Role From User
  1. REVOKE <roleName> FROM <userName>;
  2. roleName:=identifier
  3. userName:=identifier
  4. Eg: IoTDB > REVOKE temproleFROM tempuser;
  • List Users
  1. LIST USER
  2. Eg: IoTDB > LIST USER
  • List Roles
  1. LIST ROLE
  2. Eg: IoTDB > LIST ROLE
  • List Privileges
  1. LIST PRIVILEGES USER <username> ON <path>;
  2. username:=identifier
  3. path=‘root (DOT identifier)*
  4. Eg: IoTDB > LIST PRIVIEGES USER sgcc_wirte_user ON root.sgcc;
  • List Privileges of Roles(On Specific Path)
  1. LIST PRIVILEGES ROLE <roleName> ON <path>;
  2. roleName:=identifier
  3. path=‘root (DOT identifier)*
  4. Eg: IoTDB > LIST PRIVIEGES ROLE wirte_role ON root.sgcc;
  • List Privileges of Users
  1. LIST USER PRIVILEGES <username> ;
  2. username:=identifier
  3. Eg: IoTDB > LIST USER PRIVIEGES tempuser;
  • List Privileges of Roles
  1. LIST ROLE PRIVILEGES <roleName>
  2. roleName:=identifier
  3. Eg: IoTDB > LIST ROLE PRIVIEGES actor;
  • List Roles of Users
  1. LIST ALL ROLE OF USER <username> ;
  2. username:=identifier
  3. Eg: IoTDB > LIST ALL ROLE OF USER tempuser;
  • List Users of Role
  1. LIST ALL USER OF ROLE <roleName>;
  2. roleName:=identifier
  3. Eg: IoTDB > LIST ALL USER OF ROLE roleuser;
  • Alter Password
  1. ALTER USER <username> SET PASSWORD <password>;
  2. roleName:=identifier
  3. password:=identifier
  4. Eg: IoTDB > ALTER USER tempuser SET PASSWORD 'newpwd';

Functions

  • COUNT

The COUNT function returns the value number of timeseries(one or more) non-null values selected by the SELECT statement. The result is a signed 64-bit integer. If there are no matching rows, COUNT () returns 0.

  1. SELECT COUNT(Path) (COMMA COUNT(Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT COUNT(status), COUNT(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • FIRST

The FIRST function returns the first point value of the choosen timeseries(one or more).

  1. SELECT FIRST (Path) (COMMA FIRST (Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT FIRST (status), FIRST (temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • MAX_TIME

The MAX_TIME function returns the maximum timestamp of the choosen timeseries(one or more). The result is a signed 64-bit integer, greater than 0.

  1. SELECT MAX_TIME (Path) (COMMA MAX_TIME (Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT MAX_TIME(status), MAX_TIME(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • MAX_VALUE

The MAX_VALUE function returns the maximum value(lexicographically ordered) of the choosen timeseries (one or more).

  1. SELECT MAX_VALUE (Path) (COMMA MAX_VALUE (Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT MAX_VALUE(status), MAX_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • AVG(Rename from MEAN at V0.9.0)

The AVG function returns the arithmetic mean value of the choosen timeseries over a specified period of time. The timeseries must be int32, int64, float, double type, and the other types are not to be calculated. The result is a double type number.

  1. SELECT AVG (Path) (COMMA AVG (Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT AVG (temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • MIN_TIME

The MIN_TIME function returns the minimum timestamp of the choosen timeseries(one or more). The result is a signed 64-bit integer, greater than 0.

  1. SELECT MIN_TIME (Path) (COMMA MIN_TIME (Path))*FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT MIN_TIME(status), MIN_TIME(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • MIN_VALUE

The MIN_VALUE function returns the minimum value(lexicographically ordered) of the choosen timeseries (one or more).

  1. SELECT MIN_VALUE (Path) (COMMA MIN_VALUE (Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT MIN_VALUE(status),MIN_VALUE(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>
  • NOW

The NOW function returns the current timestamp. This function can be used in the data operation statement to represent time. The result is a signed 64-bit integer, greater than 0.

  1. NOW()
  2. Eg. INSERT INTO root.ln.wf01.wt01(timestamp,status) VALUES(NOW(), false)
  3. Eg. UPDATE root.ln.wf01.wt01 SET temperature = 23 WHERE time < NOW()
  4. Eg. DELETE FROM root.ln.wf01.wt01.status, root.ln.wf01.wt01.temperature WHERE time < NOW()
  5. Eg. SELECT * FROM root WHERE time < NOW()
  6. Eg. SELECT COUNT(temperature) FROM root.ln.wf01.wt01 WHERE time < NOW()
  • SUM

The SUM function returns the sum of the choosen timeseries (one or more) over a specified period of time. The timeseries must be int32, int64, float, double type, and the other types are not to be calculated. The result is a double type number.

  1. SELECT SUM(Path) (COMMA SUM(Path))* FROM <FromClause> [WHERE <WhereClause>]?
  2. Eg. SELECT SUM(temperature) FROM root.ln.wf01.wt01 WHERE root.ln.wf01.wt01.temperature < 24
  3. Note: the statement needs to satisfy this constraint: <PrefixPath> + <Path> = <Timeseries>

TTL

IoTDB supports storage-level TTL settings, which means it is able to delete old data automatically and periodically. The benefit of using TTL is that hopefully you can control the total disk space usage and prevent the machine from running out of disks. Moreover, the query performance may downgrade as the total number of files goes up and the memory usage also increase as there are more files. Timely removing such files helps to keep at a high query performance level and reduce memory usage. The TTL operations in IoTDB are supported by the following three statements:

  • Set TTL
  1. SET TTL TO StorageGroupName TTLTime
  2. Eg. SET TTL TO root.group1 3600000
  3. This example means that for data in root.group1, only that of the latest 1 hour will remain, the
  4. older one is removed or made invisible.
  5. Note: TTLTime should be millisecond timestamp. When TTL is set, insertions that fall
  6. out of TTL will be rejected.
  • Unset TTL
  1. UNSET TTL TO StorageGroupName
  2. Eg. UNSET TTL TO root.group1
  3. This example means that data of all time will be accepted in this group.
  • Show TTL
  1. SHOW ALL TTL
  2. SHOW TTL ON StorageGroupNames
  3. Eg.1 SHOW ALL TTL
  4. This example will show TTLs of all storage groups.
  5. Eg.2 SHOW TTL ON root.group1,root.group2,root.group3
  6. This example will show TTLs of the specified 3 groups.
  7. Notice: storage groups without TTL will show a "null"

Notice: When you set TTL to some storage groups, data out of the TTL will be made invisible immediately, but because the data files may contain both out-dated and living data or the data files may be being used by queries, the physical removal of data is stale. If you increase or unset TTL just after setting it previously, some previously invisible data may be seen again, but the physically removed one is lost forever. In other words, different from delete statement, the atomicity of data deletion is not guaranteed for efficiency concerns. So we recommend that you do not change the TTL once it is set or at least do not reset it frequently, unless you are determined to suffer the unpredictability.

Reference

Keywords

  1. Keywords for IoTDB (case insensitive):
  2. ADD, BY, COMPRESSOR, CREATE, DATATYPE, DELETE, DESCRIBE, DROP, ENCODING, EXIT, FROM, GRANT, GROUP, LABLE, LINK, INDEX, INSERT, INTO, LOAD, MAX_POINT_NUMBER, MERGE, METADATA, ON, ORDER, PASSWORD, PRIVILEGES, PROPERTY, QUIT, REVOKE, ROLE, ROOT, SELECT, SET, SHOW, STORAGE, TIME, TIMESERIES, TIMESTAMP, TO, UNLINK, UPDATE, USER, USING, VALUE, VALUES, WHERE, WITH
  3. Keywords with special meanings (case insensitive):
  4. * Data Types: BOOLEAN, DOUBLE, FLOAT, INT32, INT64, TEXT
  5. * Encoding Methods: BITMAP, DFT, GORILLA, PLAIN, RLE, TS_2DIFF
  6. * Compression Methods: UNCOMPRESSED, SNAPPY, GZIP, LZ0, ZDT, PAA, PLA
  7. * Logical symbol: AND, &, &&, OR, | , ||, NOT, !, TRUE, FALSE

Identifiers

  1. QUOTE := '\'';
  2. DOT := '.';
  3. COLON : ':' ;
  4. COMMA := ',' ;
  5. SEMICOLON := ';' ;
  6. LPAREN := '(' ;
  7. RPAREN := ')' ;
  8. LBRACKET := '[';
  9. RBRACKET := ']';
  10. EQUAL := '=' | '==';
  11. NOTEQUAL := '<>' | '!=';
  12. LESSTHANOREQUALTO := '<=';
  13. LESSTHAN := '<';
  14. GREATERTHANOREQUALTO := '>=';
  15. GREATERTHAN := '>';
  16. DIVIDE := '/';
  17. PLUS := '+';
  18. MINUS := '-';
  19. STAR := '*';
  20. Letter := 'a'..'z' | 'A'..'Z';
  21. HexDigit := 'a'..'f' | 'A'..'F';
  22. Digit := '0'..'9';
  23. Boolean := TRUE | FALSE | 0 | 1 (case insensitive)
  1. StringLiteral := ( '\'' ( ~('\'') )* '\'' | '\"' ( ~('\"') )* '\"');
  2. eg. 'abc'
  3. eg. 'abc'
  1. Integer := ('-' | '+')? Digit+;
  2. eg. 123
  3. eg. -222
  1. Float := ('-' | '+')? Digit+ DOT Digit+ (('e' | 'E') ('-' | '+')? Digit+)?;
  2. eg. 3.1415
  3. eg. 1.2E10
  4. eg. -1.33
  1. Identifier := (Letter | '_') (Letter | Digit | '_' | MINUS)*;
  2. eg. a123
  3. eg. _abc123

Literals

  1. PointValue : Integer | Float | StringLiteral | Boolean
  1. TimeValue : Integer | DateTime | ISO8601 | NOW()
  2. Note: Integer means timestamp type.
  3. DateTime :
  4. eg. 2016-11-16T16:22:33+08:00
  5. eg. 2016-11-16 16:22:33+08:00
  6. eg. 2016-11-16T16:22:33.000+08:00
  7. eg. 2016-11-16 16:22:33.000+08:00
  8. Note: DateTime Type can support several types, see Chapter 3 Datetime section for details.
  1. PrecedenceEqualOperator : EQUAL | NOTEQUAL | LESSTHANOREQUALTO | LESSTHAN | GREATERTHANOREQUALTO | GREATERTHAN
  1. Timeseries : ROOT [DOT <LayerName>]* DOT <SensorName>
  2. LayerName : Identifier
  3. SensorName : Identifier
  4. eg. root.ln.wf01.wt01.status
  5. eg. root.sgcc.wf03.wt01.temperature
  6. Note: Timeseries must be start with `root`(case insensitive) and end with sensor name.
  1. PrefixPath : ROOT (DOT <LayerName>)*
  2. LayerName : Identifier | STAR
  3. eg. root.sgcc
  4. eg. root.*
  1. Path: (ROOT | <LayerName>) (DOT <LayerName>)*
  2. LayerName: Identifier | STAR
  3. eg. root.ln.wf01.wt01.status
  4. eg. root.*.wf01.wt01.status
  5. eg. root.ln.wf01.wt01.*
  6. eg. *.wt01.*
  7. eg. *