docs: add taos sql

docs/en/01-index.md

 ---
-title: TDengine Cloud Documentation
+title: TDengine Cloud Service Documentation
 sidebar_label: Documentation Home
 slug: /
 ---

docs/en/02-intro.md

 ---
 sidebar_label: Introduction
-title: TDengine Cloud
+title: TDengine Cloud Service
 ---

docs/en/05-develop/01-connect/04-rust.md

@@ -3,6 +3,8 @@ sidebar_label: Rust
 title: Connect with Rust Connector
 pagination_next: develop/insert-data
 ---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
 
 ## Add Dependency
 
@@ -17,11 +19,33 @@ libtaos = { version = "0.4.2"}
 
 Run this command in your terminal to save TDengine cloud token as variables:
 
+<Tabs defaultValue="bash">
+<TabItem value="bash" label="Bash">
+
 ```bash
 export TDENGINE_CLOUD_TOKEN=<token>
 export TDENGINE_CLOUD_URL=<url>
 ```
 
+</TabItem>
+<TabItem value="cmd" label="CMD">
+
+```bash
+set TDENGINE_CLOUD_TOKEN="<token>"
+set TDENGINE_CLOUD_URL="<url>"
+```
+
+</TabItem>
+<TabItem value="powershell" label="Powershell">
+
+```powershell
+$env:TDENGINE_CLOUD_TOKEN="<token>"
+$env:TDENGINE_CLOUD_URL="<url>"
+```
+
+</TabItem>
+</Tabs>
+
 <!-- exclude -->
 :::note
 Replace  <token\> and <url\> with cloud token and URL.

docs/en/05-develop/01-connect/05-node.md

@@ -3,6 +3,8 @@ sidebar_label: Node.js
 title: Connect with Node.js Connector
 pagination_next: develop/insert-data
 ---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
 
 ## Install Connector
 
@@ -13,11 +15,34 @@ npm i td2.0-rest-connector
 
 Run this command in your terminal to save TDengine cloud token as variables:
 
+<Tabs defaultValue="bash">
+<TabItem value="bash" label="Bash">
+
 ```bash
 export TDENGINE_CLOUD_TOKEN=<token>
 export TDENGINE_CLOUD_URL=<url>
 ```
 
+</TabItem>
+<TabItem value="cmd" label="CMD">
+
+```bash
+set TDENGINE_CLOUD_TOKEN="<token>"
+set TDENGINE_CLOUD_URL="<url>"
+```
+
+</TabItem>
+<TabItem value="powershell" label="Powershell">
+
+```powershell
+$env:TDENGINE_CLOUD_TOKEN="<token>"
+$env:TDENGINE_CLOUD_URL="<url>"
+```
+
+</TabItem>
+</Tabs>
+
+
 <!-- exclude -->
 :::note
 Replace  <token\> and <url\> with cloud token and URL.

docs/en/05-develop/02-model.md

+---
+title: Data Model
+---
+
+The data model employed by TDengine is similar to that of a relational database. You have to create databases and tables. You must design the data model based on your own business and application requirements. You should design the STable (an abbreviation for super table) schema to fit your data. This chapter will explain the big picture without getting into syntactical details.
+
+## Create Database
+
+The [characteristics of time-series data](https://www.taosdata.com/blog/2019/07/09/86.html) from different data collection points may be different. Characteristics include collection frequency, retention policy and others which determine how you create and configure the database. For e.g. days to keep, number of replicas, data block size, whether data updates are allowed and other configurable parameters would be determined by the characteristics of your data and your business requirements. For TDengine to operate with the best performance, we strongly recommend that you create and configure different databases for data with different characteristics. This allows you, for example, to set up different storage and retention policies. When creating a database, there are a lot of parameters that can be configured such as, the days to keep data, the number of replicas, the number of memory blocks, time precision, the minimum and maximum number of rows in each data block, whether compression is enabled, the time range of the data in single data file and so on. Below is an example of the SQL statement to create a database.
+
+```sql
+CREATE DATABASE power KEEP 365 DAYS 10 BLOCKS 6 UPDATE 1;
+```
+
+In the above SQL statement:
+- a database named "power" will be created
+- the data in it will be kept for 365 days, which means that data older than 365 days will be deleted automatically
+- a new data file will be created every 10 days
+- the number of memory blocks is 6
+- data is allowed to be updated
+
+For more details please refer to [Database](/taos-sql/database).
+
+After creating a database, the current database in use can be switched using SQL command `USE`. For example the SQL statement below switches the current database to `power`. Without the current database specified, table name must be preceded with the corresponding database name.
+
+```sql
+USE power;
+```
+
+:::note
+
+- Any table or STable must belong to a database. To create a table or STable, the database it belongs to must be ready.
+- JOIN operations can't be performed on tables from two different databases.
+- Timestamp needs to be specified when inserting rows or querying historical rows.
+
+:::
+
+## Create STable
+
+In a time-series application, there may be multiple kinds of data collection points. For example, in the electrical power system there are meters, transformers, bus bars, switches, etc. For easy and efficient aggregation of multiple tables, one STable needs to be created for each kind of data collection point. For example, for the meters in [table 1](/tdinternal/arch#model_table1), the SQL statement below can be used to create the super table.
+
+```sql
+CREATE STable meters (ts timestamp, current float, voltage int, phase float) TAGS (location binary(64), groupId int);
+```
+
+:::note
+If you are using versions prior to 2.0.15, the `STable` keyword needs to be replaced with `TABLE`.
+
+:::
+
+Similar to creating a regular table, when creating a STable, the name and schema need to be provided. In the STable schema, the first column must always be a timestamp (like ts in the example), and the other columns (like current, voltage and phase in the example) are the data collected. The remaining columns can [contain data of type](/taos-sql/data-type/) integer, float, double, string etc. In addition, the schema for tags, like location and groupId in the example, must be provided. The tag type can be integer, float, string, etc. Tags are essentially the static properties of a data collection point. For example, properties like the location, device type, device group ID, manager ID are tags. Tags in the schema can be added, removed or updated. Please refer to [STable](/taos-sql/stable) for more details.
+
+For each kind of data collection point, a corresponding STable must be created. There may be many STables in an application. For electrical power system, we need to create a STable respectively for meters, transformers, busbars, switches. There may be multiple kinds of data collection points on a single device, for example there may be one data collection point for electrical data like current and voltage and another data collection point for environmental data like temperature, humidity and wind direction. Multiple STables are required for these kinds of devices.
+
+At most 4096 (or 1024 prior to version 2.1.7.0) columns are allowed in a STable. If there are more than 4096 of metrics to be collected for a data collection point, multiple STables are required. There can be multiple databases in a system, while one or more STables can exist in a database.
+
+## Create Table
+
+A specific table needs to be created for each data collection point. Similar to RDBMS, table name and schema are required to create a table. Additionally, one or more tags can be created for each table. To create a table, a STable needs to be used as template and the values need to be specified for the tags. For example, for the meters in [Table 1](/tdinternal/arch#model_table1), the table can be created using below SQL statement.
+
+```sql
+CREATE TABLE d1001 USING meters TAGS ("California.SanFrancisco", 2);
+```
+
+In the above SQL statement, "d1001" is the table name, "meters" is the STable name, followed by the value of tag "Location" and the value of tag "groupId", which are "California.SanFrancisco" and "2" respectively in the example. The tag values can be updated after the table is created. Please refer to [Tables](/taos-sql/table) for details.
+
+In the TDengine system, it's recommended to create a table for a data collection point via STable. A table created via STable is called subtable in some parts of the TDengine documentation. All SQL commands applied on regular tables can be applied on subtables.
+
+:::warning
+It's not recommended to create a table in a database while using a STable from another database as template.
+
+:::tip
+It's suggested to use the globally unique ID of a data collection point as the table name. For example the device serial number could be used as a unique ID. If a unique ID doesn't exist, multiple IDs that are not globally unique can be combined to form a globally unique ID. It's not recommended to use a globally unique ID as tag value.
+
+## Create Table Automatically
+
+In some circumstances, it's unknown whether the table already exists when inserting rows. The table can be created automatically using the SQL statement below, and nothing will happen if the table already exists.
+
+```sql
+INSERT INTO d1001 USING meters TAGS ("California.SanFrancisco", 2) VALUES (now, 10.2, 219, 0.32);
+```
+
+In the above SQL statement, a row with value `(now, 10.2, 219, 0.32)` will be inserted into table "d1001". If table "d1001" doesn't exist, it will be created automatically using STable "meters" as template with tag value `"California.SanFrancisco", 2`.
+
+For more details please refer to [Create Table Automatically](/taos-sql/insert#automatically-create-table-when-inserting).
+
+## Single Column vs Multiple Column
+
+A multiple columns data model is supported in TDengine. As long as multiple metrics are collected by the same data collection point at the same time, i.e. the timestamps are identical, these metrics can be put in a single STable as columns. 
+
+However, there is another kind of design, i.e. single column data model in which a table is created for each metric. This means that a STable is required for each kind of metric. For example in a single column model, 3 STables would be required for current, voltage and phase.
+
+It's recommended to use a multiple column data model as much as possible because insert and query performance is higher. In some cases, however, the collected metrics may vary frequently and so the corresponding STable schema needs to be changed frequently too. In such cases, it's more convenient to use single column data model.

docs/en/05-develop/03-insert-data.md

 # Insert Data
+
+## Introduction
+
+Application programs can execute `INSERT` statement through connectors to insert rows. The TAOS CLI can also be used to manually insert data.
+
+### Insert Single Row
+
+The below SQL statement is used to insert one row into table "d1001".
+
+```sql
+INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31);
+```
+
+### Insert Multiple Rows
+
+Multiple rows can be inserted in a single SQL statement. The example below inserts 2 rows into table "d1001".
+
+```sql
+INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, 218, 0.25);
+```
+
+### Insert into Multiple Tables
+
+Data can be inserted into multiple tables in the same SQL statement. The example below inserts 2 rows into table "d1001" and 1 row into table "d1002".
+
+```sql
+INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
+```
+
+For more details about `INSERT` please refer to [INSERT](/taos-sql/insert).
+
+:::info
+
+- Inserting in batches can improve performance. Normally, the higher the batch size, the better the performance. Please note that a single row can't exceed 48K bytes and each SQL statement can't exceed 1MB.
+- Inserting with multiple threads can also improve performance. However, depending on the system resources on the application side and the server side, when the number of inserting threads grows beyond a specific point the performance may drop instead of improving. The proper number of threads needs to be tested in a specific environment to find the best number.
+
+:::
+
+:::warning
+
+- If the timestamp for the row to be inserted already exists in the table, the behavior depends on the value of parameter `UPDATE`. If it's set to 0 (the default value), the row will be discarded. If it's set to 1, the new values will override the old values for the same row.
+- The timestamp to be inserted must be newer than the timestamp of subtracting current time by the parameter `KEEP`. If `KEEP` is set to 3650 days, then the data older than 3650 days ago can't be inserted. The timestamp to be inserted can't be newer than the timestamp of current time plus parameter `DAYS`. If `DAYS` is set to 2, the data newer than 2 days later can't be inserted.
+
+:::
\ No newline at end of file

docs/en/05-develop/04-query-data.md

-# Query Data
+# Query Data
\ No newline at end of file
+
+
+## Introduction
+
+SQL is used by TDengine as its query language. Application programs can send SQL statements to TDengine through REST API or connectors. TDengine's CLI `taos` can also be used to execute ad hoc SQL queries. Here is the list of major query functionalities supported by TDengine：
+
+- Query on single column or multiple columns
+- Filter on tags or data columns：>, <, =, <\>, like
+- Grouping of results: `Group By`
+- Sorting of results: `Order By`
+- Limit the number of results: `Limit/Offset`
+- Arithmetic on columns of numeric types or aggregate results
+- Join query with timestamp alignment
+- Aggregate functions: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff
+
+For example, the SQL statement below can be executed in TDengine CLI `taos` to select records with voltage greater than 215 and limit the output to only 2 rows.
+
+```sql
+select * from d1001 where voltage > 215 order by ts desc limit 2;
+```
+
+```title=Output
+taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
+           ts            |       current        |   voltage   |        phase         |
+======================================================================================
+ 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 |
+ 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 |
+Query OK, 2 row(s) in set (0.001100s)
+```
+
+To meet the requirements of varied use cases, some special functions have been added in TDengine. Some examples are `twa` (Time Weighted Average), `spread` (The difference between the maximum and the minimum), and `last_row` (the last row). Furthermore, continuous query is also supported in TDengine.
+
+For detailed query syntax please refer to [Select](/taos-sql/select).
+
+## Aggregation among Tables
+
+In most use cases, there are always multiple kinds of data collection points. A new concept, called STable (abbreviation for super table), is used in TDengine to represent one type of data collection point, and a subtable is used to represent a specific data collection point of that type. Tags are used by TDengine to represent the static properties of data collection points. A specific data collection point has its own values for static properties. By specifying filter conditions on tags, aggregation can be performed efficiently among all the subtables created via the same STable, i.e. same type of data collection points. Aggregate functions applicable for tables can be used directly on STables; the syntax is exactly the same.
+
+In summary, records across subtables can be aggregated by a simple query on their STable. It is like a join operation. However, tables belonging to different STables can not be aggregated. 
+
+### Example 1
+
+In TDengine CLI `taos`, use the SQL below to get the average voltage of all the meters in California grouped by location.
+
+```
+taos> SELECT AVG(voltage) FROM meters GROUP BY location;
+       avg(voltage)        |            location            |
+=============================================================
+             222.000000000 | California.LosAngeles                |
+             219.200000000 | California.SanFrancisco               |
+Query OK, 2 row(s) in set (0.002136s)
+```
+
+### Example 2
+
+In TDengine CLI `taos`, use the SQL below to get the number of rows and the maximum current in the past 24 hours from meters whose groupId is 2.
+
+```
+taos> SELECT count(*), max(current) FROM meters where groupId = 2 and ts > now - 24h;
+     count(*)  |    max(current)  |
+==================================
+            5 |             13.4 |
+Query OK, 1 row(s) in set (0.002136s)
+```
+
+Join queries are only allowed between subtables of the same STable. In [Select](/taos-sql/select), all query operations are marked as to whether they support STables or not.
+
+## Down Sampling and Interpolation
+
+In IoT use cases, down sampling is widely used to aggregate data by time range. The `INTERVAL` keyword in TDengine can be used to simplify the query by time window. For example, the SQL statement below can be used to get the sum of current every 10 seconds from meters table d1001.
+
+```
+taos> SELECT sum(current) FROM d1001 INTERVAL(10s);
+           ts            |       sum(current)        |
+======================================================
+ 2018-10-03 14:38:00.000 |              10.300000191 |
+ 2018-10-03 14:38:10.000 |              24.900000572 |
+Query OK, 2 row(s) in set (0.000883s)
+```
+
+Down sampling can also be used for STable. For example, the below SQL statement can be used to get the sum of current from all meters in California.
+
+```
+taos> SELECT SUM(current) FROM meters where location like "California%" INTERVAL(1s);
+           ts            |       sum(current)        |
+======================================================
+ 2018-10-03 14:38:04.000 |              10.199999809 |
+ 2018-10-03 14:38:05.000 |              32.900000572 |
+ 2018-10-03 14:38:06.000 |              11.500000000 |
+ 2018-10-03 14:38:15.000 |              12.600000381 |
+ 2018-10-03 14:38:16.000 |              36.000000000 |
+Query OK, 5 row(s) in set (0.001538s)
+```
+
+Down sampling also supports time offset. For example, the below SQL statement can be used to get the sum of current from all meters but each time window must start at the boundary of 500 milliseconds.
+
+```
+taos> SELECT SUM(current) FROM meters INTERVAL(1s, 500a);
+           ts            |       sum(current)        |
+======================================================
+ 2018-10-03 14:38:04.500 |              11.189999809 |
+ 2018-10-03 14:38:05.500 |              31.900000572 |
+ 2018-10-03 14:38:06.500 |              11.600000000 |
+ 2018-10-03 14:38:15.500 |              12.300000381 |
+ 2018-10-03 14:38:16.500 |              35.000000000 |
+Query OK, 5 row(s) in set (0.001521s)
+```
+
+In many use cases, it's hard to align the timestamp of the data collected by each collection point. However, a lot of algorithms like FFT require the data to be aligned with same time interval and application programs have to handle this by themselves. In TDengine, it's easy to achieve the alignment using down sampling.
+
+Interpolation can be performed in TDengine if there is no data in a time range.
+
+For more details please refer to [Aggregate by Window](/taos-sql/interval).
+

docs/en/06-taos-sql/01-data-type.md

+---
+title: Data Types
+description: "TDengine supports a variety of data types including timestamp, float, JSON and many others."
+---
+
+When using TDengine to store and query data, the most important part of the data is timestamp. Timestamp must be specified when creating and inserting data rows. Timestamp must follow the rules below:
+
+- The format must be `YYYY-MM-DD HH:mm:ss.MS`, the default time precision is millisecond (ms), for example `2017-08-12 18:25:58.128`
+- Internal function `now` can be used to get the current timestamp on the client side
+- The current timestamp of the client side is applied when `now` is used to insert data
+- Epoch Time：timestamp can also be a long integer number, which means the number of seconds, milliseconds or nanoseconds, depending on the time precision, from 1970-01-01 00:00:00.000 (UTC/GMT)
+- Add/subtract operations can be carried out on timestamps. For example `now-2h` means 2 hours prior to the time at which query is executed. The units of time in operations can be b(nanosecond), u(microsecond), a(millisecond), s(second), m(minute), h(hour), d(day), or w(week). So `select * from t1 where ts > now-2w and ts <= now-1w` means the data between two weeks ago and one week ago. The time unit can also be n (calendar month) or y (calendar year) when specifying the time window for down sampling operations.
+
+Time precision in TDengine can be set by the `PRECISION` parameter when executing `CREATE DATABASE`. The default time precision is millisecond. In the statement below, the precision is set to nanonseconds.
+
+```sql
+CREATE DATABASE db_name PRECISION 'ns';
+```
+
+In TDengine, the data types below can be used when specifying a column or tag.
+
+| #   | **type**  | **Bytes** | **Description** |
+| --- | :-------: | --------- | ------------------------- |
+| 1   | TIMESTAMP | 8         | Default precision is millisecond, microsecond and nanosecond are also supported  |
+| 2   |    INT    | 4         | Integer, the value range is [-2^31+1, 2^31-1], while -2^31 is treated as NULL  |
+| 3   |  BIGINT   | 8         | Long integer, the value range is [-2^63+1, 2^63-1], while -2^63 is treated as NULL |
+| 4   |   FLOAT   | 4         | Floating point number, the effective number of digits is 6-7, the value range is [-3.4E38, 3.4E38]  |
+| 5   |  DOUBLE   | 8         | Double precision floating point number, the effective number of digits is 15-16, the value range is [-1.7E308, 1.7E308]  |
+| 6   |  BINARY   | User Defined | Single-byte string for ASCII visible characters. Length must be specified when defining a column or tag of binary type. The string length can be up to  16374 bytes. The string value must be quoted with single quotes. The literal single quote inside the string must be preceded with back slash like `\'` |
+| 7   | SMALLINT  | 2         | Short integer, the value range is [-32767, 32767], while -32768 is treated as NULL  |
+| 8   |  TINYINT  | 1         | Single-byte integer, the value range is [-127, 127], while -128 is treated as NULL |
+| 9   |   BOOL    | 1         | Bool, the value range is {true, false}   |
+| 10  | NCHAR     | User Defined| Multi-Byte string that can include multi byte characters like Chinese characters. Each character of NCHAR type consumes 4 bytes storage. The string value should be quoted with single quotes. Literal single quote inside the string must be preceded with backslash, like `\’`. The length must be specified when defining a column or tag of NCHAR type, for example nchar(10) means it can store at most 10 characters of nchar type and will consume fixed storage of 40 bytes. An error will be reported if the string value exceeds the length defined.   |
+| 11  |   JSON    |           | JSON type can only be used on tags. A tag of json type is excluded with any other tags of any other type |
+
+:::tip
+TDengine is case insensitive and treats any characters in the sql command as lower case by default, case sensitive strings must be quoted with single quotes.
+
+:::
+
+:::note
+Only ASCII visible characters are suggested to be used in a column or tag of BINARY type. Multi-byte characters must be stored in NCHAR type.
+
+:::
+
+:::note
+Numeric values in SQL statements will be determined as integer or float type according to whether there is decimal point or whether scientific notation is used, so attention must be paid to avoid overflow. For example, 9999999999999999999 will be considered as overflow because it exceeds the upper limit of long integer, but 9999999999999999999.0 will be considered as a legal float number.
+
+:::

docs/en/06-taos-sql/02-database.md

+---
+sidebar_label: Database
+title: Database
+description: "create and drop database, show or change database parameters"
+---
+
+## Create Database
+
+```
+CREATE DATABASE [IF NOT EXISTS] db_name [KEEP keep] [DAYS days] [UPDATE 1];
+```
+
+:::info
+
+1. KEEP specifies the number of days for which the data in the database will be retained. The default value is 3650 days, i.e. 10 years. The data will be deleted automatically once its age exceeds this threshold.
+2. UPDATE specifies whether the data can be updated and how the data can be updated.
+   1. UPDATE set to 0 means update operation is not allowed. The update for data with an existing timestamp will be discarded silently and the original record in the database will be preserved as is.
+   2. UPDATE set to 1 means the whole row will be updated. The columns for which no value is specified will be set to NULL.
+   3. UPDATE set to 2 means updating a subset of columns for a row is allowed. The columns for which no value is specified will be kept unchanged.
+3. The maximum length of database name is 33 bytes.
+4. The maximum length of a SQL statement is 65,480 bytes.
+5. Below are the parameters that can be used when creating a database
+   - cache: [Description](/reference/config/#cache)
+   - blocks: [Description](/reference/config/#blocks)
+   - days: [Description](/reference/config/#days)
+   - keep: [Description](/reference/config/#keep)
+   - minRows: [Description](/reference/config/#minrows)
+   - maxRows: [Description](/reference/config/#maxrows)
+   - wal: [Description](/reference/config/#wallevel)
+   - fsync: [Description](/reference/config/#fsync)
+   - update: [Description](/reference/config/#update)
+   - cacheLast: [Description](/reference/config/#cachelast)
+   - replica: [Description](/reference/config/#replica)
+   - quorum: [Description](/reference/config/#quorum)
+   - maxVgroupsPerDb: [Description](/reference/config/#maxvgroupsperdb)
+   - comp: [Description](/reference/config/#comp)
+   - precision: [Description](/reference/config/#precision)
+6. Please note that all of the parameters mentioned in this section are configured in configuration file `taos.cfg` on the TDengine server. If not specified in the `create database` statement, the values from taos.cfg are used by default. To override default parameters, they must be specified in the `create database` statement.
+   
+:::
+
+## Show Current Configuration
+
+```
+SHOW VARIABLES;
+```
+
+## Specify The Database In Use
+
+```
+USE db_name;
+```
+
+:::note
+This way is not applicable when using a REST connection. In a REST connection the database name must be specified before a table or stable name. For e.g. to query the stable "meters" in database "test" the query would be "SELECT count(*) from test.meters"
+
+:::
+
+## Drop Database
+
+```
+DROP DATABASE [IF EXISTS] db_name;
+```
+
+:::note
+All data in the database will be deleted too. This command must be used with extreme caution. Please follow your organization's data integrity, data backup, data security or any other applicable SOPs before using this command.
+
+:::
+
+## Change Database Configuration
+
+Some examples are shown below to demonstrate how to change the configuration of a database. Please note that some configuration parameters can be changed after the database is created, but some cannot. For details of the configuration parameters of database please refer to [Configuration Parameters](/reference/config/).
+
+```
+ALTER DATABASE db_name COMP 2;
+```
+
+COMP parameter specifies whether the data is compressed and how the data is compressed.
+
+```
+ALTER DATABASE db_name REPLICA 2;
+```
+
+REPLICA parameter specifies the number of replicas of the database.
+
+```
+ALTER DATABASE db_name KEEP 365;
+```
+
+KEEP parameter specifies the number of days for which the data will be kept.
+
+```
+ALTER DATABASE db_name QUORUM 2;
+```
+
+QUORUM parameter specifies the necessary number of confirmations to determine whether the data is written successfully.
+
+```
+ALTER DATABASE db_name BLOCKS 100;
+```
+
+BLOCKS parameter specifies the number of memory blocks used by each VNODE.
+
+```
+ALTER DATABASE db_name CACHELAST 0;
+```
+
+CACHELAST parameter specifies whether and how the latest data of a sub table is cached.
+
+:::tip
+The above parameters can be changed using `ALTER DATABASE` command without restarting. For more details of all configuration parameters please refer to [Configuration Parameters](/reference/config/).
+
+:::
+
+## Show All Databases
+
+```
+SHOW DATABASES;
+```
+
+## Show The Create Statement of A Database
+
+```
+SHOW CREATE DATABASE db_name;
+```
+
+This command is useful when migrating the data from one TDengine cluster to another. This command can be used to get the CREATE statement, which can be used in another TDengine instance to create the exact same database.

docs/en/06-taos-sql/03-table.md

+---
+sidebar_label: Table
+title: Table
+description: create super table, normal table and sub table, drop tables and change tables
+---
+
+## Create Table
+
+```
+CREATE TABLE [IF NOT EXISTS] tb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]);
+```
+
+:::info
+
+1. The first column of a table MUST be of type TIMESTAMP. It is automatically set as the primary key.
+2. The maximum length of the table name is 192 bytes.
+3. The maximum length of each row is 48k bytes, please note that the extra 2 bytes used by each BINARY/NCHAR column are also counted.
+4. The name of the subtable can only consist of characters from the English alphabet, digits and underscore. Table names can't start with a digit. Table names are case insensitive.
+5. The maximum length in bytes must be specified when using BINARY or NCHAR types.
+6. Escape character "\`" can be used to avoid the conflict between table names and reserved keywords, above rules will be bypassed when using escape character on table names, but the upper limit for the name length is still valid. The table names specified using escape character are case sensitive. Only ASCII visible characters can be used with escape character.
+   For example \`aBc\` and \`abc\` are different table names but `abc` and `aBc` are same table names because they are both converted to `abc` internally.
+
+:::
+
+### Create Subtable Using STable As Template
+
+```
+CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name TAGS (tag_value1, ...);
+```
+
+The above command creates a subtable using the specified super table as a template and the specified tag values.
+
+### Create Subtable Using STable As Template With A Subset of Tags
+
+```
+CREATE TABLE [IF NOT EXISTS] tb_name USING stb_name (tag_name1, ...) TAGS (tag_value1, ...);
+```
+
+The tags for which no value is specified will be set to NULL.
+
+### Create Tables in Batch
+
+```
+CREATE TABLE [IF NOT EXISTS] tb_name1 USING stb_name TAGS (tag_value1, ...) [IF NOT EXISTS] tb_name2 USING stb_name TAGS (tag_value2, ...) ...;
+```
+
+This can be used to create a lot of tables in a single SQL statement while making table creation much faster.
+
+:::info
+
+- Creating tables in batch must use a super table as a template.
+- The length of single statement is suggested to be between 1,000 and 3,000 bytes for best performance.
+
+:::
+
+## Drop Tables
+
+```
+DROP TABLE [IF EXISTS] tb_name;
+```
+
+## Show All Tables In Current Database
+
+```
+SHOW TABLES [LIKE tb_name_wildcard];
+```
+
+## Show Create Statement of A Table
+
+```
+SHOW CREATE TABLE tb_name;
+```
+
+This is useful when migrating the data in one TDengine cluster to another one because it can be used to create the exact same tables in the target database.
+
+## Show Table Definition
+
+```
+DESCRIBE tb_name;
+```
+
+## Change Table Definition
+
+### Add A Column
+
+```
+ALTER TABLE tb_name ADD COLUMN field_name data_type;
+```
+
+:::info
+
+1. The maximum number of columns is 4096, the minimum number of columns is 2.
+2. The maximum length of a column name is 64 bytes.
+
+:::
+
+### Remove A Column
+
+```
+ALTER TABLE tb_name DROP COLUMN field_name;
+```
+
+:::note
+If a table is created using a super table as template, the table definition can only be changed on the corresponding super table, and the change will be automatically applied to all the subtables created using this super table as template. For tables created in the normal way, the table definition can be changed directly on the table.
+
+:::
+
+### Change Column Length
+
+```
+ALTER TABLE tb_name MODIFY COLUMN field_name data_type(length);
+```
+
+If the type of a column is variable length, like BINARY or NCHAR, this command can be used to change the length of the column.
+
+:::note
+If a table is created using a super table as template, the table definition can only be changed on the corresponding super table, and the change will be automatically applied to all the subtables created using this super table as template. For tables created in the normal way, the table definition can be changed directly on the table.
+
+:::
+
+### Change Tag Value Of Sub Table
+
+```
+ALTER TABLE tb_name SET TAG tag_name=new_tag_value;
+```
+
+This command can be used to change the tag value if the table is created using a super table as template.

docs/en/06-taos-sql/04-stable.md

+---
+sidebar_label: STable
+title: Super Table
+---
+
+:::note
+
+Keyword `STable`, abbreviated for super table, is supported since version 2.0.15.
+
+:::
+
+## Create STable
+
+```
+CREATE STable [IF NOT EXISTS] stb_name (timestamp_field_name TIMESTAMP, field1_name data_type1 [, field2_name data_type2 ...]) TAGS (tag1_name tag_type1, tag2_name tag_type2 [, tag3_name tag_type3]);
+```
+
+The SQL statement of creating a STable is similar to that of creating a table, but a special column set named `TAGS` must be specified with the names and types of the tags.
+
+:::info
+
+1. A tag can be of type timestamp, since version 2.1.3.0, but its value must be fixed and arithmetic operations cannot be performed on it. Prior to version 2.1.3.0, tag types specified in TAGS could not be of type timestamp.
+2. The tag names specified in TAGS should NOT be the same as other columns.
+3. The tag names specified in TAGS should NOT be the same as any reserved keywords.(Please refer to [keywords](/taos-sql/keywords/)
+4. The maximum number of tags specified in TAGS is 128, there must be at least one tag, and the total length of all tag columns should NOT exceed 16KB.
+
+:::
+
+## Drop STable
+
+```
+DROP STable [IF EXISTS] stb_name;
+```
+
+All the subtables created using the deleted STable will be deleted automatically.
+
+## Show All STables
+
+```
+SHOW STableS [LIKE tb_name_wildcard];
+```
+
+This command can be used to display the information of all STables in the current database, including name, creation time, number of columns, number of tags, and number of tables created using this STable.
+
+## Show The Create Statement of A STable
+
+```
+SHOW CREATE STable stb_name;
+```
+
+This command is useful in migrating data from one TDengine cluster to another because it can be used to create the exact same STable in the target database.
+
+## Get STable Definition
+
+```
+DESCRIBE stb_name;
+```
+
+## Change Columns Of STable
+
+### Add A Column
+
+```
+ALTER STable stb_name ADD COLUMN field_name data_type;
+```
+
+### Remove A Column
+
+```
+ALTER STable stb_name DROP COLUMN field_name;
+```
+
+### Change Column Length
+
+```
+ALTER STable stb_name MODIFY COLUMN field_name data_type(length);
+```
+
+This command can be used to change (or more specifically, increase) the length of a column of variable length types, like BINARY or NCHAR.
+
+## Change Tags of A STable
+
+### Add A Tag
+
+```
+ALTER STable stb_name ADD TAG new_tag_name tag_type;
+```
+
+This command is used to add a new tag for a STable and specify the tag type.
+
+### Remove A Tag
+
+```
+ALTER STable stb_name DROP TAG tag_name;
+```
+
+The tag will be removed automatically from all the subtables, created using the super table as template, once a tag is removed from a super table.
+
+### Change A Tag
+
+```
+ALTER STable stb_name CHANGE TAG old_tag_name new_tag_name;
+```
+
+The tag name will be changed automatically for all the subtables, created using the super table as template, once a tag name is changed for a super table.
+
+### Change Tag Length
+
+```
+ALTER STable stb_name MODIFY TAG tag_name data_type(length);
+```
+
+This command can be used to change (or more specifically, increase) the length of a tag of variable length types, like BINARY or NCHAR.
+
+:::note
+Changing tag values can be applied to only subtables. All other tag operations, like add tag, remove tag, however, can be applied to only STable. If a new tag is added for a STable, the tag will be added with NULL value for all its subtables.
+
+:::

docs/en/06-taos-sql/05-insert.md

+---
+title: Insert
+---
+
+## Syntax
+
+```sql
+INSERT INTO
+    tb_name
+        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
+        [(field1_name, ...)]
+        VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
+    [tb2_name
+        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
+        [(field1_name, ...)]
+        VALUES (field1_value, ...) [(field1_value2, ...) ...] | FILE csv_file_path
+    ...];
+```
+
+## Insert Single or Multiple Rows
+
+Single row or multiple rows specified with VALUES can be inserted into a specific table. For example:
+
+A single row is inserted using the below statement.
+
+```sq;
+INSERT INTO d1001 VALUES (NOW, 10.2, 219, 0.32);
+```
+
+Double rows are inserted using the below statement.
+
+```sql
+INSERT INTO d1001 VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32) (1626164208000, 10.15, 217, 0.33);
+```
+
+:::note
+
+1. In the second example above, different formats are used in the two rows to be inserted. In the first row, the timestamp format is a date and time string, which is interpreted from the string value only. In the second row, the timestamp format is a long integer, which will be interpreted based on the database time precision.
+2. When trying to insert multiple rows in a single statement, only the timestamp of one row can be set as NOW, otherwise there will be duplicate timestamps among the rows and the result may be out of expectation because NOW will be interpreted as the time when the statement is executed.
+3. The oldest timestamp that is allowed is subtracting the KEEP parameter from current time.
+4. The newest timestamp that is allowed is adding the DAYS parameter to current time.
+
+:::
+
+## Insert Into Specific Columns
+
+Data can be inserted into specific columns, either single row or multiple row, while other columns will be inserted as NULL value.
+
+```
+INSERT INTO d1001 (ts, current, phase) VALUES ('2021-07-13 14:06:33.196', 10.27, 0.31);
+```
+
+:::info
+If no columns are explicitly specified, all the columns must be provided with values, this is called "all column mode". The insert performance of all column mode is much better than specifying a subset of columns, so it's encouraged to use "all column mode" while providing NULL value explicitly for the columns for which no actual value can be provided.
+
+:::
+
+## Insert Into Multiple Tables
+
+One or multiple rows can be inserted into multiple tables in a single SQL statement, with or without specifying specific columns.
+
+```sql
+INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
+            d1002 (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31）;
+```
+
+## Automatically Create Table When Inserting
+
+If it's unknown whether the table already exists, the table can be created automatically while inserting using the SQL statement below. To use this functionality, a STable must be used as template and tag values must be provided.
+
+```sql
+INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32);
+```
+
+It's not necessary to provide values for all tags when creating tables automatically, the tags without values provided will be set to NULL.
+
+```sql
+INSERT INTO d21001 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:33.196', 10.15, 217, 0.33);
+```
+
+Multiple rows can also be inserted into the same table in a single SQL statement.
+
+```sql
+INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
+            d21002 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:34.255', 10.15, 217, 0.33)
+            d21003 USING meters (groupId) TAGS (2) (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31);
+```
+
+:::info
+Prior to version 2.0.20.5, when using `INSERT` to create tables automatically and specifying the columns, the column names must follow the table name immediately. From version 2.0.20.5, the column names can follow the table name immediately, also can be put between `TAGS` and `VALUES`. In the same SQL statement, however, these two ways of specifying column names can't be mixed.
+:::
+
+## Insert Rows From A File
+
+Besides using `VALUES` to insert one or multiple rows, the data to be inserted can also be prepared in a CSV file with comma as separator and each field value quoted by single quotes. Table definition is not required in the CSV file. For example, if file "/tmp/csvfile.csv" contains the below data:
+
+```
+'2021-07-13 14:07:34.630', '10.2', '219', '0.32'
+'2021-07-13 14:07:35.779', '10.15', '217', '0.33'
+```
+
+Then data in this file can be inserted by the SQL statement below:
+
+```sql
+INSERT INTO d1001 FILE '/tmp/csvfile.csv';
+```
+
+## Create Tables Automatically and Insert Rows From File
+
+From version 2.1.5.0, tables can be automatically created using a super table as template when inserting data from a CSV file, like below:
+
+```sql
+INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/csvfile.csv';
+```
+
+Multiple tables can be automatically created and inserted in a single SQL statement, like below:
+
+```sql
+INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/csvfile_21001.csv'
+            d21002 USING meters (groupId) TAGS (2) FILE '/tmp/csvfile_21002.csv';
+```
+
+## More About Insert
+
+For SQL statement like `insert`, a stream parsing strategy is applied. That means before an error is found and the execution is aborted, the part prior to the error point has already been executed. Below is an experiment to help understand the behavior.
+
+First, a super table is created.
+
+```sql
+CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);
+```
+
+It can be proven that the super table has been created by `SHOW STableS`, but no table exists using `SHOW TABLES`.
+
+```
+taos> SHOW STableS;
+              name              |      created_time       | columns |  tags  |   tables    |
+============================================================================================
+ meters                         | 2020-08-06 17:50:27.831 |       4 |      2 |           0 |
+Query OK, 1 row(s) in set (0.001029s)
+
+taos> SHOW TABLES;
+Query OK, 0 row(s) in set (0.000946s)
+```
+
+Then, try to create table d1001 automatically when inserting data into it.
+
+```sql
+INSERT INTO d1001 USING meters TAGS('California.SanFrancisco', 2) VALUES('a');
+```
+
+The output shows the value to be inserted is invalid. But `SHOW TABLES` proves that the table has been created automatically by the `INSERT` statement.
+
+```
+DB error: invalid SQL: 'a' (invalid timestamp) (0.039494s)
+
+taos> SHOW TABLES;
+           table_name           |      created_time       | columns |          STable_name           |
+======================================================================================================
+ d1001                          | 2020-08-06 17:52:02.097 |       4 | meters                         |
+Query OK, 1 row(s) in set (0.001091s)
+```
+
+From the above experiment, we can see that while the value to be inserted is invalid the table is still created.

docs/en/06-taos-sql/08-delete-data.mdx

+---
+sidebar_label: Delete Data
+description: "Delete data from table or Stable"
+title: Delete Data
+---
+
+TDengine provides the functionality of deleting data from a table or STable according to specified time range, it can be used to cleanup abnormal data generated due to device failure. Please be noted that this functionality is only available in Enterprise version, please refer to [TDengine Enterprise Edition](https://tdengine.com/products#enterprise-edition-link)
+
+
+**Syntax:**
+
+```sql
+DELETE FROM [ db_name. ] tb_name [WHERE condition];
+```
+
+**Description:** Delete data from a table or STable
+
+**Parameters:**
+   
+- `db_name`:   Optional parameter, specifies the database in which the table exists; if not specified, the current database will be used.
+- `tb_name`:  Mandatory parameter, specifies the table name from which data will be deleted, it can be normal table, subtable or STable.
+- `condition`: Optional parameter, specifies the data filter condition. If no condition is specified all data will be deleted, so please be cautions to delete data without any condition. The condition used here is only applicable to the first column, i.e. the timestamp column. If the table is a STable, the condition is also applicable to tag columns.
+
+**More Explanations:**
+      
+The data can't be recovered once deleted, so please be cautious to use the functionality of deleting data. It's better to firstly make sure the data to be deleted using `select` then execute `delete`.       
+
+**Example:**
+    
+`meters` is a STable, in which `groupid` is a tag column of int type. Now we want to delete the data older than 2021-10-01 10:40:00.100 and `groupid` is 1.  The SQL for this purpose is like below:
+
+```sql
+delete from meters where ts < '2021-10-01 10:40:00.100' and groupid=1 ;
+```
+
+The output is:
+
+```
+Deleted 102000 row(s) from 1020 table(s) (0.421950s)
+```
+
+It means totally 102,000 rows of data have been deleted from 1,020 sub tables.

docs/en/06-taos-sql/12-interval.md

+---
+sidebar_label: Interval
+title: Aggregate by Time Window
+---
+
+Aggregation by time window is supported in TDengine. For example, in the case where temperature sensors report the temperature every seconds, the average temperature for every 10 minutes can be retrieved by performing a query with a time window.
+Window related clauses are used to divide the data set to be queried into subsets and then aggregation is performed across the subsets. There are three kinds of windows: time window, status window, and session window. There are two kinds of time windows: sliding window and flip time/tumbling window.
+
+## Time Window
+
+The `INTERVAL` clause is used to generate time windows of the same time interval. The `SLIDING` parameter is used to specify the time step for which the time window moves forward. The query is performed on one time window each time, and the time window moves forward with time. When defining a continuous query, both the size of the time window and the step of forward sliding time need to be specified. As shown in the figure blow, [t0s, t0e] ，[t1s , t1e]， [t2s, t2e] are respectively the time ranges of three time windows on which continuous queries are executed. The time step for which time window moves forward is marked by `sliding time`. Query, filter and aggregate operations are executed on each time window respectively. When the time step specified by `SLIDING` is same as the time interval specified by `INTERVAL`, the sliding time window is actually a flip time/tumbling window.
+
+![TDengine Database Time Window](./timewindow-1.webp)
+
+`INTERVAL` and `SLIDING` should be used with aggregate functions and select functions. The SQL statement below is illegal because no aggregate or selection function is used with `INTERVAL`.
+
+```
+SELECT * FROM temp_tb_1 INTERVAL(1m);
+```
+
+The time step specified by `SLIDING` cannot exceed the time interval specified by `INTERVAL`. The SQL statement below is illegal because the time length specified by `SLIDING` exceeds that specified by `INTERVAL`.
+
+```
+SELECT COUNT(*) FROM temp_tb_1 INTERVAL(1m) SLIDING(2m);
+```
+
+When the time length specified by `SLIDING` is the same as that specified by `INTERVAL`, the sliding window is actually a flip/tumbling window. The minimum time range specified by `INTERVAL` is 10 milliseconds (10a) prior to version 2.1.5.0. Since version 2.1.5.0, the minimum time range by `INTERVAL` can be 1 microsecond (1u). However, if the DB precision is millisecond, the minimum time range is 1 millisecond (1a). Please note that the `timezone` parameter should be configured to be the same value in the `taos.cfg` configuration file on client side and server side.
+
+## Status Window
+
+In case of using integer, bool, or string to represent the status of a device at any given moment, continuous rows with the same status belong to a status window. Once the status changes, the status window closes. As shown in the following figure, there are two status windows according to status, [2019-04-28 14:22:07，2019-04-28 14:22:10] and [2019-04-28 14:22:11，2019-04-28 14:22:12]. Status window is not applicable to STable for now.
+
+![TDengine Database Status Window](./timewindow-3.webp)
+
+`STATE_WINDOW` is used to specify the column on which the status window will be based. For example：
+
+```
+SELECT COUNT(*), FIRST(ts), status FROM temp_tb_1 STATE_WINDOW(status);
+```
+
+## Session Window
+
+```sql
+SELECT COUNT(*), FIRST(ts) FROM temp_tb_1 SESSION(ts, tol_val);
+```
+
+The primary key, i.e. timestamp, is used to determine which session window a row belongs to. If the time interval between two adjacent rows is within the time range specified by `tol_val`, they belong to the same session window; otherwise they belong to two different session windows. As shown in the figure below, if the limit of time interval for the session window is specified as 12 seconds, then the 6 rows in the figure constitutes 2 time windows, [2019-04-28 14:22:10，2019-04-28 14:22:30] and [2019-04-28 14:23:10，2019-04-28 14:23:30], because the time difference between 2019-04-28 14:22:30 and 2019-04-28 14:23:10 is 40 seconds, which exceeds the time interval limit of 12 seconds.
+
+![TDengine Database Session Window](./timewindow-2.webp)
+
+If the time interval between two continuous rows are within the time interval specified by `tol_value` they belong to the same session window; otherwise a new session window is started automatically. Session window is not supported on STable for now.
+
+## More On Window Aggregate
+
+### Syntax
+
+The full syntax of aggregate by window is as follows:
+
+```sql
+SELECT function_list FROM tb_name
+  [WHERE where_condition]
+  [SESSION(ts_col, tol_val)]
+  [STATE_WINDOW(col)]
+  [INTERVAL(interval [, offset]) [SLIDING sliding]]
+  [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
+
+SELECT function_list FROM stb_name
+  [WHERE where_condition]
+  [INTERVAL(interval [, offset]) [SLIDING sliding]]
+  [FILL({NONE | VALUE | PREV | NULL | LINEAR | NEXT})]
+  [GROUP BY tags]
+```
+
+### Restrictions
+
+- Aggregate functions and select functions can be used in `function_list`, with each function having only one output. For example COUNT, AVG, SUM, STDDEV, LEASTSQUARES, PERCENTILE, MIN, MAX, FIRST, LAST. Functions having multiple outputs, such as DIFF or arithmetic operations can't be used.
+- `LAST_ROW` can't be used together with window aggregate.
+- Scalar functions, like CEIL/FLOOR, can't be used with window aggregate.
+- `WHERE` clause can be used to specify the starting and ending time and other filter conditions
+- `FILL` clause is used to specify how to fill when there is data missing in any window, including:
+  1. NONE: No fill (the default fill mode)
+  2. VALUE：Fill with a fixed value, which should be specified together, for example `FILL(VALUE, 1.23)`
+  3. PREV：Fill with the previous non-NULL value, `FILL(PREV)`
+  4. NULL：Fill with NULL, `FILL(NULL)`
+  5. LINEAR：Fill with the closest non-NULL value, `FILL(LINEAR)`
+  6. NEXT：Fill with the next non-NULL value, `FILL(NEXT)`
+
+:::info
+
+1. A huge volume of interpolation output may be returned using `FILL`, so it's recommended to specify the time range when using `FILL`. The maximum number of interpolation values that can be returned in a single query is 10,000,000.
+2. The result set is in ascending order of timestamp when you aggregate by time window.
+3. If aggregate by window is used on STable, the aggregate function is performed on all the rows matching the filter conditions. If `GROUP BY` is not used in the query, the result set will be returned in ascending order of timestamp; otherwise the result set is not exactly in the order of ascending timestamp in each group.
+
+:::
+
+Aggregate by time window is also used in continuous query, please refer to [Continuous Query](/develop/continuous-query).
+
+## Examples
+
+A table of intelligent meters can be created by the SQL statement below：
+
+```sql
+CREATE TABLE meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT);
+```
+
+The average current, maximum current and median of current in every 10 minutes for the past 24 hours can be calculated using the SQL statement below, with missing values filled with the previous non-NULL values.
+
+```
+SELECT AVG(current), MAX(current), APERCENTILE(current, 50) FROM meters
+  WHERE ts>=NOW-1d and ts<=now
+  INTERVAL(10m)
+  FILL(PREV);
+```

docs/en/06-taos-sql/14-limit.md

+---
+title: Limits & Restrictions
+---
+
+## Naming Rules
+
+1. Only characters from the English alphabet, digits and underscore are allowed
+2. Names cannot start with a digit
+3. Case insensitive without escape character "\`"
+4. Identifier with escape character "\`"
+   To support more flexible table or column names, a new escape character "\`" is introduced. For more details please refer to [escape](/taos-sql/escape).
+
+## Password Rule
+
+The legal character set is `[a-zA-Z0-9!?$%^&*()_–+={[}]:;@~#|<,>.?/]`.
+
+## General Limits
+
+- Maximum length of database name is 32 bytes.
+- Maximum length of table name is 192 bytes, excluding the database name prefix and the separator.
+- Maximum length of each data row is 48K bytes since version 2.1.7.0 , before which the limit was 16K bytes. Please note that the upper limit includes the extra 2 bytes consumed by each column of BINARY/NCHAR type.
+- Maximum length of column name is 64.
+- Maximum number of columns is 4096. There must be at least 2 columns, and the first column must be timestamp.
+- Maximum length of tag name is 64.
+- Maximum number of tags is 128. There must be at least 1 tag. The total length of tag values should not exceed 16K bytes.
+- Maximum length of singe SQL statement is 1048576, i.e. 1 MB. It can be configured in the parameter `maxSQLLength` in the client side, the applicable range is [65480, 1048576].
+- At most 4096 columns (or 1024 prior to 2.1.7.0) can be returned by `SELECT`. Functions in the query statement constitute columns. An error is returned if the limit is exceeded.
+- Maximum numbers of databases, STables, tables are dependent only on the system resources.
+- Maximum of database name is 32 bytes, and it can't include "." or special characters.
+- Maximum number of replicas for a database is 3.
+- Maximum length of user name is 23 bytes.
+- Maximum length of password is 15 bytes.
+- Maximum number of rows depends only on the storage space.
+- Maximum number of tables depends only on the number of nodes.
+- Maximum number of databases depends only on the number of nodes.
+- Maximum number of vnodes for a single database is 64.
+
+## Restrictions of `GROUP BY`
+
+`GROUP BY` can be performed on tags and `TBNAME`. It can be performed on data columns too, with the only restriction being it can only be performed on one data column and the number of unique values in that column is lower than 100,000. Please note that `GROUP BY` cannot be performed on float or double types.
+
+## Restrictions of `IS NOT NULL`
+
+`IS NOT NULL` can be used on any data type of columns. The non-empty string evaluation expression, i.e. `< > ""` can only be used on non-numeric data types.
+
+## Restrictions of `ORDER BY`
+
+- Only one `order by` is allowed for normal table and subtable.
+- At most two `order by` are allowed for STable, and the second one must be `ts`.
+- `order by tag` must be used with `group by tag` on same tag. This rule is also applicable to `tbname`.
+- `order by column` must be used with `group by column` or `top/bottom` on same column. This rule is applicable to table and STable.
+- `order by ts` is applicable to table and STable.
+- If `order by ts` is used with `group by`, the result set is sorted using `ts` in each group.
+
+## Restrictions of Table/Column Names
+
+### Name Restrictions of Table/Column
+
+The name of a table or column can only be composed of ASCII characters, digits and underscore and it cannot start with a digit. The maximum length is 192 bytes. Names are case insensitive. The name mentioned in this rule doesn't include the database name prefix and the separator.
+
+### Name Restrictions After Escaping
+
+To support more flexible table or column names, new escape character "\`" is introduced in TDengine to avoid the conflict between table name and keywords and break the above restrictions for table names. The escape character is not counted in the length of table name.
+
+With escaping, the string inside escape characters are case sensitive, i.e. will not be converted to lower case internally.
+
+For example:
+\`aBc\` and \`abc\` are different table or column names, but "abc" and "aBc" are same names because internally they are all "abc".
+
+:::note
+The characters inside escape characters must be printable characters.
+
+:::
+
+### Applicable Versions
+
+Escape character "\`" is available from version 2.3.0.1.

docs/en/06-taos-sql/16-json.md

+---
+title: JSON Type
+---
+
+## Syntax
+
+1. Tag of type JSON
+
+   ```sql
+   create STable s1 (ts timestamp, v1 int) tags (info json);
+
+   create table s1_1 using s1 tags ('{"k1": "v1"}');
+   ```
+
+2. "->" Operator of JSON
+
+   ```sql
+   select * from s1 where info->'k1' = 'v1';
+
+   select info->'k1' from s1;
+   ```
+
+3. "contains" Operator of JSON
+
+   ```sql
+   select * from s1 where info contains 'k2';
+
+   select * from s1 where info contains 'k1';
+   ```
+
+## Applicable Operations
+
+1. When a JSON data type is used in `where`, `match/nmatch/between and/like/and/or/is null/is no null` can be used but `in` can't be used.
+
+   ```sql
+   select * from s1 where info->'k1' match 'v*';
+
+   select * from s1 where info->'k1' like 'v%' and info contains 'k2';
+
+   select * from s1 where info is null;
+
+   select * from s1 where info->'k1' is not null;
+   ```
+
+2. A tag of JSON type can be used in `group by`, `order by`, `join`, `union all` and sub query; for example `group by json->'key'`
+
+3. `Distinct` can be used with a tag of type JSON
+
+   ```sql
+   select distinct info->'k1' from s1;
+   ```
+
+4. Tag Operations
+
+   The value of a JSON tag can be altered. Please note that the full JSON will be overriden when doing this.
+
+   The name of a JSON tag can be altered. A tag of JSON type can't be added or removed. The column length of a JSON tag can't be changed.
+
+## Other Restrictions
+
+- JSON type can only be used for a tag. There can be only one tag of JSON type, and it's exclusive to any other types of tags.
+
+- The maximum length of keys in JSON is 256 bytes, and key must be printable ASCII characters. The maximum total length of a JSON is 4,096 bytes.
+
+- JSON format：
+
+  - The input string for JSON can be empty, i.e. "", "\t", or NULL, but it can't be non-NULL string, bool or array.
+  - object can be {}, and the entire JSON is empty if so. Key can be "", and it's ignored if so.
+  - value can be int, double, string, bool or NULL, and it can't be an array. Nesting is not allowed which means that the value of a key can't be JSON.
+  - If one key occurs twice in JSON, only the first one is valid.
+  - Escape characters are not allowed in JSON.
+
+- NULL is returned when querying a key that doesn't exist in JSON.
+
+- If a tag of JSON is the result of inner query, it can't be parsed and queried in the outer query.
+
+For example, the SQL statements below are not supported.
+
+```sql;
+select jtag->'key' from (select jtag from STable);
+select jtag->'key' from (select jtag from STable) where jtag->'key'>0;
+```

docs/en/06-taos-sql/18-escape.md

+---
+title: Escape Characters
+---
+
+Below table is the list of escape characters used in TDengine.
+
+| Escape Character | **Actual Meaning**       |
+| :--------------: | ------------------------ |
+|       `\'`       | Single quote '           |
+|       `\"`       | Double quote "           |
+|        \n        | Line Break               |
+|        \r        | Carriage Return          |
+|        \t        | tab                      |
+|       `\\`       | Back Slash \             |
+|       `\%`       | % see below for details  |
+|       `\_`       | \_ see below for details |
+
+:::note
+Escape characters are available from version 2.4.0.4 .
+
+:::
+
+## Restrictions
+
+1. If there are escape characters in identifiers (database name, table name, column name)
+   - Identifier without ``: Error will be returned because identifier must be constituted of digits, ASCII characters or underscore and can't be started with digits
+   - Identifier quoted with ``： Original content is kept, no escaping
+2. If there are escape characters in values
+   - The escape characters will be escaped as the above table. If the escape character doesn't match any supported one, the escape character "\" will be ignored.
+   - "%" and "\_" are used as wildcards in `like`. `\%` and `\_` should be used to represent literal "%" and "\_" in `like`,. If `\%` and `\_` are used out of `like` context, the evaluation result is "`\%`"and "`\_`", instead of "%" and "\_".

docs/en/06-taos-sql/20-keywords.md

+---
+title: Keywords
+---
+
+There are about 200 keywords reserved by TDengine, they can't be used as the name of database, STable or table with either upper case, lower case or mixed case.
+
+## Keyword List
+
+### A
+
+- ABORT
+- ACCOUNT
+- ACCOUNTS
+- ADD
+- AFTER
+- ALL
+- ALTER
+- AND
+- AS
+- ASC
+- ATTACH
+
+### B
+
+- BEFORE
+- BEGIN
+- BETWEEN
+- BIGINT
+- BINARY
+- BITAND
+- BITNOT
+- BITOR
+- BLOCKS
+- BOOL
+- BY
+
+### C
+
+- CACHE
+- CACHELAST
+- CASCADE
+- CHANGE
+- CLUSTER
+- COLON
+- COLUMN
+- COMMA
+- COMP
+- COMPACT
+- CONCAT
+- CONFLICT
+- CONNECTION
+- CONNECTIONS
+- CONNS
+- COPY
+- CREATE
+- CTIME
+
+### D
+
+- DATABASE  
+- DATABASES 
+- DAYS      
+- DBS       
+- DEFERRED  
+- DELETE
+- DELIMITERS
+- DESC      
+- DESCRIBE  
+- DETACH    
+- DISTINCT  
+- DIVIDE    
+- DNODE     
+- DNODES    
+- DOT       
+- DOUBLE    
+- DROP  
+
+### E
+
+- END     
+- EQ      
+- EXISTS  
+- EXPLAIN 
+
+### F
+
+- FAIL   
+- FILE   
+- FILL   
+- FLOAT  
+- FOR    
+- FROM   
+- FSYNC  
+
+### G
+
+- GE    
+- GLOB  
+- GRANTS
+- GROUP 
+- GT  
+
+### H
+
+- HAVING 
+
+### I
+
+- ID
+- IF
+- IGNORE 
+- IMMEDIA
+- IMPORT 
+- IN     
+- INITIAL
+- INSERT 
+- INSTEAD
+- INT    
+- INTEGER
+- INTERVA
+- INTO   
+- IS     
+- ISNULL 
+
+### J
+
+- JOIN
+
+### K
+
+- KEEP
+- KEY 
+- KILL
+
+### L
+
+- LE    
+- LIKE  
+- LIMIT 
+- LINEAR
+- LOCAL 
+- LP    
+- LSHIFT
+- LT 
+
+### M
+
+- MATCH    
+- MAXROWS  
+- MINROWS  
+- MINUS    
+- MNODES   
+- MODIFY   
+- MODULES  
+
+### N
+
+- NE     
+- NONE   
+- NOT    
+- NOTNULL
+- NOW    
+- NULL
+
+### O
+
+- OF    
+- OFFSET
+- OR    
+- ORDER 
+
+### P
+
+- PARTITION
+- PASS     
+- PLUS     
+- PPS      
+- PRECISION
+- PREV     
+- PRIVILEGE
+
+### Q
+
+- QTIME 
+- QUERIE
+- QUERY 
+- QUORUM
+
+### R
+
+- RAISE  
+- REM    
+- REPLACE
+- REPLICA
+- RESET  
+- RESTRIC
+- ROW    
+- RP     
+- RSHIFT
+
+### S
+
+- SCORES 
+- SELECT 
+- SEMI   
+- SESSION
+- SET    
+- SHOW   
+- SLASH  
+- SLIDING
+- SLIMIT 
+- SMALLIN
+- SOFFSET
+- STable 
+- STableS
+- STAR    
+- STATE   
+- STATEMEN
+- STATE_WI
+- STORAGE 
+- STREAM  
+- STREAMS 
+- STRING  
+- SYNCDB  
+
+### T
+
+- TABLE     
+- TABLES    
+- TAG       
+- TAGS      
+- TBNAME    
+- TIMES     
+- TIMESTAMP 
+- TINYINT   
+- TOPIC     
+- TOPICS    
+- TRIGGER   
+- TSERIES   
+
+### U
+
+- UMINUS   
+- UNION    
+- UNSIGNED 
+- UPDATE   
+- UPLUS    
+- USE      
+- USER     
+- USERS    
+- USING  
+
+### V
+
+- VALUES   
+- VARIABLE 
+- VARIABLES
+- VGROUPS  
+- VIEW     
+- VNODES   
+
+### W
+
+- WAL
+- WHERE
+
+### _
+
+- _C0
+- _QSTART
+- _QSTOP
+- _QDURATION
+- _WSTART
+- _WSTOP
+- _WDURATION
+
+## Explanations
+### TBNAME
+`TBNAME` can be considered as a special tag, which represents the name of the subtable, in STable.
+
+Get the table name and tag values of all subtables in a STable.
+```mysql
+SELECT TBNAME, location FROM meters;
+
+Count the number of subtables in a STable.
+```mysql
+SELECT COUNT(TBNAME) FROM meters;
+```
+
+Only filter on TAGS can be used in WHERE clause in the above two query statements.
+```mysql
+taos> SELECT TBNAME, location FROM meters;
+             tbname             |            location            |
+==================================================================
+ d1004                          | California.SanFrancisco        |
+ d1003                          | California.SanFrancisco        |
+ d1002                          | California.LosAngeles          |
+ d1001                          | California.LosAngeles          |
+Query OK, 4 row(s) in set (0.000881s)
+
+taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
+     count(tbname)     |
+========================
+                     2 |
+Query OK, 1 row(s) in set (0.001091s)
+```
+### _QSTART/_QSTOP/_QDURATION
+The start, stop and duration of a query time window (Since version 2.6.0.0).
+
+### _WSTART/_WSTOP/_WDURATION
+The start, stop and duration of aggegate query by time window, like interval, session window, state window (Since version 2.6.0.0).
+
+### _c0
+The first column of a table or STable.

docs/en/06-taos-sql/_category_.yml

+label: TDengine SQL

docs/en/06-taos-sql/index.md

+---
+title: TDengine SQL
+description: "The syntax supported by TDengine SQL "
+---
+
+This section explains the syntax of SQL to perform operations on databases, tables and STables, insert data, select data and use functions. We also provide some tips that can be used in TDengine SQL. If you have previous experience with SQL this section will be fairly easy to understand. If you do not have previous experience with SQL, you'll come to appreciate the simplicity and power of SQL.
+
+TDengine SQL is the major interface for users to write data into or query from TDengine. For ease of use, the syntax is similar to that of standard SQL. However, please note that TDengine SQL is not standard SQL. For instance, TDengine doesn't provide a delete function for time series data and so corresponding statements are not provided in TDengine SQL.
+
+Syntax Specifications used in this chapter:
+
+- The content inside <\> needs to be input by the user, excluding <\> itself.
+- \[ \] means optional input, excluding [] itself.
+- | means one of a few options, excluding | itself.
+- … means the item prior to it can be repeated multiple times.
+
+To better demonstrate the syntax, usage and rules of TAOS SQL, hereinafter it's assumed that there is a data set of data from electric meters. Each meter collects 3 data measurements: current, voltage, phase. The data model is shown below:
+
+```sql
+taos> DESCRIBE meters;
+             Field              |        Type        |   Length    |    Note    |
+=================================================================================
+ ts                             | TIMESTAMP          |           8 |            |
+ current                        | FLOAT              |           4 |            |
+ voltage                        | INT                |           4 |            |
+ phase                          | FLOAT              |           4 |            |
+ location                       | BINARY             |          64 | TAG        |
+ groupid                        | INT                |           4 | TAG        |
+```
+
+The data set includes the data collected by 4 meters, the corresponding table name is d1001, d1002, d1003 and d1004 based on the data model of TDengine.