[iotdb] branch master updated: [IOTDB-1620] Support backtick (`) character and double quotes (") to quote identifiers (#4243)

[jackietien]

This is an automated email from the ASF dual-hosted git repository.

jackietien pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/iotdb.git


The following commit(s) were added to refs/heads/master by this push:
     new b5ef4d8  [IOTDB-1620] Support backtick (`) character and double quotes 
(") to quote identifiers (#4243)
b5ef4d8 is described below

commit b5ef4d8bb5e1082ff55345cdb5e728fd1a7c2fc9
Author: Steve Yurong Su <r...@apache.org>
AuthorDate: Fri Oct 29 16:42:24 2021 +0800

    [IOTDB-1620] Support backtick (`) character and double quotes (") to quote 
identifiers (#4243)
---
 .github/dependabot.yml                             |   8 +-
 .gitignore                                         |   5 +
 .../org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4    |  68 ++----
 .../org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4   |  25 ---
 .../Data-Concept/Data-Model-and-Terminology.md     |  70 ++++---
 .../IoTDB-SQL-Language/Syntax-Conventions.md       | 115 ++++++++++
 .../System-Tools/Monitor-and-Log-Tools.md          |   2 +-
 .../Data-Concept/Data-Model-and-Terminology.md     |  69 +++---
 .../IoTDB-SQL-Language/Syntax-Conventions.md       | 116 ++++++++++
 .../System-Tools/Monitor-and-Log-Tools.md          |  10 +-
 .../java/org/apache/iotdb/db/conf/IoTDBConfig.java |   5 +-
 .../iotdb/db/metadata/utils/MetaFormatUtils.java   |   2 +-
 .../apache/iotdb/db/metadata/utils/MetaUtils.java  |  25 +--
 .../org/apache/iotdb/db/monitor/StatMonitor.java   |   2 +-
 .../apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java    | 233 +++++++++++++--------
 .../iotdb/db/integration/IoTDBArithmeticIT.java    |   7 +-
 .../db/integration/IoTDBCreateStorageGroupIT.java  |   2 +-
 .../iotdb/db/integration/IoTDBDeletionIT.java      |  16 +-
 .../iotdb/db/integration/IoTDBQuotedPathIT.java    |  35 ++--
 .../iotdb/db/integration/IoTDBSimpleQueryIT.java   |   2 +-
 .../db/integration/IoTDBTriggerExecutionIT.java    | 160 +++++++-------
 .../db/integration/IoTDBTriggerManagementIT.java   | 172 +++++++--------
 .../db/integration/auth/IoTDBAuthorizationIT.java  |  12 +-
 .../iotdb/db/metadata/MManagerBasicTest.java       |   6 +-
 .../apache/iotdb/db/metadata/MetaUtilsTest.java    |  30 +--
 .../iotdb/db/monitor/IoTDBStatMonitorTest.java     |   4 +-
 .../java/org/apache/iotdb/db/qp/PlannerTest.java   |   4 +-
 .../iotdb/db/qp/physical/PhysicalPlanTest.java     |   6 +-
 .../iotdb/db/query/dataset/ListDataSetTest.java    |   2 +-
 .../iotdb/db/query/dataset/SingleDataSetTest.java  |   2 +-
 .../dataset/groupby/GroupByLevelDataSetTest.java   |   9 +-
 .../dataset/groupby/GroupByTimeDataSetTest.java    |   9 +-
 .../iotdb/session/IoTDBSessionComplexIT.java       |   8 +-
 site/src/main/.vuepress/config.js                  |   4 +
 34 files changed, 725 insertions(+), 520 deletions(-)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 0cd49be..130248e 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -25,7 +25,7 @@ updates:
     target-branch: "master"
     ignore:
       - dependency-name: "*"
-      - update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
+        update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
     labels:
       - "master"
       - "dependencies"
@@ -38,7 +38,7 @@ updates:
     target-branch: "rel/0.12"
     ignore:
       - dependency-name: "*"
-      - update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
+        update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
     labels:
       - "0.12"
       - "dependencies"
@@ -51,7 +51,7 @@ updates:
     target-branch: "master"
     ignore:
       - dependency-name: "*"
-      - update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
+        update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
     labels:
       - "master"
       - "dependencies"
@@ -64,7 +64,7 @@ updates:
     target-branch: "rel/0.12"
     ignore:
       - dependency-name: "*"
-      - update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
+        update-types: [ "version-update:semver-major", 
"version-update:semver-minor" ]
     labels:
       - "0.12"
       - "dependencies"
diff --git a/.gitignore b/.gitignore
index 757a55b..31c481f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -108,3 +108,8 @@ node3/
 
 # Exclude copied license
 /client-py/LICENSE
+
+# ANTLR
+antlr/gen/
+antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/gen/
+antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.tokens
diff --git a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4 
b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4
index dc1a8ee..5dcf809 100644
--- a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4
+++ b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4
@@ -25,7 +25,7 @@ lexer grammar IoTDBSqlLexer;
 
 WS
     :
-    [ \t\r\n]+ -> skip
+    [ \u000B\t\r\n]+ -> skip
     ;
 
 
@@ -840,25 +840,9 @@ RS_BRACKET : ']';
 // String Literal
 
 STRING_LITERAL
-    : SQUOTE_STRING
+    : '\'' ((~'\'') | '\'\'')* '\''
     ;
 
-QUOTED_STRING_LITERAL
-    : DQUOTE_STRING
-    | BQUOTE_STRING
-    ;
-
-fragment DQUOTE_STRING
-    : '"' ('\\' . | ~'"' )*? '"'
-    ;
-
-fragment SQUOTE_STRING
-    : '\'' ('\\' . | ~'\'' )*? '\''
-    ;
-
-fragment BQUOTE_STRING
-    : '`' ('\\' . | ~'`' )*? '`'
-    ;
 
 // Date & Time Literal
 
@@ -913,43 +897,23 @@ NAN_LITERAL
  */
 
 ID
-    : FIRST_NAME_CHAR NAME_CHAR*
+    : NAME_CHAR+
+    | '"' (~('"' | '.') | '""')+ '"'
+    | '`' (~('`' | '.') | '``')+ '`'
     ;
 
 fragment NAME_CHAR
-    :   'A'..'Z'
-    |   'a'..'z'
-    |   '0'..'9'
-    |   '_'
-    |   '-'
-    |   ':'
-    |   '/'
-    |   '@'
-    |   '#'
-    |   '$'
-    |   '%'
-    |   '&'
-    |   '+'
-    |   '{'
-    |   '}'
-    |   CN_CHAR
-    ;
-
-fragment FIRST_NAME_CHAR
-    :   'A'..'Z'
-    |   'a'..'z'
-    |   '0'..'9'
-    |   '_'
-    |   '/'
-    |   '@'
-    |   '#'
-    |   '$'
-    |   '%'
-    |   '&'
-    |   '+'
-    |   '{'
-    |   '}'
-    |   CN_CHAR
+    : 'A'..'Z'
+    | 'a'..'z'
+    | '0'..'9'
+    | '_'
+    | ':'
+    | '@'
+    | '#'
+    | '$'
+    | '{'
+    | '}'
+    | CN_CHAR
     ;
 
 fragment CN_CHAR
diff --git a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4 
b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4
index b7043c9..b1b241b 100644
--- a/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4
+++ b/antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4
@@ -404,7 +404,6 @@ insertMultiValue
 
 measurementName
     : nodeNameWithoutWildcard
-    | LR_BRACKET nodeNameWithoutWildcard (COMMA nodeNameWithoutWildcard)+ 
RR_BRACKET
     ;
 
 measurementValue
@@ -662,16 +661,10 @@ suffixPath
 nodeName
     : wildcard? ID wildcard?
     | wildcard
-    | (ID | OPERATOR_IN)? LS_BRACKET INTEGER_LITERAL? ID? RS_BRACKET? ID?
-    | literalCanBeNodeName
-    | keywordsCanBeNodeName
     ;
 
 nodeNameWithoutWildcard
     : ID
-    | (ID | OPERATOR_IN)? LS_BRACKET INTEGER_LITERAL? ID? RS_BRACKET? ID?
-    | literalCanBeNodeName
-    | keywordsCanBeNodeName
     ;
 
 wildcard
@@ -679,24 +672,6 @@ wildcard
     | DOUBLE_STAR
     ;
 
-literalCanBeNodeName
-    : QUOTED_STRING_LITERAL
-    | datetimeLiteral
-    | DURATION_LITERAL
-    | (MINUS|PLUS)? INTEGER_LITERAL
-    | (MINUS|PLUS)? EXPONENT_NUM_PART
-    | BOOLEAN_LITERAL
-    ;
-
-keywordsCanBeNodeName
-    : DATATYPE_VALUE
-    | ENCODING_VALUE
-    | COMPRESSOR_VALUE
-    | ASC
-    | DESC
-    | DEVICE
-    ;
-
 
 // Constant & Literal
 
diff --git a/docs/UserGuide/Data-Concept/Data-Model-and-Terminology.md 
b/docs/UserGuide/Data-Concept/Data-Model-and-Terminology.md
index 96ca3fe..5ee4e12 100644
--- a/docs/UserGuide/Data-Concept/Data-Model-and-Terminology.md
+++ b/docs/UserGuide/Data-Concept/Data-Model-and-Terminology.md
@@ -33,21 +33,21 @@ Here are the basic concepts of the model involved in IoTDB.
 
 ### Measurement, Entity, Storage Group, Path
 
-* Measurement (Also called field)
+#### Measurement (Also called field)
 
 **Univariable or multi-variable measurement**. It is information measured by a 
detection equipment in an actual scene, and can transform the sensed 
information into an electrical signal or other desired form of information 
output and send it to IoTDB.  In IoTDB, all data and paths stored are organized 
in units of measuements.
 
-* Sub-measurement
+#### Sub-measurement
 
 In multi-variable measurements, there are many sub-measurement. For example, 
GPS is a multi-variable measurements, including three sub-measurement: 
longitude, dimension and altitude. Multi-variable measurements are usually 
collected at the same time and share time series.
 
 The univariable measurement overlaps the sub-measurement name with the 
measurement name. For example, temperature is a univariable measurement.
 
-* Entity (Also called device)
+#### Entity (Also called device)
 
 **An entity** is an equipped with measurements in real scenarios. In IoTDB, 
all measurements should have their corresponding entities.
 
-* Storage Group
+#### Storage Group
 
 **A group of entities.** Users can set any prefix path as a storage group. 
Provided that there are four timeseries `root.ln.wf01.wt01.status`, 
`root.ln.wf01.wt01.temperature`, `root.ln.wf02.wt02.hardware`, 
`root.ln.wf02.wt02.status`, two devices `wt01`, `wt02` under the path `root.ln` 
may belong to the same owner or the same manufacturer, so d1 and d2 are closely 
related. At this point, the prefix path root.vehicle can be designated as a 
storage group, which will enable IoTDB to store al [...]
 
@@ -61,38 +61,46 @@ After a storage group is set, the ancestral layers, 
children and descendant laye
 
 The Layer Name of storage group can only consist of characters, numbers, 
underscores and hyphen, like `root.storagegroup_1-sg1`.
 
-* Path
-
-In IoTDB, a path is an expression that conforms to the following constraints:
-
-```
-path: LayerName (DOT LayerName)+
-LayerName: Identifier | STAR
+#### Path
+
+A `path` is an expression that conforms to the following constraints:
+
+```sql
+path       
+    : layer_name ('.' layer_name)*
+    ;
+layer_name
+    : wildcard? id wildcard?
+    | wildcard
+    ;
+wildcard 
+    : '*' 
+    | '**'
+    ;
 ```
 
-Among them, STAR is `*` or `**` and DOT is `.`.
+You can refer to the definition of `id` in 
[Syntax-Conventions](../IoTDB-SQL-Language/Syntax-Conventions.md).
 
-We call the middle part of a path between two "." as a layer, and thus 
`root.A.B.C` is a path with four layers. 
+We call the part of a path divided by `'.'` as a layer (`layer_name`). For 
example: `root.a.b.c` is a path with 4 layers.
 
-It is worth noting that in the path, root is a reserved character, which is 
only allowed to appear at the beginning of the time series mentioned below. If 
root appears in other layers, it cannot be parsed and an error is reported.
+The following are the constraints on the layer (`layer_name`):
 
-Single quotes are not allowed in the path. If you want to use special 
characters such as "." in LayerName, use double quotes. For example, 
`root.sg."d.1"."s.1"`. 
+* `root` is a reserved character, and it is only allowed to appear at the 
beginning layer of the time series mentioned below. If `root` appears in other 
layers, it cannot be parsed and an error will be reported.
 
-The characters supported in LayerName without double quotes are as below:
+* Except for the beginning layer (`root`) of the time series, the characters 
supported in other layers are as follows:
 
-* Chinese characters '\u2E80' to '\u9FFF'
-* '+', '&', '%', '$', '#', '@', '/', '_', '-', ':'
-* 'A' to 'Z', 'a' to 'z', '0' to '9'
-* '[', ']' (eg. 's[1', 's[1]', s[ab]')
+  * Chinese characters:  `"\u2E80"` to `"\u9FFF"`
+  * `"_"，"@"，"#"，"$"`
+  * `"A"` to `"Z"`, `"a"` to `"z"`, `"0"` to `"9"`
 
-'-' and ':' cannot be the first character. '+' cannot use alone.
+* In addition to the beginning layer (`root`) of the time series and the 
storage group layer, other layers also support the use of special strings 
referenced by \` or `" ` as its name. It should be noted that the quoted string 
cannot contain `.` characters. Here are some legal examples:
 
-> Note: the LayerName of storage group can only be characters, numbers, 
underscores and hyphen. 
->
-> Besides, if deploy on Windows system, the LayerName is case-insensitive, 
which means it's not allowed to set storage groups `root.ln` and `root.LN` at 
the same time.
+  * root.sg."select"."+-from="."where""where"""."\$", which contains 6 layers: 
root, sg, select, +-from, where"where", \$
+  * root.sg.\`\`\`\`.\`select\`.\`+="from"\`.\`\$\`, which contains 6 layers: 
root, sg, \`, select, +-"from", \$
 
+* In particular, if the system is deployed on a Windows machine, the storage 
group layer name will be case-insensitive. For example, creating both `root.ln` 
and `root.LN` at the same time is not allowed.
 
-* Path Pattern
+#### Path Pattern
 
 In order to make it easier and faster to express multiple timeseries paths, 
IoTDB provides users with the path pattern. Users can construct a path pattern 
by using wildcard `*` and `**`. Wildcard can appear in any layer of the path. 
 
@@ -105,18 +113,17 @@ In order to make it easier and faster to express multiple 
timeseries paths, IoTD
 
 ### Timeseries
 
-* Data point
+#### Data point
 
 **A "time-value" pair**.
 
-* Timeseries (A measurement of an entity corresponds to a timeseries. Also 
called meter, timeline, and tag, parameter in real time database)
+#### Timeseries (A measurement of an entity corresponds to a timeseries. Also 
called meter, timeline, and tag, parameter in real time database)
 
 **The record of a measurement of an entity on the time axis.** Timeseries is a 
series of data points.
 
 For example, if entity wt01 in power plant wf01 of power group ln has a 
measurement named status, its timeseries  can be expressed as: 
`root.ln.wf01.wt01.status`.
 
-
-* Multi-variable timeseries (Also called aligned timeseries, from v0.13)
+#### Multi-variable timeseries (Also called aligned timeseries, from v0.13)
 
 A multi-variable measurements of an entity corresponds to a multi-variable 
timeseries. These timeseries are called **multi-variable timeseries**, also 
called **aligned timeseries**.
 
@@ -128,7 +135,7 @@ By using multi-variable timeseries, the timestamp columns 
of a group of multi-va
 
 In the following chapters of data definition language, data operation language 
and Java Native Interface, various operations related to multi-variable 
timeseries will be introduced one by one.
 
-* Timestamp
+#### Timestamp
 
 The timestamp is the time point at which data is produced. It includes 
absolute timestamps and relative timestamps. For detailed description, please 
go to Data Type doc.
 
@@ -136,8 +143,7 @@ The timestamp is the time point at which data is produced. 
It includes absolute
 
 ### Measurement Template
 
-
-* Measurement template (From v0.13)
+#### Measurement template (From v0.13)
 
 In the actual scenario, many entities collect the same measurements, that is, 
they have the same measurements name and type. A **measurement template** can 
be declared to define the collectable measurements set. Measurement template 
helps save memory by implementing schema sharing. For detailed description, 
please refer to Measurement Template doc.
 
diff --git a/docs/UserGuide/IoTDB-SQL-Language/Syntax-Conventions.md 
b/docs/UserGuide/IoTDB-SQL-Language/Syntax-Conventions.md
new file mode 100644
index 0000000..55fd9fd
--- /dev/null
+++ b/docs/UserGuide/IoTDB-SQL-Language/Syntax-Conventions.md
@@ -0,0 +1,115 @@
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+    
+        http://www.apache.org/licenses/LICENSE-2.0
+    
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+-->
+
+# Syntax Conventions
+
+## Double-quotes (\") & Backquotes (\`)
+
+Strings quoted in double-quotes and backquotes are interpreted as identifiers 
(ID), and the quoted strings generally contain special characters. It should be 
noted that the quoted strings cannot contain `.` characters.
+
+The definition of identifier (ID) is:
+
+```sql
+ID
+    : NAME_CHAR+
+    | '"' (~('"' | '.') | '""')+ '"'
+    | '`' (~('`' | '.') | '``')+ '`'
+    ;
+
+fragment NAME_CHAR
+    : 'A'..'Z'
+    | 'a'..'z'
+    | '0'..'9'
+    | '_'
+    | ':'
+    | '@'
+    | '#'
+    | '$'
+    | '{'
+    | '}'
+    | CN_CHAR
+    ;
+
+fragment CN_CHAR
+    : '\u2E80'..'\u9FFF'
+    ;
+```
+
+Usages of identifiers:
+
+* The names of `TRIGGER`, `FUNCTION`(UDF), `CONTINUOUS QUERY`, `USER`, `ROLE`, 
etc.
+* In time series paths: In addition to the beginning level of the time series 
(`root`) and the storage group level, other levels also support strings quoted 
by  \` or `" ` as their names.
+
+Examples:
+
+```sql
+CREATE FUNCTION "udfname:""actual-name""" AS 
'org.apache.iotdb.db.query.udf.example.Counter'
+# "udfname:""actual-name""" will be parsed as udfname:"actual-name"
+
+CREATE FUNCTION `udfname:actual-name` AS 
'org.apache.iotdb.db.query.udf.example.Counter'
+# `udfname:actual-name` will be parsed as udfname:actual-name
+
+CREATE TIMESERIES root.a.b.`s1+s2/s3`.c WITH DATATYPE=INT32,ENCODING=RLE
+# root.a.b.`s1+s2/s3`.c will be parsed as root.a.b.s1+s2/s3.c
+```
+
+
+
+## Single-quotes (\')
+
+The literal value of a string can only be represented by a string quoted by 
`'` characters.
+
+The definition of string literal (`STRING_LITERAL`) is:
+
+```sql
+STRING_LITERAL
+    : '\'' ((~'\'') | '\'\'')* '\''
+    ;
+```
+
+Usages of string literals:
+
+* Values of  `TEXT` type data in `INSERT` or `SELECT` statements
+* Full Java class names in UDF and trigger management statements
+* Attribute fields (including attribute keys and attribute values) in UDF / 
trigger execution or management statements
+* File paths in `LOAD` / `REMOVE` / `SETTLE` statements
+* Password fields in user management statements
+
+Examples:
+
+```sql
+SELECT `my-udf`(s1, s2, 'key'='value') FROM root.sg.d;
+
+CREATE TRIGGER trigger_name BEFORE INSERT ON root.a.b.`s1+s2/s3`.c AS 
'org.apache.iotdb.db.engine.trigger.example.Counter'
+
+CREATE USER `my-%+-*/user&name` 'my-pass''word'''
+# The password is my-pass'word'
+```
+
+
+
+## Learn More
+
+Please read the lexical and grammar description files in our code repository:
+
+Lexical file: 
`antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4`
+
+Grammer file: 
`antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4`
\ No newline at end of file
diff --git a/docs/UserGuide/System-Tools/Monitor-and-Log-Tools.md 
b/docs/UserGuide/System-Tools/Monitor-and-Log-Tools.md
index 3c70de4..33865a5 100644
--- a/docs/UserGuide/System-Tools/Monitor-and-Log-Tools.md
+++ b/docs/UserGuide/System-Tools/Monitor-and-Log-Tools.md
@@ -96,7 +96,7 @@ Here are the writing data statistics (the range supported is 
shown in brackets):
 |Name| TOTAL\_POINTS |
 |:---:|:---|
 |Description| Calculate the total number of global writing points. |
-|Timeseries Name| root.stats.{"global" \|"storageGroupName"}.TOTAL\_POINTS |
+|Timeseries Name| 
root.stats."global".TOTAL_POINTS<br/>root.stats."{storageGroupName}".TOTAL_POINTS<br/>where
 storageGroupName equals to `the-actual-sg-name.replace('.', '#')`<br/>For 
example, the total write points of the storage group `root.sg` is recorded in 
root.stats."root#sg".TOTAL_POINTS |
 
 * TOTAL\_REQ\_SUCCESS (GLOBAL)
 
diff --git a/docs/zh/UserGuide/Data-Concept/Data-Model-and-Terminology.md 
b/docs/zh/UserGuide/Data-Concept/Data-Model-and-Terminology.md
index 8c2658f..f29062b 100644
--- a/docs/zh/UserGuide/Data-Concept/Data-Model-and-Terminology.md
+++ b/docs/zh/UserGuide/Data-Concept/Data-Model-and-Terminology.md
@@ -33,21 +33,21 @@ IoTDB 模型结构涉及的基本概念在下文将做详细叙述。
 
 ### 物理量、实体、存储组、路径
 
-* 物理量（Measurement，也称工况、字段 field）
+#### 物理量（Measurement，也称工况、字段 field）
 
 **一元或多元物理量**，是在实际场景中检测装置所记录的测量信息，且可以按一定规律变换成为电信号或其他所需形式的信息输出并发送给 IoTDB。在 IoTDB 
当中，存储的所有数据及路径，都是以物理量为单位进行组织。
 
-* 物理分量（SubMeasurement、分量）
+#### 物理分量（SubMeasurement、分量）
 
 在多元物理量中，包括多个分量。如 GPS 是一个多元物理量，包含 3 个分量：经度、维度、海拔。多元物理量通常被同时采集，共享时间列。
 
 一元物理量则将分量名和物理量名字重合。如温度是一个一元物理量。
 
-* 实体（Entity，也称设备，device）
+#### 实体（Entity，也称设备，device）
 
 **一个物理实体**，是在实际场景中拥有物理量的设备或装置。在 IoTDB 当中，所有的物理量都有其对应的归属实体。
 
-* 存储组（Storage group）
+#### 存储组（Storage group）
 
 **一组物理实体**，用户可以将任意前缀路径设置成存储组。如有 4 条时间序列`root.ln.wf01.wt01.status`, 
`root.ln.wf01.wt01.temperature`, `root.ln.wf02.wt02.hardware`, 
`root.ln.wf02.wt02.status`，路径`root.ln`下的两个实体 `wt01`, 
`wt02`可能属于同一个业主，或者同一个制造商，这时候就可以将前缀路径`root.ln`指定为一个存储组。未来`root.ln`下增加了新的实体，也将属于该存储组。
 
@@ -63,35 +63,44 @@ IoTDB 模型结构涉及的基本概念在下文将做详细叙述。
 
 存储组节点名只支持中英文字符、数字、下划线和中划线的组合。例如`root. 存储组_1-组1` 。
 
-* 路径（Path）
-
-在 IoTDB 中，路径是指符合以下约束的表达式：
-
+#### 路径（Path）
+
+路径（`path`）是指符合以下约束的表达式：
+
+```sql
+path       
+    : layer_name ('.' layer_name)*
+    ;
+layer_name
+    : wildcard? id wildcard?
+    | wildcard
+    ;
+wildcard 
+    : '*' 
+    | '**'
+    ;
 ```
-path: LayerName (DOT LayerName)+
-LayerName: Identifier | STAR
-```
-
-其中 STAR 为 `*` 或 `**`，DOT 为 `.`。
 
-我们称一个路径中在两个“.”中间的部分叫做一个层级，则`root.a.b.c`为一个层级为 4 的路径。
+其中，对 `id` 的定义可以参考[语法约定](../IoTDB-SQL-Language/Syntax-Conventions.md)。
 
-值得说明的是，在路径中，root 为一个保留字符，它只允许出现在下文提到的时间序列的开头，若其他层级出现 root，则无法解析，提示报错。
+我们称一个路径中由 `'.'` 分割的部分叫做层级（`layer_name`）。例如：`root.a.b.c`为一个层级为 4 的路径。
 
-在路径中，不允许使用单引号。如果你想在 LayerName 
中使用`.`等特殊字符，请使用双引号。例如，`root.sg."d.1"."s.1"`。双引号内支持使用转义符进行双引号的嵌套，如 
`root.sg.d1."s.\"t\"1"`。
+下面是对层级（`layer_name`）的约束：
 
-除了 storage group 存储组，其他的 LayerName 中不用加双引号就支持的字符如下：
+* `root` 作为一个保留字符，它只允许出现在下文提到的时间序列的开头，若其他层级出现 `root`，则无法解析，提示报错。
 
-* 中文字符"\u2E80"到"\u9FFF"
-* "+"，"&"，"%"，"$"，"#"，"@"，"/"，"_"，"-"，":"
-* "A"到"Z"，"a"到"z"，"0"到"9"
+* 除了时间序列的开头的层级（`root`）外，其他的层级支持的字符如下：
+  * 中文字符`"\u2E80"`到`"\u9FFF"`
+  * `"_"，"@"，"#"，"$"`
+  * `"A"`到`"Z"`，`"a"`到`"z"`，`"0"`到`"9"`
+* 除了时间序列的开头的层级（`root`）和存储组层级外，层级还支持使用被  \`  或者 ` " ` 
符号引用的特殊字符串作为其名称。需要注意的是，被引用的字符串不可带有 `.` 字符。下面是一些合法的例子：
+  * root.sg."select"."+-from="."where""where"""."\$"，6 个层级分别为 root, sg, 
select, +-from, where"where", \$
+  * root.sg.\`\`\`\`.\`select\`.\`+="from"\`.\`\$\`，6 个层级分别为 root, sg, \`, 
select, +-"from", \$
 
-其中'-' 和 ':' 不能放置在第一位，不能使用单个 '+'。
+* 特别地，如果系统在 Windows 系统上部署，那么存储组层级名称是大小写不敏感的。例如，同时创建`root.ln` 和 `root.LN` 
是不被允许的。
 
-> 注意：storage group 中的 LayerName 只支持数字，字母，汉字，下划线和中划线。另外，如果在 Windows 
系统上部署，存储组层级名称是大小写不敏感的。例如同时创建`root.ln` 和 `root.LN` 是不被允许的。
+#### 路径模式（Path Pattern）
 
-* 路径模式（Path Pattern）
-  
 为了使得在表达多个时间序列的时候更加方便快捷，IoTDB 
为用户提供带通配符`*`或`**`的路径。用户可以利用两种通配符构造出期望的路径模式。通配符可以出现在路径中的任何层。
 
 
`*`在路径中表示一层。例如`root.vehicle.*.sensor1`代表的是以`root.vehicle`为前缀，以`sensor1`为后缀，层次等于 
4 层的路径。
@@ -103,21 +112,21 @@ LayerName: Identifier | STAR
 
 ### 一元、多元时间序列
 
-* 数据点（Data point）
+#### 数据点（Data point）
 
 **一个“时间-值”对**。
 
-* 时间序列（一个实体的某个物理量对应一个时间序列，Timeseries，也称测点 meter、时间线 timeline，实时数据库中常被称作标签 
tag、参数 parameter）
+#### 时间序列（一个实体的某个物理量对应一个时间序列，Timeseries，也称测点 meter、时间线 timeline，实时数据库中常被称作标签 
tag、参数 parameter）
 
 **一个物理实体的某个物理量在时间轴上的记录**，是数据点的序列。
 
 例如，ln 电力集团、wf01 风电场的实体 wt01 有名为 status 
的物理量，则它的时间序列可以表示为：`root.ln.wf01.wt01.status`。 
 
-* 一元时间序列（single-variable timeseries 或 timeseries，v0.1 起支持）
+#### 一元时间序列（single-variable timeseries 或 timeseries，v0.1 起支持）
 
 一个实体的一个一元物理量对应一个一元时间序列。实体+物理量=时间序列
 
-* 多元时间序列（Multi-variable timeseries 或 Aligned timeseries，v0.13 起支持）
+#### 多元时间序列（Multi-variable timeseries 或 Aligned timeseries，v0.13 起支持）
 
 一个实体的一个多元物理量对应一个多元时间序列。这些时间序列称为**多元时间序列**，也叫**对齐时间序列**。
 
@@ -129,13 +138,13 @@ LayerName: Identifier | STAR
 
 在后续数据定义语言、数据操作语言和 Java 原生接口章节，将对涉及到对齐时间序列的各种操作进行逐一介绍。
 
-* 时间戳类型
+#### 时间戳类型
 
 时间戳是一个数据到来的时间点，其中包括绝对时间戳和相对时间戳，详细描述参见数据类型文档。
 
 
 ### 物理量模板
 
-* 物理量模板（Measurement template，v0.13 起支持）
+#### 物理量模板（Measurement template，v0.13 起支持）
 
 
实际应用中有许多实体所采集的物理量相同，即具有相同的工况名称和类型，可以声明一个**物理量模板**来定义可采集的物理量集合。在实践中，物理量模板的使用可帮助减少元数据的资源占用，详细内容参见物理量模板文档。
\ No newline at end of file
diff --git a/docs/zh/UserGuide/IoTDB-SQL-Language/Syntax-Conventions.md 
b/docs/zh/UserGuide/IoTDB-SQL-Language/Syntax-Conventions.md
new file mode 100644
index 0000000..50f51da
--- /dev/null
+++ b/docs/zh/UserGuide/IoTDB-SQL-Language/Syntax-Conventions.md
@@ -0,0 +1,116 @@
+<!--
+
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+    
+        http://www.apache.org/licenses/LICENSE-2.0
+    
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+-->
+
+# 语法约定
+
+## 双引号（\"）、反引号（\`）
+
+双引号和反引号内引用的字符串被解释为标识符（ID），被引用的字符串一般包含特殊字符。需要注意的是，被引用的字符串不可带有 `.` 字符。
+
+标识符（ID）的定义为：
+
+```sql
+ID
+    : NAME_CHAR+
+    | '"' (~('"' | '.') | '""')+ '"'
+    | '`' (~('`' | '.') | '``')+ '`'
+    ;
+
+fragment NAME_CHAR
+    : 'A'..'Z'
+    | 'a'..'z'
+    | '0'..'9'
+    | '_'
+    | ':'
+    | '@'
+    | '#'
+    | '$'
+    | '{'
+    | '}'
+    | CN_CHAR
+    ;
+
+fragment CN_CHAR
+    : '\u2E80'..'\u9FFF'
+    ;
+```
+
+标志符的使用场景：
+* `TRIGGER`，`FUNCTION`(UDF)，`CONTINUOUS QUERY`，`USER`，`ROLE` 等的名字。
+* 时间序列路径的表达：除了时间序列的开头的层级（`root`）和存储组层级外，层级还支持使用被  \`  或者 ` " ` 符号引用的特殊字符串作为其名称。
+
+例子：
+
+```sql
+CREATE FUNCTION "udfname:""actual-name""" AS 
'org.apache.iotdb.db.query.udf.example.Counter'
+# "udfname:""actual-name""" 会被解析成 udfname:"actual-name"
+
+CREATE FUNCTION `udfname:actual-name` AS 
'org.apache.iotdb.db.query.udf.example.Counter'
+# `udfname:actual-name` 会被解析成 udfname:actual-name
+
+CREATE TIMESERIES root.a.b.`s1+s2/s3`.c WITH DATATYPE=INT32,ENCODING=RLE
+# root.a.b.`s1+s2/s3`.c 会被解析成 root.a.b.s1+s2/s3.c
+```
+
+
+
+## 单引号（\'）
+
+字符串字面值只能由单引号（`'`）字符包围的字符串表示。
+
+字符串字面值（`STRING_LITERAL`）的定义为：
+
+```sql
+STRING_LITERAL
+    : '\'' ((~'\'') | '\'\'')* '\''
+    ;
+```
+
+字符串字面值的使用场景：
+
+* `INSERT` 或者 `SELECT` 中用于表达 `TEXT` 类型数据的场景
+* SQL 中 UDF 和 Trigger 的 Java 类全类名
+* `CREATE TRIGGER` 语句中描述触发器属性的键值对
+* UDF 函数输入参数中的属性
+* `LOAD` / `REMOVE` / `SETTLE` 指令中的文件路径
+* 用户密码
+
+例子：
+
+```sql
+SELECT `my-udf`(s1, s2, 'key'='value') FROM root.sg.d;
+
+CREATE TRIGGER trigger_name BEFORE INSERT ON root.a.b.`s1+s2/s3`.c AS 
'org.apache.iotdb.db.engine.trigger.example.Counter'
+
+CREATE USER `my-%+-*/user&name` 'my-pass''word'''
+# 密码是 my-pass'word'
+```
+
+
+
+## 了解更多
+
+请阅读代码仓库中的词法和语法描述文件：
+
+词法文件：`antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlLexer.g4`
+
+语法文件：`antlr/src/main/antlr4/org/apache/iotdb/db/qp/sql/IoTDBSqlParser.g4`
+
diff --git a/docs/zh/UserGuide/System-Tools/Monitor-and-Log-Tools.md 
b/docs/zh/UserGuide/System-Tools/Monitor-and-Log-Tools.md
index 443b156..2238ac2 100644
--- a/docs/zh/UserGuide/System-Tools/Monitor-and-Log-Tools.md
+++ b/docs/zh/UserGuide/System-Tools/Monitor-and-Log-Tools.md
@@ -82,7 +82,7 @@ Monitor 下有几个属性，包括数据文件目录，写入数据统计信息
 | :--: | :---------------------------------------- |
 | 描述 |  成功的请求数 |
 | 类型 |     Long                               |
-  
+
 - GlobalReqFailNum
   
 | 名称 | GlobalReqFailNum                       |
@@ -122,10 +122,10 @@ Monitor 下有几个属性，包括数据文件目录，写入数据统计信息
 
 * TOTAL_POINTS （全局，存储组）
 
-|     名字     | TOTAL\_POINTS                                             |
-|:------------:|:--------------------------------------------------------- |
-|     描述     | 写入总点数                                                |
-| 时间序列名称 | root.stats.{"global" \| "storageGroupName"}.TOTAL\_POINTS |
+|     名字     | TOTAL\_POINTS                                                |
+| :----------: | :----------------------------------------------------------- |
+|     描述     | 写入总点数                                                   |
+| 时间序列名称 | root.stats."global".TOTAL\_POINTS <br 
/>root.stats."{storageGroupName}".TOTAL\_POINTS<br />其中 storageGroupName 
是将存储组中的 `.` 替换成 `#` 得到<br />例如存储组 `root.sg` 的写入总点数记录在  
root.stats."root#sg".TOTAL\_POINTS |
 
 * TOTAL\_REQ\_SUCCESS （全局）
 
diff --git a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java 
b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
index 1bcce03..5d7bd6d 100644
--- a/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
+++ b/server/src/main/java/org/apache/iotdb/db/conf/IoTDBConfig.java
@@ -56,17 +56,16 @@ public class IoTDBConfig {
 
   // e.g., a31+/$%#&[]{}3e4
   private static final String ID_MATCHER =
-      "([a-zA-Z0-9/\"[ ],:@#$%&{}()*=?!~\\[\\]\\-+\\u2E80-\\u9FFF_]+)";
+      "([a-zA-Z0-9/\"`[ ],:@#$%&{}()*=?!~\\[\\]\\-+\\u2E80-\\u9FFF_]+)";
 
   private static final String STORAGE_GROUP_MATCHER = 
"([a-zA-Z0-9_.\\-\\u2E80-\\u9FFF]+)";
 
   // e.g.,  .s1
   private static final String PARTIAL_NODE_MATCHER = "[" + PATH_SEPARATOR + 
"]" + ID_MATCHER;
 
-  // for path like: root.sg1.d1."1.2.3", root.sg.d1."1.2.3"
   // TODO : need to match the rule of antlr grammar
   private static final String NODE_MATCHER =
-      "([" + PATH_SEPARATOR + "][\"])?" + ID_MATCHER + "(" + 
PARTIAL_NODE_MATCHER + ")*([\"])?";
+      "([" + PATH_SEPARATOR + "])?" + ID_MATCHER + "(" + PARTIAL_NODE_MATCHER 
+ ")*";
 
   public static final Pattern STORAGE_GROUP_PATTERN = 
Pattern.compile(STORAGE_GROUP_MATCHER);
 
diff --git 
a/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaFormatUtils.java 
b/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaFormatUtils.java
index a6288d4..0e6e7fc 100644
--- 
a/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaFormatUtils.java
+++ 
b/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaFormatUtils.java
@@ -80,7 +80,7 @@ public class MetaFormatUtils {
 
   /** check whether the node name uses "." correctly */
   private static void checkNameFormat(String name) throws MetadataException {
-    if (name.contains(".") && !(name.startsWith("\"") && name.endsWith("\""))) 
{
+    if (name.contains(".")) {
       throw new MetadataException(String.format("%s is an illegal name.", 
name));
     }
   }
diff --git 
a/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaUtils.java 
b/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaUtils.java
index 47b4062..f37d1a3 100644
--- a/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaUtils.java
+++ b/server/src/main/java/org/apache/iotdb/db/metadata/utils/MetaUtils.java
@@ -54,33 +54,10 @@ public class MetaUtils {
         if (startIndex == path.length()) {
           throw new IllegalPathException(path);
         }
-      } else if (path.charAt(i) == '"') {
-        int endIndex = path.indexOf('"', i + 1);
-        // if a double quotes with escape character
-        while (endIndex != -1 && path.charAt(endIndex - 1) == '\\') {
-          endIndex = path.indexOf('"', endIndex + 1);
-        }
-        if (endIndex != -1 && (endIndex == path.length() - 1 || 
path.charAt(endIndex + 1) == '.')) {
-          String node = path.substring(startIndex, endIndex + 1);
-          if (node.isEmpty()) {
-            throw new IllegalPathException(path);
-          }
-          nodes.add(node);
-          i = endIndex + 1;
-          startIndex = endIndex + 2;
-        } else {
-          throw new IllegalPathException(path);
-        }
-      } else if (path.charAt(i) == '\'') {
-        throw new IllegalPathException(path);
       }
     }
     if (startIndex <= path.length() - 1) {
-      String node = path.substring(startIndex);
-      if (node.isEmpty()) {
-        throw new IllegalPathException(path);
-      }
-      nodes.add(node);
+      nodes.add(path.substring(startIndex));
     }
     return nodes.toArray(new String[0]);
   }
diff --git a/server/src/main/java/org/apache/iotdb/db/monitor/StatMonitor.java 
b/server/src/main/java/org/apache/iotdb/db/monitor/StatMonitor.java
index f8c2268..6bc3050 100644
--- a/server/src/main/java/org/apache/iotdb/db/monitor/StatMonitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/monitor/StatMonitor.java
@@ -186,7 +186,7 @@ public class StatMonitor implements StatMonitorMBean, 
IService {
 
   private PartialPath getStorageGroupMonitorSeries(String storageGroupName) {
     String[] monitorSeries = 
Arrays.copyOf(MonitorConstants.STAT_STORAGE_GROUP_ARRAY, 4);
-    monitorSeries[2] = "\"" + storageGroupName + "\"";
+    monitorSeries[2] = "\"" + storageGroupName.replace('.', '#') + "\"";
     monitorSeries[3] = StatMeasurementConstants.TOTAL_POINTS.getMeasurement();
     return new PartialPath(monitorSeries);
   }
diff --git 
a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java 
b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
index 21a39b5..88dd607 100644
--- a/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
+++ b/server/src/main/java/org/apache/iotdb/db/qp/sql/IoTDBSqlVisitor.java
@@ -50,10 +50,52 @@ import 
org.apache.iotdb.db.qp.logical.crud.SelectIntoOperator;
 import org.apache.iotdb.db.qp.logical.crud.SpecialClauseComponent;
 import org.apache.iotdb.db.qp.logical.crud.UDFQueryOperator;
 import org.apache.iotdb.db.qp.logical.crud.WhereComponent;
-import org.apache.iotdb.db.qp.logical.sys.*;
+import org.apache.iotdb.db.qp.logical.sys.AlterTimeSeriesOperator;
 import org.apache.iotdb.db.qp.logical.sys.AlterTimeSeriesOperator.AlterType;
+import org.apache.iotdb.db.qp.logical.sys.AuthorOperator;
 import org.apache.iotdb.db.qp.logical.sys.AuthorOperator.AuthorType;
+import org.apache.iotdb.db.qp.logical.sys.ClearCacheOperator;
+import org.apache.iotdb.db.qp.logical.sys.CountOperator;
+import org.apache.iotdb.db.qp.logical.sys.CreateContinuousQueryOperator;
+import org.apache.iotdb.db.qp.logical.sys.CreateFunctionOperator;
+import org.apache.iotdb.db.qp.logical.sys.CreateSnapshotOperator;
+import org.apache.iotdb.db.qp.logical.sys.CreateTimeSeriesOperator;
+import org.apache.iotdb.db.qp.logical.sys.CreateTriggerOperator;
+import org.apache.iotdb.db.qp.logical.sys.DataAuthOperator;
+import org.apache.iotdb.db.qp.logical.sys.DeletePartitionOperator;
+import org.apache.iotdb.db.qp.logical.sys.DeleteStorageGroupOperator;
+import org.apache.iotdb.db.qp.logical.sys.DeleteTimeSeriesOperator;
+import org.apache.iotdb.db.qp.logical.sys.DropContinuousQueryOperator;
+import org.apache.iotdb.db.qp.logical.sys.DropFunctionOperator;
+import org.apache.iotdb.db.qp.logical.sys.DropTriggerOperator;
+import org.apache.iotdb.db.qp.logical.sys.FlushOperator;
+import org.apache.iotdb.db.qp.logical.sys.KillQueryOperator;
+import org.apache.iotdb.db.qp.logical.sys.LoadConfigurationOperator;
 import 
org.apache.iotdb.db.qp.logical.sys.LoadConfigurationOperator.LoadConfigurationOperatorType;
+import org.apache.iotdb.db.qp.logical.sys.LoadDataOperator;
+import org.apache.iotdb.db.qp.logical.sys.LoadFilesOperator;
+import org.apache.iotdb.db.qp.logical.sys.MergeOperator;
+import org.apache.iotdb.db.qp.logical.sys.RemoveFileOperator;
+import org.apache.iotdb.db.qp.logical.sys.SetStorageGroupOperator;
+import org.apache.iotdb.db.qp.logical.sys.SetSystemModeOperator;
+import org.apache.iotdb.db.qp.logical.sys.SetTTLOperator;
+import org.apache.iotdb.db.qp.logical.sys.SettleOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowChildNodesOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowChildPathsOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowContinuousQueriesOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowDevicesOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowFunctionsOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowLockInfoOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowMergeStatusOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowStorageGroupOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowTTLOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowTimeSeriesOperator;
+import org.apache.iotdb.db.qp.logical.sys.ShowTriggersOperator;
+import org.apache.iotdb.db.qp.logical.sys.StartTriggerOperator;
+import org.apache.iotdb.db.qp.logical.sys.StopTriggerOperator;
+import org.apache.iotdb.db.qp.logical.sys.UnSetTTLOperator;
+import org.apache.iotdb.db.qp.logical.sys.UnloadFileOperator;
 import org.apache.iotdb.db.qp.utils.DatetimeUtils;
 import org.apache.iotdb.db.query.executor.fill.IFill;
 import org.apache.iotdb.db.query.executor.fill.LinearFill;
@@ -81,7 +123,15 @@ import org.antlr.v4.runtime.tree.TerminalNode;
 
 import java.io.File;
 import java.time.ZoneId;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -101,7 +151,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       "For delete statement, where clause can only contain time expressions, "
           + "value filter is not currently supported.";
 
-  // used to match "{x}", where x is a integer.
+  // used to match "{x}", where x is an integer.
   // for create-cq clause and select-into clause.
   private static final Pattern leveledPathNodePattern = 
Pattern.compile("\\$\\{\\w+}");
 
@@ -152,7 +202,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
         new CreateTimeSeriesOperator(SQLConstant.TOK_METADATA_CREATE);
     createTimeSeriesOperator.setPath(parseFullPath(ctx.fullPath()));
     if (ctx.alias() != null) {
-      createTimeSeriesOperator.setAlias(ctx.alias().ID().getText());
+      
createTimeSeriesOperator.setAlias(parseStringWithQuotes(ctx.alias().ID().getText()));
     }
     if (ctx.attributeClauses() != null) {
       parseAttributeClauses(ctx.attributeClauses(), createTimeSeriesOperator);
@@ -187,8 +237,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       props = new HashMap<>(properties.size());
       for (IoTDBSqlParser.PropertyClauseContext property : properties) {
         props.put(
-            property.ID().getText().toLowerCase(),
-            property.propertyValue().getText().toLowerCase());
+            parseStringWithQuotes(property.ID().getText().toLowerCase()),
+            
parseStringWithQuotes(property.propertyValue().getText().toLowerCase()));
       }
     }
     createTimeSeriesOperator.setCompressor(compressor);
@@ -216,8 +266,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitCreateFunction(IoTDBSqlParser.CreateFunctionContext 
ctx) {
     CreateFunctionOperator createFunctionOperator =
         new CreateFunctionOperator(SQLConstant.TOK_FUNCTION_CREATE);
-    createFunctionOperator.setUdfName(ctx.udfName.getText());
-    
createFunctionOperator.setClassName(removeStringQuote(ctx.className.getText()));
+    
createFunctionOperator.setUdfName(parseStringWithQuotes(ctx.udfName.getText()));
+    
createFunctionOperator.setClassName(parseStringWithQuotes(ctx.className.getText()));
     return createFunctionOperator;
   }
 
@@ -227,19 +277,19 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitCreateTrigger(IoTDBSqlParser.CreateTriggerContext ctx) {
     CreateTriggerOperator createTriggerOperator =
         new CreateTriggerOperator(SQLConstant.TOK_TRIGGER_CREATE);
-    createTriggerOperator.setTriggerName(ctx.triggerName.getText());
+    
createTriggerOperator.setTriggerName(parseStringWithQuotes(ctx.triggerName.getText()));
     createTriggerOperator.setEvent(
         ctx.triggerEventClause().BEFORE() != null
             ? TriggerEvent.BEFORE_INSERT
             : TriggerEvent.AFTER_INSERT);
     createTriggerOperator.setFullPath(parseFullPath(ctx.fullPath()));
-    
createTriggerOperator.setClassName(removeStringQuote(ctx.className.getText()));
+    
createTriggerOperator.setClassName(parseStringWithQuotes(ctx.className.getText()));
     if (ctx.triggerAttributeClause() != null) {
       for (IoTDBSqlParser.TriggerAttributeContext triggerAttributeContext :
           ctx.triggerAttributeClause().triggerAttribute()) {
         createTriggerOperator.addAttribute(
-            removeStringQuote(triggerAttributeContext.key.getText()),
-            removeStringQuote(triggerAttributeContext.value.getText()));
+            parseStringWithQuotes(triggerAttributeContext.key.getText()),
+            parseStringWithQuotes(triggerAttributeContext.value.getText()));
       }
     }
     return createTriggerOperator;
@@ -254,7 +304,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
 
     createContinuousQueryOperator.setQuerySql(ctx.getText());
 
-    
createContinuousQueryOperator.setContinuousQueryName(ctx.continuousQueryName.getText());
+    createContinuousQueryOperator.setContinuousQueryName(
+        parseStringWithQuotes(ctx.continuousQueryName.getText()));
 
     if (ctx.resampleClause() != null) {
       parseResampleClause(ctx.resampleClause(), createContinuousQueryOperator);
@@ -406,7 +457,9 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     // rename
     if (ctx.RENAME() != null) {
       alterTimeSeriesOperator.setAlterType(AlterType.RENAME);
-      alterMap.put(ctx.beforeName.getText(), ctx.currentName.getText());
+      alterMap.put(
+          parseStringWithQuotes(ctx.beforeName.getText()),
+          parseStringWithQuotes(ctx.currentName.getText()));
     } else if (ctx.SET() != null) {
       // set
       alterTimeSeriesOperator.setAlterType(AlterType.SET);
@@ -415,7 +468,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       // drop
       alterTimeSeriesOperator.setAlterType(AlterType.DROP);
       for (TerminalNode dropId : ctx.ID()) {
-        alterMap.put(dropId.getText(), null);
+        alterMap.put(parseStringWithQuotes(dropId.getText()), null);
       }
     } else if (ctx.TAGS() != null) {
       // add tag
@@ -444,7 +497,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public void parseAliasClause(
       IoTDBSqlParser.AliasClauseContext ctx, AlterTimeSeriesOperator 
alterTimeSeriesOperator) {
     if (alterTimeSeriesOperator != null && ctx.ID() != null) {
-      alterTimeSeriesOperator.setAlias(ctx.ID().getText());
+      
alterTimeSeriesOperator.setAlias(parseStringWithQuotes(ctx.ID().getText()));
     }
   }
 
@@ -499,7 +552,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitDropFunction(IoTDBSqlParser.DropFunctionContext ctx) {
     DropFunctionOperator dropFunctionOperator =
         new DropFunctionOperator(SQLConstant.TOK_FUNCTION_DROP);
-    dropFunctionOperator.setUdfName(ctx.udfName.getText());
+    
dropFunctionOperator.setUdfName(parseStringWithQuotes(ctx.udfName.getText()));
     return dropFunctionOperator;
   }
 
@@ -508,7 +561,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   @Override
   public Operator visitDropTrigger(IoTDBSqlParser.DropTriggerContext ctx) {
     DropTriggerOperator dropTriggerOperator = new 
DropTriggerOperator(SQLConstant.TOK_TRIGGER_DROP);
-    dropTriggerOperator.setTriggerName(ctx.triggerName.getText());
+    
dropTriggerOperator.setTriggerName(parseStringWithQuotes(ctx.triggerName.getText()));
     return dropTriggerOperator;
   }
 
@@ -518,7 +571,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitDropContinuousQuery(IoTDBSqlParser.DropContinuousQueryContext ctx) {
     DropContinuousQueryOperator dropContinuousQueryOperator =
         new DropContinuousQueryOperator(SQLConstant.TOK_CONTINUOUS_QUERY_DROP);
-    
dropContinuousQueryOperator.setContinuousQueryName(ctx.continuousQueryName.getText());
+    dropContinuousQueryOperator.setContinuousQueryName(
+        parseStringWithQuotes(ctx.continuousQueryName.getText()));
     return dropContinuousQueryOperator;
   }
 
@@ -547,7 +601,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitStartTrigger(IoTDBSqlParser.StartTriggerContext ctx) {
     StartTriggerOperator startTriggerOperator =
         new StartTriggerOperator(SQLConstant.TOK_TRIGGER_START);
-    startTriggerOperator.setTriggerName(ctx.triggerName.getText());
+    
startTriggerOperator.setTriggerName(parseStringWithQuotes(ctx.triggerName.getText()));
     return startTriggerOperator;
   }
 
@@ -556,7 +610,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   @Override
   public Operator visitStopTrigger(IoTDBSqlParser.StopTriggerContext ctx) {
     StopTriggerOperator stopTriggerOperator = new 
StopTriggerOperator(SQLConstant.TOK_TRIGGER_STOP);
-    stopTriggerOperator.setTriggerName(ctx.triggerName.getText());
+    
stopTriggerOperator.setTriggerName(parseStringWithQuotes(ctx.triggerName.getText()));
     return stopTriggerOperator;
   }
 
@@ -628,19 +682,13 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     if (ctx.containsExpression() != null) {
       operator.setContains(true);
       propertyValueContext = ctx.containsExpression().propertyValue();
-      operator.setKey(ctx.containsExpression().ID().getText());
+      
operator.setKey(parseStringWithQuotes(ctx.containsExpression().ID().getText()));
     } else {
       operator.setContains(false);
       propertyValueContext = ctx.propertyClause().propertyValue();
-      operator.setKey(ctx.propertyClause().ID().getText());
+      
operator.setKey(parseStringWithQuotes(ctx.propertyClause().ID().getText()));
     }
-    String value;
-    if (propertyValueContext.STRING_LITERAL() != null) {
-      value = removeStringQuote(propertyValueContext.getText());
-    } else {
-      value = propertyValueContext.getText();
-    }
-    operator.setValue(value);
+    operator.setValue(parseStringWithQuotes(propertyValueContext.getText()));
   }
 
   // Show Child Paths
@@ -831,7 +879,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       Matcher m = leveledPathNodePattern.matcher(intoPath.getFullPath());
       while (m.find()) {
         String param = m.group();
-        int nodeIndex = 0;
+        int nodeIndex;
         try {
           nodeIndex = Integer.parseInt(param.substring(2, param.length() - 
1).trim());
         } catch (NumberFormatException e) {
@@ -853,7 +901,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
         intoPathNodes[i] = "${" + i + "}";
       }
       for (int i = 1; i <= nodeNameWithoutStars.size(); ++i) {
-        intoPathNodes[levelLimitOfSourcePrefixPath + i] = 
nodeNameWithoutStars.get(i - 1).getText();
+        intoPathNodes[levelLimitOfSourcePrefixPath + i] =
+            parseStringWithQuotes(nodeNameWithoutStars.get(i - 1).getText());
       }
 
       intoPath = new PartialPath(intoPathNodes);
@@ -1269,11 +1318,9 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
 
   private void parseInsertColumnSpec(
       IoTDBSqlParser.InsertColumnsSpecContext ctx, InsertOperator insertOp) {
-    List<IoTDBSqlParser.MeasurementNameContext> measurementNames = 
ctx.measurementName();
     List<String> measurementList = new ArrayList<>();
-    for (IoTDBSqlParser.MeasurementNameContext measurementName : 
measurementNames) {
-      String measurement = measurementName.getText();
-      measurementList.add(measurement);
+    for (IoTDBSqlParser.MeasurementNameContext measurementName : 
ctx.measurementName()) {
+      measurementList.add(parseStringWithQuotes(measurementName.getText()));
     }
     insertOp.setMeasurementList(measurementList.toArray(new String[0]));
   }
@@ -1298,8 +1345,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       List<IoTDBSqlParser.MeasurementValueContext> values =
           insertMultiValues.get(i).measurementValue();
       for (IoTDBSqlParser.MeasurementValueContext value : values) {
-        for (IoTDBSqlParser.ConstantContext counstant : value.constant()) {
-          valueList.add(counstant.getText());
+        for (IoTDBSqlParser.ConstantContext constant : value.constant()) {
+          valueList.add(constant.getText());
         }
       }
     }
@@ -1365,8 +1412,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitCreateUser(IoTDBSqlParser.CreateUserContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_CREATE, 
AuthorOperator.AuthorType.CREATE_USER);
-    authorOperator.setUserName(ctx.ID().getText());
-    authorOperator.setPassWord(removeStringQuote(ctx.password.getText()));
+    authorOperator.setUserName(parseStringWithQuotes(ctx.ID().getText()));
+    authorOperator.setPassWord(parseStringWithQuotes(ctx.password.getText()));
     return authorOperator;
   }
 
@@ -1376,7 +1423,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitCreateRole(IoTDBSqlParser.CreateRoleContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_CREATE, 
AuthorOperator.AuthorType.CREATE_ROLE);
-    authorOperator.setRoleName(ctx.ID().getText());
+    authorOperator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     return authorOperator;
   }
 
@@ -1387,8 +1434,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     AuthorOperator authorOperator =
         new AuthorOperator(
             SQLConstant.TOK_AUTHOR_UPDATE_USER, 
AuthorOperator.AuthorType.UPDATE_USER);
-    authorOperator.setUserName(ctx.userName.getText());
-    authorOperator.setNewPassword(removeStringQuote(ctx.password.getText()));
+    authorOperator.setUserName(parseStringWithQuotes(ctx.userName.getText()));
+    
authorOperator.setNewPassword(parseStringWithQuotes(ctx.password.getText()));
     return authorOperator;
   }
 
@@ -1398,7 +1445,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitGrantUser(IoTDBSqlParser.GrantUserContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT, 
AuthorOperator.AuthorType.GRANT_USER);
-    authorOperator.setUserName(ctx.ID().getText());
+    authorOperator.setUserName(parseStringWithQuotes(ctx.ID().getText()));
     authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
     authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
     return authorOperator;
@@ -1410,7 +1457,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitGrantRole(IoTDBSqlParser.GrantRoleContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT, 
AuthorType.GRANT_ROLE);
-    authorOperator.setRoleName(ctx.ID().getText());
+    authorOperator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
     authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
     return authorOperator;
@@ -1423,8 +1470,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     AuthorOperator authorOperator =
         new AuthorOperator(
             SQLConstant.TOK_AUTHOR_GRANT, 
AuthorOperator.AuthorType.GRANT_ROLE_TO_USER);
-    authorOperator.setRoleName(ctx.roleName.getText());
-    authorOperator.setUserName(ctx.userName.getText());
+    authorOperator.setRoleName(parseStringWithQuotes(ctx.roleName.getText()));
+    authorOperator.setUserName(parseStringWithQuotes(ctx.userName.getText()));
     return authorOperator;
   }
 
@@ -1434,7 +1481,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitRevokeUser(IoTDBSqlParser.RevokeUserContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT, 
AuthorType.REVOKE_USER);
-    authorOperator.setUserName(ctx.ID().getText());
+    authorOperator.setUserName(parseStringWithQuotes(ctx.ID().getText()));
     authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
     authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
     return authorOperator;
@@ -1446,7 +1493,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitRevokeRole(IoTDBSqlParser.RevokeRoleContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT, 
AuthorType.REVOKE_ROLE);
-    authorOperator.setRoleName(ctx.ID().getText());
+    authorOperator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     authorOperator.setPrivilegeList(parsePrivilege(ctx.privileges()));
     authorOperator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
     return authorOperator;
@@ -1458,8 +1505,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitRevokeRoleFromUser(IoTDBSqlParser.RevokeRoleFromUserContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_GRANT, 
AuthorType.REVOKE_ROLE_FROM_USER);
-    authorOperator.setRoleName(ctx.roleName.getText());
-    authorOperator.setUserName(ctx.userName.getText());
+    authorOperator.setRoleName(parseStringWithQuotes(ctx.roleName.getText()));
+    authorOperator.setUserName(parseStringWithQuotes(ctx.userName.getText()));
     return authorOperator;
   }
 
@@ -1469,7 +1516,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitDropUser(IoTDBSqlParser.DropUserContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_DROP, 
AuthorOperator.AuthorType.DROP_USER);
-    authorOperator.setUserName(ctx.ID().getText());
+    authorOperator.setUserName(parseStringWithQuotes(ctx.ID().getText()));
     return authorOperator;
   }
 
@@ -1479,7 +1526,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitDropRole(IoTDBSqlParser.DropRoleContext ctx) {
     AuthorOperator authorOperator =
         new AuthorOperator(SQLConstant.TOK_AUTHOR_DROP, 
AuthorOperator.AuthorType.DROP_ROLE);
-    authorOperator.setRoleName(ctx.ID().getText());
+    authorOperator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     return authorOperator;
   }
 
@@ -1503,7 +1550,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitListPrivilegesUser(IoTDBSqlParser.ListPrivilegesUserContext ctx) {
     AuthorOperator operator =
         new AuthorOperator(SQLConstant.TOK_LIST, 
AuthorOperator.AuthorType.LIST_USER_PRIVILEGE);
-    operator.setUserName(ctx.userName.getText());
+    operator.setUserName(parseStringWithQuotes(ctx.userName.getText()));
     operator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
     return operator;
   }
@@ -1514,7 +1561,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitListPrivilegesRole(IoTDBSqlParser.ListPrivilegesRoleContext ctx) {
     AuthorOperator operator =
         new AuthorOperator(SQLConstant.TOK_LIST, 
AuthorOperator.AuthorType.LIST_ROLE_PRIVILEGE);
-    operator.setRoleName((ctx.ID().getText()));
+    operator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     operator.setNodeNameList(parsePrefixPath(ctx.prefixPath()));
     return operator;
   }
@@ -1525,7 +1572,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitListUserPrivileges(IoTDBSqlParser.ListUserPrivilegesContext ctx) {
     AuthorOperator operator =
         new AuthorOperator(SQLConstant.TOK_LIST, 
AuthorOperator.AuthorType.LIST_USER_PRIVILEGE);
-    operator.setUserName(ctx.userName.getText());
+    operator.setUserName(parseStringWithQuotes(ctx.userName.getText()));
     return operator;
   }
 
@@ -1535,7 +1582,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitListRolePrivileges(IoTDBSqlParser.ListRolePrivilegesContext ctx) {
     AuthorOperator operator =
         new AuthorOperator(SQLConstant.TOK_LIST, 
AuthorOperator.AuthorType.LIST_ROLE_PRIVILEGE);
-    operator.setRoleName(ctx.ID().getText());
+    operator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     return operator;
   }
 
@@ -1545,7 +1592,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitListAllRoleOfUser(IoTDBSqlParser.ListAllRoleOfUserContext ctx) {
     AuthorOperator operator =
         new AuthorOperator(SQLConstant.TOK_LIST, 
AuthorOperator.AuthorType.LIST_USER_ROLES);
-    operator.setUserName(ctx.userName.getText());
+    operator.setUserName(parseStringWithQuotes(ctx.userName.getText()));
     return operator;
   }
 
@@ -1555,7 +1602,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator 
visitListAllUserOfRole(IoTDBSqlParser.ListAllUserOfRoleContext ctx) {
     AuthorOperator operator =
         new AuthorOperator(SQLConstant.TOK_LIST, 
AuthorOperator.AuthorType.LIST_ROLE_USERS);
-    operator.setRoleName((ctx.ID().getText()));
+    operator.setRoleName(parseStringWithQuotes(ctx.ID().getText()));
     return operator;
   }
 
@@ -1621,7 +1668,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       settleOperator.setIsSgPath(true);
     } else {
       // TsFile Path
-      String tsFilePath = removeStringQuote(ctx.tsFilePath.getText());
+      String tsFilePath = parseStringWithQuotes(ctx.tsFilePath.getText());
       settleOperator.setTsFilePath(tsFilePath);
       settleOperator.setIsSgPath(false);
     }
@@ -1699,7 +1746,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     List<IoTDBSqlParser.UsernameWithRootContext> usernameList = 
ctx.usernameWithRoot();
     List<String> users = new ArrayList<>();
     for (IoTDBSqlParser.UsernameWithRootContext username : usernameList) {
-      users.add(username.getText());
+      users.add(parseStringWithQuotes(username.getText()));
     }
     return new DataAuthOperator(SQLConstant.TOK_GRANT_WATERMARK_EMBEDDING, 
users);
   }
@@ -1712,7 +1759,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     List<IoTDBSqlParser.UsernameWithRootContext> usernameList = 
ctx.usernameWithRoot();
     List<String> users = new ArrayList<>();
     for (IoTDBSqlParser.UsernameWithRootContext username : usernameList) {
-      users.add(username.getText());
+      users.add(parseStringWithQuotes(username.getText()));
     }
     return new DataAuthOperator(SQLConstant.TOK_REVOKE_WATERMARK_EMBEDDING, 
users);
   }
@@ -1741,10 +1788,10 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     List<IoTDBSqlParser.NodeNameContext> nodeNames = 
ctx.prefixPath().nodeName();
     sc.addTail(ctx.prefixPath().ROOT().getText());
     for (IoTDBSqlParser.NodeNameContext nodeName : nodeNames) {
-      sc.addTail(nodeName.getText());
+      sc.addTail(parseStringWithQuotes(nodeName.getText()));
     }
     return new LoadDataOperator(
-        SQLConstant.TOK_DATALOAD, removeStringQuote(csvPath), sc.toString());
+        SQLConstant.TOK_DATALOAD, parseStringWithQuotes(csvPath), 
sc.toString());
   }
 
   // Load TsFile
@@ -1753,7 +1800,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   public Operator visitLoadFile(IoTDBSqlParser.LoadFileContext ctx) {
     LoadFilesOperator loadFilesOperator =
         new LoadFilesOperator(
-            new File(removeStringQuote(ctx.fileName.getText())),
+            new File(parseStringWithQuotes(ctx.fileName.getText())),
             true,
             
IoTDBDescriptor.getInstance().getConfig().getDefaultStorageGroupLevel(),
             true);
@@ -1793,7 +1840,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
 
   @Override
   public Operator visitRemoveFile(IoTDBSqlParser.RemoveFileContext ctx) {
-    return new RemoveFileOperator(new 
File(removeStringQuote(ctx.fileName.getText())));
+    return new RemoveFileOperator(new 
File(parseStringWithQuotes(ctx.fileName.getText())));
   }
 
   // Unload TsFile
@@ -1801,8 +1848,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   @Override
   public Operator visitUnloadFile(IoTDBSqlParser.UnloadFileContext ctx) {
     return new UnloadFileOperator(
-        new File(removeStringQuote(ctx.srcFileName.getText())),
-        new File(removeStringQuote(ctx.dstFileDir.getText())));
+        new File(parseStringWithQuotes(ctx.srcFileName.getText())),
+        new File(parseStringWithQuotes(ctx.dstFileDir.getText())));
   }
 
   /** 6. Common Clauses */
@@ -1819,7 +1866,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     }
     for (IoTDBSqlParser.NodeNameWithoutWildcardContext nodeNameWithoutStar : 
nodeNamesWithoutStar) {
       i++;
-      path[i] = nodeNameWithoutStar.getText();
+      path[i] = parseStringWithQuotes(nodeNameWithoutStar.getText());
     }
     return new PartialPath(path);
   }
@@ -1829,7 +1876,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     String[] path = new String[nodeNames.size() + 1];
     path[0] = ctx.ROOT().getText();
     for (int i = 0; i < nodeNames.size(); i++) {
-      path[i + 1] = nodeNames.get(i).getText();
+      path[i + 1] = parseStringWithQuotes(nodeNames.get(i).getText());
     }
     return new PartialPath(path);
   }
@@ -1838,7 +1885,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     List<IoTDBSqlParser.NodeNameContext> nodeNames = ctx.nodeName();
     String[] path = new String[nodeNames.size()];
     for (int i = 0; i < nodeNames.size(); i++) {
-      path[i] = nodeNames.get(i).getText();
+      path[i] = parseStringWithQuotes(nodeNames.get(i).getText());
     }
     return new PartialPath(path);
   }
@@ -1973,7 +2020,7 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
 
   private Expression parseFunctionExpression(IoTDBSqlParser.ExpressionContext 
functionClause) {
     FunctionExpression functionExpression =
-        new FunctionExpression(functionClause.functionName().getText());
+        new 
FunctionExpression(parseStringWithQuotes(functionClause.functionName().getText()));
 
     // expressions
     for (IoTDBSqlParser.ExpressionContext expression : 
functionClause.expression()) {
@@ -1984,8 +2031,8 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     for (IoTDBSqlParser.FunctionAttributeContext functionAttribute :
         functionClause.functionAttribute()) {
       functionExpression.addAttribute(
-          removeStringQuote(functionAttribute.functionAttributeKey.getText()),
-          
removeStringQuote(functionAttribute.functionAttributeValue.getText()));
+          
parseStringWithQuotes(functionAttribute.functionAttributeKey.getText()),
+          
parseStringWithQuotes(functionAttribute.functionAttributeValue.getText()));
     }
 
     return functionExpression;
@@ -2220,7 +2267,9 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
   private ResultColumn parseResultColumn(IoTDBSqlParser.ResultColumnContext 
resultColumnContext) {
     return new ResultColumn(
         parseExpression(resultColumnContext.expression()),
-        resultColumnContext.AS() == null ? null : 
resultColumnContext.ID().getText());
+        resultColumnContext.AS() == null
+            ? null
+            : parseStringWithQuotes(resultColumnContext.ID().getText()));
   }
 
   // From Clause
@@ -2361,16 +2410,19 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
         || queryOp instanceof UDFQueryOperator;
   }
 
-  private String removeStringQuote(String src) {
-    if (src.charAt(0) == '\'' && src.charAt(src.length() - 1) == '\'') {
-      return src.substring(1, src.length() - 1);
-    } else if (src.charAt(0) == '\"' && src.charAt(src.length() - 1) == '\"') {
-      return src.substring(1, src.length() - 1);
-    } else if (src.charAt(0) == '`' && src.charAt(src.length() - 1) == '`') {
-      return src.substring(1, src.length() - 1);
-    } else {
-      throw new SQLParserException("error format for string with quote:" + 
src);
+  private String parseStringWithQuotes(String src) {
+    if (2 <= src.length()) {
+      if (src.charAt(0) == '\"' && src.charAt(src.length() - 1) == '\"') {
+        return src.length() == 2 ? "" : src.replace("\"\"", "\"").substring(1, 
src.length() - 1);
+      }
+      if (src.charAt(0) == '`' && src.charAt(src.length() - 1) == '`') {
+        return src.length() == 2 ? "" : src.replace("``", "`").substring(1, 
src.length() - 1);
+      }
+      if (src.charAt(0) == '\'' && src.charAt(src.length() - 1) == '\'') {
+        return src.length() == 2 ? "" : src.replace("''", "'").substring(1, 
src.length() - 1);
+      }
     }
+    return src;
   }
 
   /**
@@ -2397,11 +2449,11 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
       for (IoTDBSqlParser.PropertyClauseContext property : tagsList) {
         String value;
         if (property.propertyValue().STRING_LITERAL() != null) {
-          value = removeStringQuote(property.propertyValue().getText());
+          value = parseStringWithQuotes(property.propertyValue().getText());
         } else {
           value = property.propertyValue().getText();
         }
-        alterMap.put(property.ID().getText(), value);
+        alterMap.put(parseStringWithQuotes(property.ID().getText()), value);
       }
     }
   }
@@ -2413,12 +2465,9 @@ public class IoTDBSqlVisitor extends 
IoTDBSqlParserBaseVisitor<Operator> {
     Map<String, String> tags = new HashMap<>(property2.size());
     if (property3 != null) {
       for (IoTDBSqlParser.PropertyClauseContext property : property2) {
-        if (property.propertyValue().STRING_LITERAL() != null) {
-          value = removeStringQuote(property.propertyValue().getText());
-        } else {
-          value = property.propertyValue().getText();
-        }
-        tags.put(property.ID().getText(), value);
+        tags.put(
+            parseStringWithQuotes(property.ID().getText()),
+            parseStringWithQuotes(property.propertyValue().getText()));
       }
     }
     return tags;
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBArithmeticIT.java 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBArithmeticIT.java
index 741cef1..331aa76 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBArithmeticIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBArithmeticIT.java
@@ -137,9 +137,10 @@ public class IoTDBArithmeticIT {
 
   @Test
   public void testArithmeticBinary() {
-    try (Statement statement =
-        DriverManager.getConnection(Config.IOTDB_URL_PREFIX + 
"127.0.0.1:6667/", "root", "root")
-            .createStatement()) {
+    try (Connection connection =
+            DriverManager.getConnection(
+                Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
+        Statement statement = connection.createStatement()) {
 
       String[] operands = new String[] {"s1", "s2", "s3", "s4"};
       for (String operator : new String[] {" + ", " - ", " * ", " / ", " % "}) 
{
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBCreateStorageGroupIT.java
 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBCreateStorageGroupIT.java
index 46c788e..af5057a 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBCreateStorageGroupIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBCreateStorageGroupIT.java
@@ -122,7 +122,7 @@ public class IoTDBCreateStorageGroupIT {
     statement.execute("create storage group root.sg");
 
     try {
-      statement.execute("create storage group root.sg.device");
+      statement.execute("create storage group root.sg.`device`");
     } catch (SQLException e) {
       Assert.assertEquals(e.getMessage(), "300: root.sg has already been set 
to storage group");
     }
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBDeletionIT.java 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBDeletionIT.java
index 52fbbc9..21ea114 100644
--- a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBDeletionIT.java
+++ b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBDeletionIT.java
@@ -407,11 +407,11 @@ public class IoTDBDeletionIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "CREATE TIMESERIES root.ln.d1.\"status,01\" WITH DATATYPE=BOOLEAN, 
ENCODING=PLAIN");
-      statement.execute("INSERT INTO root.ln.d1(timestamp,\"status,01\") 
VALUES(300, true)");
-      statement.execute("INSERT INTO root.ln.d1(timestamp,\"status,01\") 
VALUES(500, false)");
+          "CREATE TIMESERIES root.ln.d1.`\"status,01\"` WITH DATATYPE=BOOLEAN, 
ENCODING=PLAIN");
+      statement.execute("INSERT INTO root.ln.d1(timestamp,`\"status,01\"`) 
VALUES(300, true)");
+      statement.execute("INSERT INTO root.ln.d1(timestamp,`\"status,01\"`) 
VALUES(500, false)");
 
-      try (ResultSet resultSet = statement.executeQuery("select \"status,01\" 
from root.ln.d1")) {
+      try (ResultSet resultSet = statement.executeQuery("select 
`\"status,01\"` from root.ln.d1")) {
         int cnt = 0;
         while (resultSet.next()) {
           cnt++;
@@ -419,9 +419,9 @@ public class IoTDBDeletionIT {
         Assert.assertEquals(2, cnt);
       }
 
-      statement.execute("DELETE FROM root.ln.d1.\"status,01\" WHERE time <= 
400");
+      statement.execute("DELETE FROM root.ln.d1.`\"status,01\"` WHERE time <= 
400");
 
-      try (ResultSet resultSet = statement.executeQuery("select \"status,01\" 
from root.ln.d1")) {
+      try (ResultSet resultSet = statement.executeQuery("select 
`\"status,01\"` from root.ln.d1")) {
         int cnt = 0;
         while (resultSet.next()) {
           cnt++;
@@ -429,9 +429,9 @@ public class IoTDBDeletionIT {
         Assert.assertEquals(1, cnt);
       }
 
-      statement.execute("DELETE FROM root.ln.d1.\"status,01\"");
+      statement.execute("DELETE FROM root.ln.d1.`\"status,01\"`");
 
-      try (ResultSet resultSet = statement.executeQuery("select \"status,01\" 
from root.ln.d1")) {
+      try (ResultSet resultSet = statement.executeQuery("select 
`\"status,01\"` from root.ln.d1")) {
         int cnt = 0;
         while (resultSet.next()) {
           cnt++;
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBQuotedPathIT.java 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBQuotedPathIT.java
index 79bd685..d9a20e8 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBQuotedPathIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBQuotedPathIT.java
@@ -63,23 +63,21 @@ public class IoTDBQuotedPathIT {
           };
       statement.execute("SET STORAGE GROUP TO root.ln");
       statement.execute(
-          "CREATE TIMESERIES root.ln.\"wf.01\".wt01.\"status.2.3\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
+          "CREATE TIMESERIES root.ln.\"wf+01\".wt01.\"status+2+3\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
       statement.execute(
-          "INSERT INTO root.ln.\"wf.01\".wt01(timestamp,\"status.2.3\") 
values(1509465600000,true)");
+          "INSERT INTO root.ln.\"wf+01\".wt01(timestamp,\"status+2+3\") 
values(1509465600000,true)");
       statement.execute(
-          "INSERT INTO root.ln.\"wf.01\".wt01(timestamp,\"status.2.3\") 
values(1509465600001,true)");
+          "INSERT INTO root.ln.\"wf+01\".wt01(timestamp,\"status+2+3\") 
values(1509465600001,true)");
       statement.execute(
-          "INSERT INTO root.ln.\"wf.01\".wt01(timestamp,\"status.2.3\") 
values(1509465600002,false)");
+          "INSERT INTO root.ln.\"wf+01\".wt01(timestamp,\"status+2+3\") 
values(1509465600002,false)");
       statement.execute(
-          "INSERT INTO root.ln.\"wf.01\".wt01(timestamp,\"status.2.3\") 
values(1509465600003,false)");
+          "INSERT INTO root.ln.\"wf+01\".wt01(timestamp,\"status+2+3\") 
values(1509465600003,false)");
       statement.execute(
-          "CREATE TIMESERIES root.ln.\"wf.01\".wt02.\"abd\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
+          "CREATE TIMESERIES root.ln.\"wf+01\".wt02.\"abd\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
       statement.execute(
-          "CREATE TIMESERIES root.ln.\"wf.01\".wt02.\"asf.asd.sdf\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
-      statement.execute(
-          "CREATE TIMESERIES root.ln.\"wf.01\".wt02.\"asd12\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
+          "CREATE TIMESERIES root.ln.\"wf+01\".wt02.\"asd12\" WITH 
DATATYPE=BOOLEAN, ENCODING=PLAIN");
 
-      boolean hasResultSet = statement.execute("SELECT * FROM 
root.ln.\"wf.01\".wt01");
+      boolean hasResultSet = statement.execute("SELECT * FROM 
root.ln.\"wf+01\".wt01");
       assertTrue(hasResultSet);
       ResultSet resultSet = statement.getResultSet();
       try {
@@ -90,7 +88,7 @@ public class IoTDBQuotedPathIT {
         }
 
         hasResultSet =
-            statement.execute("SELECT * FROM root.ln.\"wf.01\".wt01 WHERE 
\"status.2.3\" = false");
+            statement.execute("SELECT * FROM root.ln.\"wf+01\".wt01 WHERE 
\"status+2+3\" = false");
         assertTrue(hasResultSet);
         exp = new String[] {"1509465600002,false", "1509465600003,false"};
         cnt = 0;
@@ -102,14 +100,14 @@ public class IoTDBQuotedPathIT {
 
         hasResultSet =
             statement.execute(
-                "select \"status.2.3\", 'status.2.3' from 
root.ln.\"wf.01\".wt01 align by device");
+                "select \"status+2+3\", 'status.2.3' from 
root.ln.\"wf+01\".wt01 align by device");
         assertTrue(hasResultSet);
         exp =
             new String[] {
-              "1509465600000,root.ln.\"wf.01\".wt01,true,'status.2.3',",
-              "1509465600001,root.ln.\"wf.01\".wt01,true,'status.2.3',",
-              "1509465600002,root.ln.\"wf.01\".wt01,false,'status.2.3',",
-              "1509465600003,root.ln.\"wf.01\".wt01,false,'status.2.3',"
+              "1509465600000,root.ln.wf+01.wt01,true,'status.2.3',",
+              "1509465600001,root.ln.wf+01.wt01,true,'status.2.3',",
+              "1509465600002,root.ln.wf+01.wt01,false,'status.2.3',",
+              "1509465600003,root.ln.wf+01.wt01,false,'status.2.3',"
             };
         cnt = 0;
         resultSet = statement.getResultSet();
@@ -122,8 +120,7 @@ public class IoTDBQuotedPathIT {
         }
 
         statement.execute(
-            "DELETE FROM root.ln.\"wf.01\".wt01.\"status.2.3\" WHERE time < 
1509465600001");
-        statement.execute("DELETE TIMESERIES 
root.ln.\"wf.01\".wt01.\"status.2.3\"");
+            "DELETE FROM root.ln.\"wf+01\".wt01.\"status+2+3\" WHERE time < 
1509465600001");
       } finally {
         resultSet.close();
       }
@@ -139,7 +136,7 @@ public class IoTDBQuotedPathIT {
             DriverManager.getConnection(
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
-      statement.execute("SET STORAGE GROUP TO root.\"ln\"");
+      statement.execute("SET STORAGE GROUP TO root.`\"ln\"`");
     } catch (IoTDBSQLException e) {
       Assert.assertEquals(
           "315: The storage group name can only be characters, numbers and 
underscores. root.\"ln\" is not a legal path",
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBSimpleQueryIT.java 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBSimpleQueryIT.java
index 04a281d..a2bf1f0 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBSimpleQueryIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBSimpleQueryIT.java
@@ -1257,7 +1257,7 @@ public class IoTDBSimpleQueryIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.setFetchSize(5);
-      statement.execute("SET STORAGE GROUP TO root.group-with-hyphen");
+      statement.execute("SET STORAGE GROUP TO root.`group-with-hyphen`");
     } catch (SQLException e) {
       fail();
     }
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerExecutionIT.java
 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerExecutionIT.java
index 18fcb95..6026791 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerExecutionIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerExecutionIT.java
@@ -154,17 +154,17 @@ public class IoTDBTriggerExecutionIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       int[] counters1 = getCounters(6);
       LOGGER.info(Arrays.toString(counters1));
@@ -205,11 +205,11 @@ public class IoTDBTriggerExecutionIT {
       waitCountIncreaseBy(500);
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       waitCountIncreaseBy(500);
 
@@ -226,11 +226,11 @@ public class IoTDBTriggerExecutionIT {
       waitCountIncreaseBy(500);
 
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       // IOTDB-1825: if the background data generator's connection is closed, 
the following checks
       // will be meaningless, in which case we ignore the checks
@@ -260,11 +260,11 @@ public class IoTDBTriggerExecutionIT {
       waitCountIncreaseBy(500);
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       waitCountIncreaseBy(500);
 
@@ -280,27 +280,27 @@ public class IoTDBTriggerExecutionIT {
       }
 
       waitCountIncreaseBy(100);
-      statement.execute("drop trigger trigger-1");
-      statement.execute("drop trigger trigger-2");
-      statement.execute("drop trigger trigger-3");
+      statement.execute("drop trigger trigger_1");
+      statement.execute("drop trigger trigger_2");
+      statement.execute("drop trigger trigger_3");
       waitCountIncreaseBy(100);
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
       waitCountIncreaseBy(100);
-      statement.execute("drop trigger trigger-1");
-      statement.execute("drop trigger trigger-2");
-      statement.execute("drop trigger trigger-3");
+      statement.execute("drop trigger trigger_1");
+      statement.execute("drop trigger trigger_2");
+      statement.execute("drop trigger trigger_3");
       waitCountIncreaseBy(100);
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
 
       waitCountIncreaseBy(500);
 
@@ -332,32 +332,32 @@ public class IoTDBTriggerExecutionIT {
       waitCountIncreaseBy(500);
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       waitCountIncreaseBy(500);
 
-      statement.execute("stop trigger trigger-1");
-      statement.execute("stop trigger trigger-2");
-      statement.execute("stop trigger trigger-3");
+      statement.execute("stop trigger trigger_1");
+      statement.execute("stop trigger trigger_2");
+      statement.execute("stop trigger trigger_3");
 
       int[] counters1 = getCounters(6);
       LOGGER.info(Arrays.toString(counters1));
 
       waitCountIncreaseBy(500);
 
-      statement.execute("stop trigger trigger-4");
-      statement.execute("stop trigger trigger-5");
-      statement.execute("stop trigger trigger-6");
+      statement.execute("stop trigger trigger_4");
+      statement.execute("stop trigger trigger_5");
+      statement.execute("stop trigger trigger_6");
 
       int[] counters2 = getCounters(6);
       LOGGER.info(Arrays.toString(counters2));
@@ -374,9 +374,9 @@ public class IoTDBTriggerExecutionIT {
         assertTrue(counters1[i] < counters2[i]);
       }
 
-      statement.execute("start trigger trigger-1");
-      statement.execute("start trigger trigger-2");
-      statement.execute("start trigger trigger-3");
+      statement.execute("start trigger trigger_1");
+      statement.execute("start trigger trigger_2");
+      statement.execute("start trigger trigger_3");
 
       waitCountIncreaseBy(500);
 
@@ -394,9 +394,9 @@ public class IoTDBTriggerExecutionIT {
         assertEquals(counters2[i], counters3[i]);
       }
 
-      statement.execute("start trigger trigger-4");
-      statement.execute("start trigger trigger-5");
-      statement.execute("start trigger trigger-6");
+      statement.execute("start trigger trigger_4");
+      statement.execute("start trigger trigger_5");
+      statement.execute("start trigger trigger_6");
 
       waitCountIncreaseBy(500);
 
@@ -411,12 +411,12 @@ public class IoTDBTriggerExecutionIT {
         assertTrue(counters3[i] < counters4[i]);
       }
 
-      statement.execute("stop trigger trigger-1");
-      statement.execute("stop trigger trigger-2");
-      statement.execute("stop trigger trigger-3");
-      statement.execute("stop trigger trigger-4");
-      statement.execute("stop trigger trigger-5");
-      statement.execute("stop trigger trigger-6");
+      statement.execute("stop trigger trigger_1");
+      statement.execute("stop trigger trigger_2");
+      statement.execute("stop trigger trigger_3");
+      statement.execute("stop trigger trigger_4");
+      statement.execute("stop trigger trigger_5");
+      statement.execute("stop trigger trigger_6");
 
       waitCountIncreaseBy(500);
       int[] counters5 = getCounters(6);
@@ -439,7 +439,7 @@ public class IoTDBTriggerExecutionIT {
     int[] counters = new int[limit];
     for (int i = 1; i <= limit; ++i) {
       counters[i - 1] =
-          ((Counter) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-" + i))
+          ((Counter) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_" + i))
               .getCounter();
     }
     return counters;
@@ -456,17 +456,17 @@ public class IoTDBTriggerExecutionIT {
       waitCountIncreaseBy(500);
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       waitCountIncreaseBy(500);
 
@@ -492,7 +492,7 @@ public class IoTDBTriggerExecutionIT {
 
       for (int i = 0; i < 6; ++i) {
         try {
-          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-" + i);
+          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_" + i);
           fail();
         } catch (TriggerManagementException e) {
           assertTrue(e.getMessage().contains("does not exist"));
@@ -503,7 +503,7 @@ public class IoTDBTriggerExecutionIT {
 
       for (int i = 0; i < 6; ++i) {
         try {
-          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-" + i);
+          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_" + i);
           fail();
         } catch (TriggerManagementException e) {
           assertTrue(e.getMessage().contains("does not exist"));
@@ -511,17 +511,17 @@ public class IoTDBTriggerExecutionIT {
       }
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       Thread.sleep(500);
 
@@ -546,17 +546,17 @@ public class IoTDBTriggerExecutionIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       waitCountIncreaseBy(500);
 
@@ -567,7 +567,7 @@ public class IoTDBTriggerExecutionIT {
 
       for (int i = 0; i < 6; ++i) {
         try {
-          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-" + i);
+          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_" + i);
           fail();
         } catch (TriggerManagementException e) {
           assertTrue(e.getMessage().contains("does not exist"));
@@ -578,7 +578,7 @@ public class IoTDBTriggerExecutionIT {
 
       for (int i = 0; i < 6; ++i) {
         try {
-          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-" + i);
+          
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_" + i);
           fail();
         } catch (TriggerManagementException e) {
           assertTrue(e.getMessage().contains("does not exist"));
@@ -586,17 +586,17 @@ public class IoTDBTriggerExecutionIT {
       }
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-5 before insert on root.vehicle.d1.s5 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_5 before insert on root.vehicle.d1.s5 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-6 after insert on root.vehicle.d1.s6 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_6 after insert on root.vehicle.d1.s6 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       Thread.sleep(500);
 
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerManagementIT.java
 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerManagementIT.java
index ec9a238..373b47c 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerManagementIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/IoTDBTriggerManagementIT.java
@@ -97,14 +97,14 @@ public class IoTDBTriggerManagementIT {
 
       // create trigger
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       assertFalse(
-          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-1"))
+          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_1"))
               .isStopped());
       assertFalse(
-          ((Counter) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-2"))
+          ((Counter) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_2"))
               .isStopped());
 
       // show
@@ -114,9 +114,9 @@ public class IoTDBTriggerManagementIT {
       assertFalse(resultSet.next());
 
       // stop trigger
-      statement.execute("stop trigger trigger-1");
+      statement.execute("stop trigger trigger_1");
       assertTrue(
-          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-1"))
+          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_1"))
               .isStopped());
 
       // show
@@ -126,14 +126,14 @@ public class IoTDBTriggerManagementIT {
       assertFalse(resultSet.next());
 
       // start trigger
-      statement.execute("start trigger trigger-1");
+      statement.execute("start trigger trigger_1");
       assertFalse(
-          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-1"))
+          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_1"))
               .isStopped());
 
       // drop trigger
-      statement.execute("drop trigger trigger-1");
-      statement.execute("drop trigger trigger-2");
+      statement.execute("drop trigger trigger_1");
+      statement.execute("drop trigger trigger_2");
 
       // show
       resultSet = statement.executeQuery("show triggers");
@@ -150,7 +150,7 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-2 before insert on root.vehicle.d1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_2 before insert on root.vehicle.d1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
     } catch (SQLException throwable) {
       assertTrue(
           throwable.getMessage().contains("MNode [root.vehicle.d1] is not a 
MeasurementMNode."));
@@ -164,7 +164,7 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-2 before insert on root.nonexistent.d1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_2 before insert on root.nonexistent.d1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
     } catch (SQLException throwable) {
       assertTrue(throwable.getMessage().contains("Path [root.nonexistent.d1] 
does not exist"));
     }
@@ -177,9 +177,9 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-2 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Nonexistent'");
+          "create trigger trigger_2 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Nonexistent\'");
     } catch (SQLException throwable) {
-      assertTrue(throwable.getMessage().contains("Failed to reflect Trigger 
trigger-2"));
+      assertTrue(throwable.getMessage().contains("Failed to reflect Trigger 
trigger_2"));
     }
   }
 
@@ -190,9 +190,9 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-1 after insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 after insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
     } catch (SQLException throwable) {
       assertTrue(
           throwable
@@ -209,9 +209,9 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-1 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
     } catch (SQLException throwable) {
       assertTrue(
           throwable
@@ -228,33 +228,33 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
-      statement.execute("drop trigger trigger-1");
-      statement.execute("drop trigger trigger-2");
+      statement.execute("drop trigger trigger_1");
+      statement.execute("drop trigger trigger_2");
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
-      statement.execute("drop trigger trigger-1");
-      statement.execute("drop trigger trigger-2");
+      statement.execute("drop trigger trigger_1");
+      statement.execute("drop trigger trigger_2");
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       ResultSet resultSet = statement.executeQuery("show triggers");
       assertTrue(resultSet.next());
       assertTrue(resultSet.next());
       assertFalse(resultSet.next());
 
-      statement.execute("drop trigger trigger-1");
-      statement.execute("drop trigger trigger-2");
+      statement.execute("drop trigger trigger_1");
+      statement.execute("drop trigger trigger_2");
 
       resultSet = statement.executeQuery("show triggers");
       assertFalse(resultSet.next());
@@ -270,20 +270,20 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
-      ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-1"))
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
+      ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_1"))
           .setAccumulator(1234);
 
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       statement.execute(
-          "create trigger trigger-4 after insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_4 after insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
 
       assertEquals(
           1234,
-          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger-1"))
+          ((Accumulator) 
TriggerRegistrationService.getInstance().getTriggerInstance("trigger_1"))
               .getAccumulator(),
           0);
     } catch (SQLException | TriggerManagementException throwable) {
@@ -297,9 +297,9 @@ public class IoTDBTriggerManagementIT {
             DriverManager.getConnection(
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
-      statement.execute("drop trigger trigger-1");
+      statement.execute("drop trigger trigger_1");
     } catch (SQLException throwable) {
-      assertTrue(throwable.getMessage().contains("Trigger trigger-1 does not 
exist"));
+      assertTrue(throwable.getMessage().contains("Trigger trigger_1 does not 
exist"));
     }
   }
 
@@ -309,9 +309,9 @@ public class IoTDBTriggerManagementIT {
             DriverManager.getConnection(
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
-      statement.execute("start trigger trigger-1");
+      statement.execute("start trigger trigger_1");
     } catch (SQLException throwable) {
-      assertTrue(throwable.getMessage().contains("Trigger trigger-1 does not 
exist"));
+      assertTrue(throwable.getMessage().contains("Trigger trigger_1 does not 
exist"));
     }
   }
 
@@ -322,10 +322,10 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
-      statement.execute("start trigger trigger-1");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
+      statement.execute("start trigger trigger_1");
     } catch (SQLException throwable) {
-      assertTrue(throwable.getMessage().contains("Trigger trigger-1 has 
already been started"));
+      assertTrue(throwable.getMessage().contains("Trigger trigger_1 has 
already been started"));
     }
   }
 
@@ -335,9 +335,9 @@ public class IoTDBTriggerManagementIT {
             DriverManager.getConnection(
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
-      statement.execute("stop trigger trigger-1");
+      statement.execute("stop trigger trigger_1");
     } catch (SQLException throwable) {
-      assertTrue(throwable.getMessage().contains("Trigger trigger-1 does not 
exist"));
+      assertTrue(throwable.getMessage().contains("Trigger trigger_1 does not 
exist"));
     }
   }
 
@@ -348,11 +348,11 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
-      statement.execute("stop trigger trigger-1");
-      statement.execute("stop trigger trigger-1");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
+      statement.execute("stop trigger trigger_1");
+      statement.execute("stop trigger trigger_1");
     } catch (SQLException throwable) {
-      assertTrue(throwable.getMessage().contains("Trigger trigger-1 has 
already been stopped"));
+      assertTrue(throwable.getMessage().contains("Trigger trigger_1 has 
already been stopped"));
     }
   }
 
@@ -363,34 +363,34 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
       assertFalse(
           TriggerRegistrationService.getInstance()
-              .getRegistrationInformation("trigger-1")
+              .getRegistrationInformation("trigger_1")
               .isStopped());
 
-      statement.execute("stop trigger trigger-1");
+      statement.execute("stop trigger trigger_1");
       assertTrue(
           TriggerRegistrationService.getInstance()
-              .getRegistrationInformation("trigger-1")
+              .getRegistrationInformation("trigger_1")
               .isStopped());
 
-      statement.execute("start trigger trigger-1");
+      statement.execute("start trigger trigger_1");
       assertFalse(
           TriggerRegistrationService.getInstance()
-              .getRegistrationInformation("trigger-1")
+              .getRegistrationInformation("trigger_1")
               .isStopped());
 
-      statement.execute("stop trigger trigger-1");
+      statement.execute("stop trigger trigger_1");
       assertTrue(
           TriggerRegistrationService.getInstance()
-              .getRegistrationInformation("trigger-1")
+              .getRegistrationInformation("trigger_1")
               .isStopped());
 
-      statement.execute("start trigger trigger-1");
+      statement.execute("start trigger trigger_1");
       assertFalse(
           TriggerRegistrationService.getInstance()
-              .getRegistrationInformation("trigger-1")
+              .getRegistrationInformation("trigger_1")
               .isStopped());
     } catch (SQLException | TriggerManagementException e) {
       fail(e.getMessage());
@@ -405,22 +405,22 @@ public class IoTDBTriggerManagementIT {
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s1 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator' with ('k1'='v1', 
'k2'='v2')");
-      statement.execute("stop trigger trigger-1");
-      statement.execute("start trigger trigger-1");
-      statement.execute("drop trigger trigger-1");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s1 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\' with ('k1'='v1', 
'k2'='v2')");
+      statement.execute("stop trigger trigger_1");
+      statement.execute("start trigger trigger_1");
+      statement.execute("drop trigger trigger_1");
 
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Counter' with ('k3'='v3')");
-      statement.execute("stop trigger trigger-1");
-      statement.execute("start trigger trigger-1");
-      statement.execute("drop trigger trigger-1");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\' with ('k3'='v3')");
+      statement.execute("stop trigger trigger_1");
+      statement.execute("start trigger trigger_1");
+      statement.execute("drop trigger trigger_1");
 
       statement.execute(
-          "create trigger trigger-1 after insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+          "create trigger trigger_1 after insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
       statement.execute(
-          "create trigger trigger-2 before insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator' with ('k4'='v4')");
-      statement.execute("stop trigger trigger-1");
+          "create trigger trigger_2 before insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\' with ('k4'='v4')");
+      statement.execute("stop trigger trigger_1");
 
     } catch (Exception e) {
       fail(e.getMessage());
@@ -434,8 +434,8 @@ public class IoTDBTriggerManagementIT {
         Statement statement = connection.createStatement()) {
 
       TriggerRegistrationInformation trigger1Info =
-          
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger-1");
-      assertEquals("trigger-1", trigger1Info.getTriggerName());
+          
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger_1");
+      assertEquals("trigger_1", trigger1Info.getTriggerName());
       assertEquals("root.vehicle.d1.s3", 
trigger1Info.getFullPath().getFullPath());
       assertEquals(TriggerEvent.AFTER_INSERT, trigger1Info.getEvent());
       assertEquals(
@@ -444,8 +444,8 @@ public class IoTDBTriggerManagementIT {
       assertTrue(trigger1Info.isStopped());
 
       TriggerRegistrationInformation trigger2Info =
-          
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger-2");
-      assertEquals("trigger-2", trigger2Info.getTriggerName());
+          
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger_2");
+      assertEquals("trigger_2", trigger2Info.getTriggerName());
       assertEquals("root.vehicle.d1.s4", 
trigger2Info.getFullPath().getFullPath());
       assertEquals(TriggerEvent.BEFORE_INSERT, trigger2Info.getEvent());
       assertEquals(
@@ -453,15 +453,15 @@ public class IoTDBTriggerManagementIT {
       assertEquals("{k4=v4}", trigger2Info.getAttributes().toString());
       assertFalse(trigger2Info.isStopped());
 
-      statement.execute("drop trigger trigger-2");
+      statement.execute("drop trigger trigger_2");
       statement.execute(
-          "create trigger trigger-2 after insert on root.vehicle.d1.s3 as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
-      statement.execute("drop trigger trigger-1");
+          "create trigger trigger_2 after insert on root.vehicle.d1.s3 as 
\'org.apache.iotdb.db.engine.trigger.example.Counter\'");
+      statement.execute("drop trigger trigger_1");
       statement.execute(
-          "create trigger trigger-1 before insert on root.vehicle.d1.s4 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator' with ('k5'='v5')");
-      statement.execute("stop trigger trigger-2");
+          "create trigger trigger_1 before insert on root.vehicle.d1.s4 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\' with ('k5'='v5')");
+      statement.execute("stop trigger trigger_2");
       statement.execute(
-          "create trigger trigger-3 before insert on root.vehicle.d1.s2 as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+          "create trigger trigger_3 before insert on root.vehicle.d1.s2 as 
\'org.apache.iotdb.db.engine.trigger.example.Accumulator\'");
     } catch (Exception e) {
       fail(e.getMessage());
     }
@@ -469,8 +469,8 @@ public class IoTDBTriggerManagementIT {
     EnvironmentUtils.restartDaemon();
 
     TriggerRegistrationInformation trigger1Info =
-        
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger-1");
-    assertEquals("trigger-1", trigger1Info.getTriggerName());
+        
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger_1");
+    assertEquals("trigger_1", trigger1Info.getTriggerName());
     assertEquals("root.vehicle.d1.s4", 
trigger1Info.getFullPath().getFullPath());
     assertEquals(TriggerEvent.BEFORE_INSERT, trigger1Info.getEvent());
     assertEquals(
@@ -479,8 +479,8 @@ public class IoTDBTriggerManagementIT {
     assertFalse(trigger1Info.isStopped());
 
     TriggerRegistrationInformation trigger2Info =
-        
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger-2");
-    assertEquals("trigger-2", trigger2Info.getTriggerName());
+        
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger_2");
+    assertEquals("trigger_2", trigger2Info.getTriggerName());
     assertEquals("root.vehicle.d1.s3", 
trigger2Info.getFullPath().getFullPath());
     assertEquals(TriggerEvent.AFTER_INSERT, trigger2Info.getEvent());
     assertEquals("org.apache.iotdb.db.engine.trigger.example.Counter", 
trigger2Info.getClassName());
@@ -488,8 +488,8 @@ public class IoTDBTriggerManagementIT {
     assertTrue(trigger2Info.isStopped());
 
     TriggerRegistrationInformation trigger3Info =
-        
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger-3");
-    assertEquals("trigger-3", trigger3Info.getTriggerName());
+        
TriggerRegistrationService.getInstance().getRegistrationInformation("trigger_3");
+    assertEquals("trigger_3", trigger3Info.getTriggerName());
     assertEquals("root.vehicle.d1.s2", 
trigger3Info.getFullPath().getFullPath());
     assertEquals(TriggerEvent.BEFORE_INSERT, trigger3Info.getEvent());
     assertEquals(
diff --git 
a/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
 
b/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
index 12678de..c45d4ce 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/integration/auth/IoTDBAuthorizationIT.java
@@ -178,18 +178,18 @@ public class IoTDBAuthorizationIT {
     adminStmt.execute(
         "create timeseries root.ln.wf03.wt03.software with 
datatype=DOUBLE,encoding=PLAIN");
     adminStmt.execute(
-        "create trigger started-trigger before insert on 
root.ln.wf01.wt01.temperature as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
+        "create trigger `started-trigger` before insert on 
root.ln.wf01.wt01.temperature as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'");
     adminStmt.execute(
-        "create trigger stopped-trigger after insert on 
root.ln.wf02.wt02.hardware as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
-    adminStmt.execute("stop trigger stopped-trigger");
+        "create trigger `stopped-trigger` after insert on 
root.ln.wf02.wt02.hardware as 
'org.apache.iotdb.db.engine.trigger.example.Counter'");
+    adminStmt.execute("stop trigger `stopped-trigger`");
   }
 
   private static void executeTriggerRelatedPrivilegesTests(Statement userStmt) 
throws SQLException {
     String[] statements = {
       "create trigger magic before insert on root.ln.wf03.wt03.software as 
'org.apache.iotdb.db.engine.trigger.example.Accumulator'",
-      "stop trigger started-trigger",
-      "drop trigger started-trigger",
-      "start trigger stopped-trigger",
+      "stop trigger `started-trigger`",
+      "drop trigger `started-trigger`",
+      "start trigger `stopped-trigger`",
     };
     for (String statement : statements) {
       try {
diff --git 
a/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java 
b/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java
index d694c90..2914dec 100644
--- a/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/metadata/MManagerBasicTest.java
@@ -1890,9 +1890,9 @@ public class MManagerBasicTest {
     PartialPath deviceId = new PartialPath("root.sg.d");
     InsertPlan insertPlan;
 
-    insertPlan = getInsertPlan("\"a.b\"");
+    insertPlan = getInsertPlan("\"a+b\"");
     manager.getSeriesSchemasAndReadLockDevice(insertPlan);
-    assertTrue(manager.isPathExist(deviceId.concatNode("\"a.b\"")));
+    assertTrue(manager.isPathExist(deviceId.concatNode("\"a+b\"")));
 
     String[] illegalMeasurementIds = {"a.b", "time", "timestamp", "TIME", 
"TIMESTAMP"};
     for (String measurementId : illegalMeasurementIds) {
@@ -1920,7 +1920,7 @@ public class MManagerBasicTest {
   @Test
   public void testTemplateSchemaNameCheckWhileCreate() {
     MManager manager = IoTDB.metaManager;
-    String[] illegalSchemaNames = {"a.b", "time", "timestamp", "TIME", 
"TIMESTAMP"};
+    String[] illegalSchemaNames = {"a+b", "time", "timestamp", "TIME", 
"TIMESTAMP"};
     for (String schemaName : illegalSchemaNames) {
       CreateTemplatePlan plan = getCreateTemplatePlan(schemaName);
       try {
diff --git 
a/server/src/test/java/org/apache/iotdb/db/metadata/MetaUtilsTest.java 
b/server/src/test/java/org/apache/iotdb/db/metadata/MetaUtilsTest.java
index ea17917..d6a42d5 100644
--- a/server/src/test/java/org/apache/iotdb/db/metadata/MetaUtilsTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/metadata/MetaUtilsTest.java
@@ -40,20 +40,20 @@ public class MetaUtilsTest {
         MetaUtils.splitPathToDetachedPath("root.sg.d1.s1"));
 
     assertArrayEquals(
-        Arrays.asList("root", "sg", "d1", "\"s.1\"").toArray(),
-        MetaUtils.splitPathToDetachedPath("root.sg.d1.\"s.1\""));
+        Arrays.asList("root", "sg", "d1", "\"s+1\"").toArray(),
+        MetaUtils.splitPathToDetachedPath("root.sg.d1.\"s+1\""));
 
     assertArrayEquals(
-        Arrays.asList("root", "sg", "d1", "\"s\\\".1\"").toArray(),
-        MetaUtils.splitPathToDetachedPath("root.sg.d1.\"s\\\".1\""));
+        Arrays.asList("root", "sg", "d1", "\"s\\\"+-1\"").toArray(),
+        MetaUtils.splitPathToDetachedPath("root.sg.d1.\"s\\\"+-1\""));
 
     assertArrayEquals(
-        Arrays.asList("root", "\"s g\"", "d1", "\"s.1\"").toArray(),
-        MetaUtils.splitPathToDetachedPath("root.\"s g\".d1.\"s.1\""));
+        Arrays.asList("root", "\"s g\"", "d1", "\"s+1\"").toArray(),
+        MetaUtils.splitPathToDetachedPath("root.\"s g\".d1.\"s+1\""));
 
     assertArrayEquals(
-        Arrays.asList("root", "\"s g\"", "\"d_.1\"", "\"s.1.1\"").toArray(),
-        MetaUtils.splitPathToDetachedPath("root.\"s g\".\"d_.1\".\"s.1.1\""));
+        Arrays.asList("root", "\"s g\"", "\"d_+-1\"", "\"s+1+2\"").toArray(),
+        MetaUtils.splitPathToDetachedPath("root.\"s g\".\"d_+-1\".\"s+1+2\""));
 
     assertArrayEquals(
         Arrays.asList("root", "1").toArray(), 
MetaUtils.splitPathToDetachedPath("root.1"));
@@ -63,13 +63,6 @@ public class MetaUtilsTest {
         MetaUtils.splitPathToDetachedPath("root.sg.d1.s.1"));
 
     try {
-      MetaUtils.splitPathToDetachedPath("root.sg.\"d.1\"\"s.1\"");
-      fail();
-    } catch (IllegalPathException e) {
-      Assert.assertEquals("root.sg.\"d.1\"\"s.1\" is not a legal path", 
e.getMessage());
-    }
-
-    try {
       MetaUtils.splitPathToDetachedPath("root..a");
       fail();
     } catch (IllegalPathException e) {
@@ -77,13 +70,6 @@ public class MetaUtilsTest {
     }
 
     try {
-      MetaUtils.splitPathToDetachedPath("root.sg.d1.'s1'");
-      fail();
-    } catch (IllegalPathException e) {
-      Assert.assertEquals("root.sg.d1.'s1' is not a legal path", 
e.getMessage());
-    }
-
-    try {
       MetaUtils.splitPathToDetachedPath("root.sg.d1.");
       fail();
     } catch (IllegalPathException e) {
diff --git 
a/server/src/test/java/org/apache/iotdb/db/monitor/IoTDBStatMonitorTest.java 
b/server/src/test/java/org/apache/iotdb/db/monitor/IoTDBStatMonitorTest.java
index cf39984..c8ac0d2 100644
--- a/server/src/test/java/org/apache/iotdb/db/monitor/IoTDBStatMonitorTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/monitor/IoTDBStatMonitorTest.java
@@ -121,13 +121,13 @@ public class IoTDBStatMonitorTest {
             DriverManager.getConnection(
                 Config.IOTDB_URL_PREFIX + "127.0.0.1:6667/", "root", "root");
         Statement statement = connection.createStatement()) {
-      boolean hasResult = statement.execute("select TOTAL_POINTS from 
root.stats.\"root.sg\"");
+      boolean hasResult = statement.execute("select TOTAL_POINTS from 
root.stats.\"\"root#sg\"\"");
       Assert.assertTrue(hasResult);
 
       int cnt = 0;
       try (ResultSet resultSet = statement.getResultSet()) {
         while (resultSet.next()) {
-          long ans = resultSet.getLong("root.stats.\"root.sg\".TOTAL_POINTS");
+          long ans = resultSet.getLong("root.stats.\"root#sg\".TOTAL_POINTS");
           Assert.assertEquals(5, ans);
           cnt++;
         }
diff --git a/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java 
b/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java
index 6a29f11..7a3b1db 100644
--- a/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/qp/PlannerTest.java
@@ -192,12 +192,12 @@ public class PlannerTest {
     assertEquals(OperatorType.INSERT, plan11.getOperatorType());
 
     String createTSStatement2 =
-        "create timeseries root.a.b.d_1.1s with datatype=FLOAT,encoding=RLE";
+        "create timeseries root.a.b.d_1.`1s` with datatype=FLOAT,encoding=RLE";
     PhysicalPlan plan12 = processor.parseSQLToPhysicalPlan(createTSStatement2);
     assertEquals(OperatorType.CREATE_TIMESERIES, plan12.getOperatorType());
 
     String queryStatement2 =
-        "select windDirection10min from 
root.national.4.5.585.9_6666.9_333.88_9";
+        "select windDirection10min from 
root.national.`4`.`5`.`585`.9_6666.9_333.88_9";
     PhysicalPlan plan13 = processor.parseSQLToPhysicalPlan(queryStatement2);
     assertEquals(OperatorType.QUERY, plan13.getOperatorType());
 
diff --git 
a/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanTest.java 
b/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanTest.java
index d785d8b..1b6c5f7 100644
--- a/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanTest.java
+++ b/server/src/test/java/org/apache/iotdb/db/qp/physical/PhysicalPlanTest.java
@@ -1143,7 +1143,7 @@ public class PhysicalPlanTest {
   @Test
   public void testSpecialCharacters() throws QueryProcessException {
     String sqlStr1 =
-        "create timeseries 
root.3e-3.-1.1/2.SNAPPY.RLE.81+12.+2.s/io.in[jack].hel[jjj.s[1].desc with "
+        "create timeseries 
root.`3e-3`.`-1+1/2`.`SNAPPY`.`RLE`.`81+12+2s/io`.`in[jack]`.`hel[jjj[]s[1]`.`desc`
 with "
             + "datatype=FLOAT, encoding=RLE, compression=SNAPPY tags(tag1=v1, 
tag2=v2)"
             + " attributes(attr1=v1, attr2=v2)";
     PhysicalPlan plan1 = processor.parseSQLToPhysicalPlan(sqlStr1);
@@ -1204,7 +1204,7 @@ public class PhysicalPlanTest {
 
   @Test
   public void testStartTrigger() throws QueryProcessException {
-    String sql = "START TRIGGER my-trigger";
+    String sql = "START TRIGGER `my-trigger`";
 
     StartTriggerPlan plan = (StartTriggerPlan) 
processor.parseSQLToPhysicalPlan(sql);
     Assert.assertFalse(plan.isQuery());
@@ -1213,7 +1213,7 @@ public class PhysicalPlanTest {
 
   @Test
   public void testStopTrigger() throws QueryProcessException {
-    String sql = "STOP TRIGGER my-trigger";
+    String sql = "STOP TRIGGER `my-trigger`";
 
     StopTriggerPlan plan = (StopTriggerPlan) 
processor.parseSQLToPhysicalPlan(sql);
     Assert.assertFalse(plan.isQuery());
diff --git 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/ListDataSetTest.java 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/ListDataSetTest.java
index 39d8d9b..1487374 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/ListDataSetTest.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/ListDataSetTest.java
@@ -51,7 +51,7 @@ public class ListDataSetTest {
     "CREATE TIMESERIES root.vehicle.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
     "CREATE TIMESERIES root.test.d0.s0 WITH DATATYPE=INT32, ENCODING=RLE",
     "CREATE TIMESERIES root.test.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
-    "CREATE TIMESERIES root.test.d1.\"s3.xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN"
+    "CREATE TIMESERIES root.test.d1.\"s3+xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN"
   };
 
   public ListDataSetTest() throws QueryProcessException {}
diff --git 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/SingleDataSetTest.java 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/SingleDataSetTest.java
index ffb9fd8..8f9a15b 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/SingleDataSetTest.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/SingleDataSetTest.java
@@ -50,7 +50,7 @@ public class SingleDataSetTest {
     "CREATE TIMESERIES root.vehicle.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
     "CREATE TIMESERIES root.test.d0.s0 WITH DATATYPE=INT32, ENCODING=RLE",
     "CREATE TIMESERIES root.test.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
-    "CREATE TIMESERIES root.test.d1.\"s3.xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN"
+    "CREATE TIMESERIES root.test.d1.\"s3+xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN"
   };
 
   public SingleDataSetTest() throws QueryProcessException {}
diff --git 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByLevelDataSetTest.java
 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByLevelDataSetTest.java
index 602ee20..03cd7c4 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByLevelDataSetTest.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByLevelDataSetTest.java
@@ -31,7 +31,8 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class GroupByLevelDataSetTest {
   private IPlanExecutor queryExecutor = new PlanExecutor();
@@ -44,7 +45,7 @@ public class GroupByLevelDataSetTest {
     "CREATE TIMESERIES root.test.d0.s0 WITH DATATYPE=INT32, ENCODING=RLE",
     "CREATE TIMESERIES root.test.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
     "CREATE TIMESERIES root.test.d0.s3 WITH DATATYPE=TEXT, ENCODING=PLAIN",
-    "CREATE TIMESERIES root.test.d1.\"s3.xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN",
+    "CREATE TIMESERIES root.test.d1.\"s3+xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN",
     "insert into root.vehicle.d0(timestamp,s0) values(10,100)",
     "insert into root.vehicle.d0(timestamp,s0,s1) values(12,101,'102')",
     "insert into root.vehicle.d0(timestamp,s1) values(19,'103')",
@@ -79,7 +80,7 @@ public class GroupByLevelDataSetTest {
     "insert into root.test.d0(timestamp,s0,s1) values(700,1307,'1038')",
     "insert into root.test.d0(timestamp,s1) values(3000,'1309')",
     "insert into root.test.d0(timestamp,s3) values(10,'100')",
-    "insert into root.test.d1(timestamp, \"s3.xy\") values(10, 'text')"
+    "insert into root.test.d1(timestamp, \"s3+xy\") values(10, 'text')"
   };
 
   static {
@@ -142,7 +143,7 @@ public class GroupByLevelDataSetTest {
     queryPlan =
         (QueryPlan)
             processor.parseSQLToPhysicalPlan(
-                "select count(\"s3.xy\") from root.test.* group by level=2");
+                "select count(\"s3+xy\") from root.test.* group by level=2");
     dataSet = queryExecutor.processQuery(queryPlan, 
EnvironmentUtils.TEST_QUERY_CONTEXT);
 
     assertTrue(dataSet.hasNext());
diff --git 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByTimeDataSetTest.java
 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByTimeDataSetTest.java
index c14d7a7..30f3468 100644
--- 
a/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByTimeDataSetTest.java
+++ 
b/server/src/test/java/org/apache/iotdb/db/query/dataset/groupby/GroupByTimeDataSetTest.java
@@ -31,7 +31,8 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 public class GroupByTimeDataSetTest {
 
@@ -44,7 +45,7 @@ public class GroupByTimeDataSetTest {
     "CREATE TIMESERIES root.vehicle.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
     "CREATE TIMESERIES root.test.d0.s0 WITH DATATYPE=INT32, ENCODING=RLE",
     "CREATE TIMESERIES root.test.d0.s1 WITH DATATYPE=TEXT, ENCODING=PLAIN",
-    "CREATE TIMESERIES root.test.d1.\"s3.xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN",
+    "CREATE TIMESERIES root.test.d1.\"s3+xy\" WITH DATATYPE=TEXT, 
ENCODING=PLAIN",
     "insert into root.vehicle.d0(timestamp,s0) values(10,100)",
     "insert into root.vehicle.d0(timestamp,s0,s1) values(12,101,'102')",
     "insert into root.vehicle.d0(timestamp,s1) values(19,'103')",
@@ -78,7 +79,7 @@ public class GroupByTimeDataSetTest {
     "insert into root.test.d0(timestamp,s0) values(1900,1316)",
     "insert into root.test.d0(timestamp,s0,s1) values(700,1307,'1038')",
     "insert into root.test.d0(timestamp,s1) values(3000,'1309')",
-    "insert into root.test.d1(timestamp, \"s3.xy\") values(10, 'text')"
+    "insert into root.test.d1(timestamp, \"s3+xy\") values(10, 'text')"
   };
 
   static {
@@ -171,7 +172,7 @@ public class GroupByTimeDataSetTest {
     queryPlan =
         (QueryPlan)
             processor.parseSQLToPhysicalPlan(
-                "select count(\"s3.xy\") from root.test.* group by ([0,20), 
3ms, 10ms), level=2");
+                "select count(\"s3+xy\") from root.test.* group by ([0,20), 
3ms, 10ms), level=2");
     dataSet = queryExecutor.processQuery(queryPlan, 
EnvironmentUtils.TEST_QUERY_CONTEXT);
 
     assertTrue(dataSet.hasNext());
diff --git 
a/session/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java 
b/session/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
index d63577d..eb6d7f4 100644
--- a/session/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
+++ b/session/src/test/java/org/apache/iotdb/session/IoTDBSessionComplexIT.java
@@ -417,13 +417,13 @@ public class IoTDBSessionComplexIT {
     session.createTimeseries(
         "root.sg1.d1.1_2", TSDataType.INT64, TSEncoding.RLE, 
CompressionType.SNAPPY);
     session.createTimeseries(
-        "root.sg1.d1.\"1.2.3\"", TSDataType.INT64, TSEncoding.RLE, 
CompressionType.SNAPPY);
+        "root.sg1.d1.1+2+3", TSDataType.INT64, TSEncoding.RLE, 
CompressionType.SNAPPY);
     session.createTimeseries(
-        "root.sg1.d1.\"1.2.4\"", TSDataType.INT64, TSEncoding.RLE, 
CompressionType.SNAPPY);
+        "root.sg1.d1.1+2+4", TSDataType.INT64, TSEncoding.RLE, 
CompressionType.SNAPPY);
 
     Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.1_2"));
-    Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.\"1.2.3\""));
-    Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.\"1.2.4\""));
+    Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.\"1+2+3\""));
+    Assert.assertTrue(session.checkTimeseriesExists("root.sg1.d1.\"1+2+4\""));
 
     session.setStorageGroup("root.1");
     session.createTimeseries(
diff --git a/site/src/main/.vuepress/config.js 
b/site/src/main/.vuepress/config.js
index c784574..c3ea509 100644
--- a/site/src/main/.vuepress/config.js
+++ b/site/src/main/.vuepress/config.js
@@ -664,6 +664,7 @@ var config = {
                                        },
                                        {
                                                title: 'Data Concept',
+                                               sidebarDepth: 2,
                                                children: [
                                                        
['Data-Concept/Data-Model-and-Terminology','Data Model and Terminology'],
                                                        
['Data-Concept/Measurement-Template','Measurement Template'],
@@ -691,6 +692,7 @@ var config = {
                                                title: 'IoTDB-SQL Language',
                                                sidebarDepth: 2,
                                                children: [
+                                                       
['IoTDB-SQL-Language/Syntax-Conventions','Syntax Conventions'],
                                                        
['IoTDB-SQL-Language/DDL-Data-Definition-Language','DDL (Data Definition 
Language)'],
                                                        
['IoTDB-SQL-Language/DML-Data-Manipulation-Language','DML (Data Manipulation 
Language)'],
                                                        
['IoTDB-SQL-Language/Maintenance-Command','Maintenance Command']
@@ -1460,6 +1462,7 @@ var config = {
                                        },
                                        {
                                                title: '数据模式与概念',
+                                               sidebarDepth: 2,
                                                children: [
                                                        
['Data-Concept/Data-Model-and-Terminology','数据模型'],
                                                        
['Data-Concept/Measurement-Template','物理量模板'],
@@ -1487,6 +1490,7 @@ var config = {
                                                title: 'IoTDB-SQL 语言',
                                                sidebarDepth: 2,
                                                children: [
+                                                       
['IoTDB-SQL-Language/Syntax-Conventions','语法约定'],
                                                        
['IoTDB-SQL-Language/DDL-Data-Definition-Language','数据定义语言（DDL）'],
                                                        
['IoTDB-SQL-Language/DML-Data-Manipulation-Language','数据操作语言（DML）'],
                                                        
['IoTDB-SQL-Language/Maintenance-Command','运维命令']