
# 搜索语法介绍
云日志服务（LTS）提供一套搜索语法用于设置搜索条件和指定日志查询时的过滤规则，从而筛选日志中满足条件的记录，筛选结果可以用于分析语句，进行更复杂的分析处理。
为了快速了解并使用搜索语法，建议您了解以下信息：[搜索方式]、[短语搜索]、[运算符]、[搜索语句示例]。
- 使用搜索语法前，请您在索引配置处设置对应分词符，如无特殊需要，可直接使用默认的分词符**, '";=()\[\]{}@\&\<\>/:\\\\?\\n\\t\\r。**
- 搜索语法不支持对分词符进行搜索。例如搜索语句**var/log** ，其中**/** 为分词符，搜索语句等同于**var log** ，搜索的是同时包含**var** 和**log** 的所有日志。同理，搜索语句**"var:log"** 、**var;log** 等搜索的也是同时包含**var** 和**log**的所有日志。
- 查询日志使用搜索语法的常见问题和相关报错的处理方法请参考[日志搜索相关问题](https://support.huaweicloud.com/lts_faq/lts_faq_0140.html)。
 #### 搜索方式
搜索语句是用来指定日志搜索时的过滤规则，返回符合条件的日志。
根据索引配置方式可分为全文搜索和字段搜索，根据搜索精确程度可分为精确搜索和模糊搜索。其他类型的搜索方式包括范围搜索、短语搜索等。
表1搜索方式说明 
| 搜索方式 | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 示例                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| 全文搜索 | 配置全文索引后，日志服务根据您设置的分词符将整条日志拆分成多个关键词。 - content为日志原文对应的内置字段，搜索语句GET等同于content:GET，默认匹配日志原文的内容。  - 多个关键词默认通过AND连接，搜索语句GET POST等同于GET and POST。                                                                                                                                                                                                                                                                                                                                                                                                 | - GET POST  - GET and POST  - content:GET and content:POST   上述三个搜索语句功能相同，均表示搜索同时包含关键词GET和POST的日志。                                                         |
| 字段搜索 | 配置字段索引后，您可以指定字段名称和字段值（key:value）进行搜索。根据字段索引中设置的数据类型，您可以进行多种类型的基础搜索和组合搜索。 - value参数不可为空，通过搜索语句**key:""**匹配字段值为空的日志。  - 字段搜索和 not 运算符配合使用时，还会匹配到不包含该字段的日志。                                                                                                                                                                                                                                                                                                                                                                                     | - request_time\>60 and request_method:po\*表示搜索request_time字段值大于60且request_method字段值以po开头的日志。  - request_method:""表示搜索request_method字段值为空的日志。  - not request_method:GET表示搜索不包含request_method字段和request_method字段值不为GET的日志。   |
| 精确搜索 | 使用精确的词进行搜索。 日志服务搜索采用的是分词法，搜索时不会保证关键词出现的顺序。 搜索语句为abc def，会匹配所有同时包含abc和def的日志，日志abc def或者def abc都会命中，如果需要确保关键词出现的顺序，请您采用[短语搜索]**#"abc def"**。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | - GET POST表示搜索同时包含关键词GET和POST的日志。  - request_method:GET表示搜索request_method字段值包含GET的日志。  - #"/var/log"表示搜索包含短语/var/log的日志。                                           |
| 模糊搜索 | 在搜索语句中指定一个词，在词的中间或者末尾加上模糊搜索关键字，即星号（\*）或问号（?），云日志服务会在所有日志中查询到符合条件的100个词，返回包含这100个词并满足查询条件的所有日志。指定的词越精确，查询结果越精确。 - 星号（\*）代表匹配多个字符，问号（?）代表匹配1个字符。  - 当星号（\*）和问号（?）作为分词符时，不具备模糊搜索功能，其中问号（?）为默认的分词符，使用其模糊搜索功能前需将其从分词符中移除。  - 星号（\*）或问号（?）不能用在词的开头。  - long数据类型和float数据类型不支持使用星号（\*）或问号（?）进行模糊搜索。  - 当模糊条件前缀很短且日志中符合条件的词超过100个时，查询结果会不精确。   | - GE\*表示在所有日志中查找以GE开头的词，并返回包含这些词的日志。  - request_method:GE\*表示在所有日志中查找request_method字段值以GE开头的词，并返回包含这些词的日志。                                                                                                                                                                                 |
| 范围搜索 | long数据类型和float数据类型支持范围搜索。 string类型的字段不支持范围查询。 - 方式1：通过 =（等于） \>（大于） \<（小于） 运算符搜索日志。  - 方式2：通过 in 运算符搜索日志，支持修改开闭区间。                                                                                                                                                                                                           | - request_time\>=60表示在所有日志中查找request_time字段值大于等于60的日志。  - request_time in (60 120\]表示在所有日志中查找request_time字段值大于60且小于等于120的日志。                                                                                                                                                            |
| 短语搜索 | 短语搜索用于完全匹配日志中的目标短语，可以确保关键词出现的顺序。 短语搜索不支持模糊搜索                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **#"abc def"**表示在所有日志中查找包含目标短语abc def 的日志。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
   
- **分词符**
  云日志服务LTS会根据分词符，将日志内容拆分成多个词。日志服务默认配置的分词符为**, '";=()\[\]{}@\&\<\>/:\\\\?\\n\\t\\r**。
  例如：日志**2023-01-01 09:30:00** ，默认分词符会将其分为四部分：**2023-01-01、09、30、00**。
  此时搜索语句**2023** 无法匹配到该条日志，可以通过**2023-01\*** 或**2023-01-01**搜索到该条日志。
  如果设置分词符为空，则字段值将被当成一个整体，您只能通过完整日志内容或模糊搜索查找对应的日志。
  
- **关键词顺序**
  只有短语搜索**#"abc def"**才能保证关键词出现的顺序，其他搜索方式多个关键词默认AND连接。
  例如：**request_method:GET POST**查询的是同时包含GET和POST的日志，不会保证GET和POST的顺序。如有需要推荐采用短语搜索。
  
- **中文搜索**
  中文搜索时不需要采用模糊查询，如有需要推荐采用短语搜索，可以匹配到更精确的结果。
  云日志服务LTS的英文是以单词的形式进行拆分的，单词的长度不一致，因此可以通过模糊搜索匹配拥有相同前缀英文单词的日志。
  中文采用的是一元分词，每个字都是独立的，拆分后每部分的长度都是1。
  例如：搜索语句**星期一** ，代表搜索同时包含**星** 、**期** 、**一** 的日志；搜索语句**#"星期一"** ，代表搜索包含目标短语**星期一**的日志。
  
- **语法关键词**
  日志搜索语句的语法关键词包括：\&\& \|\| AND OR and or NOT not in : \> \< = ( ) \[ \]
  其中**and AND or OR NOT not in**作为语法关键词使用时，前后需要使用空格分隔；
  如果日志中本身包含语法关键词且需要搜索时，搜索语句需要用**双引号**包裹，否则可能会导致语法错误或搜索到错误的结果。
  例如：搜索语句**content:and** ，包含语法关键词**and** ，需要修改为**content:"and"**。
  
 #### 短语搜索
短语搜索用于准确匹配目标短语，例如搜索语句**#"abc def"** ，区分先后顺序，将匹配所有同时包含abc、def，且abc位于def前面的日志。短语搜索和关键词搜索的区别请参考[表2]。
- **短语搜索**：在关键词搜索语法的基础上实现，短语搜索能够区分关键词的顺序，用于精准匹配目标短语，搜索结果更加精确。短语搜索适用于英文短语、中文短语的搜索，不支持模糊搜索。
- **关键词搜索** ：关键词搜索是基于分词实现，通过分词符先将搜索内容拆分为多个关键词，然后匹配日志。关键词搜索不会区分多个关键词在日志中出现的顺序，因此只要日志中按照搜索的与或非逻辑能命中关键词，该日志就会被搜索到。
   表2搜索区别 
  | 搜索方式  | 说明                            | 示例                                                                                                                                                                                                                                                                                                              |
  |:---|:---|:---|
  | 短语搜索  | 区分关键词的顺序，用于精准匹配目标短语，搜索结果更加精确。 | 假设您的日志流中存在两条原始日志，如下： - 原始日志1：this service is lts  - 原始日志2：lts is service   则搜索：#"is lts"，会命中1条日志；搜索：#"lts is"，会命中1条日志。 |
  | 关键词搜索 | 不区分关键词的顺序，按照搜索逻辑命中关键词即可。      | 假设您的日志流中存在两条原始日志，如下： - 原始日志1：this service is lts  - 原始日志2：lts is service   则搜索：is lts，会命中2条日志；搜索：lts is，会命中2条日志。    |
     
  
使用限制如下：
- 短语搜索不支持搭配模糊搜索。 短语搜索中的星号（\*）和问号（?）会被视为普通字符，因此短语搜索不支持搭配模糊搜索，可以用来搜索日志中的星号（\*）和问号（?）。
  

- 短语搜索不支持对分词符进行搜索。 例如搜索语句**#"var/log"** ，其中 / 为分词符，搜索语句等同于**#"var log"** ，会搜索包含目标短语**var log** 的日志。同理，搜索语句**#"var:log"** 、**#"var;log"** 等搜索的也是包含目标短语**var log**的日志。
  
- 中文搜索推荐采用短语搜索。 由于中文默认采用的是一元分词，每个汉字单独分词，搜索时会匹配同时包含搜索语句中每一个汉字的日志，本身便具有模糊搜索的特性，当需要更加精确的结果时，推荐采用短语搜索。
  
 
 #### 运算符
搜索语句支持的运算符请参考[表3]。
- 除in运算符外，其他运算符不区分大小写。
- 运算符的优先级由高到低排序如下所示：
  1. 冒号（:）
  
  2. 双引号（""）
  
  3. 圆括号( )
  
  4. and、not
  
  5. or
   
 表3运算符说明 
| 运算符  | 说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 示例                                                                                                                                                                                                                       |
|:---|:---|:---|
| and  | 与运算符，如果多个关键词之间没有语法关键词，默认为and关系。 and作为运算符使用时前后需要使用空格分隔。例如**1 and 2** 代表搜索同时包含**1** 和**2** 的日志；**1and2** 代表搜索包含词语**1and2**的日志。                                                                                                                                                                                                                                                                                                                                                                                                     | GET 200等同于GET and 200                                                                                                                                                                                                    |
| AND  | 与运算符，等同于and。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | GET AND 200                                                                                                                                                                                                              |
| \&\& | 与运算符。 \&\&作为运算符使用时不需要使用空格分隔。例如**：1 \&\& 2** 等同于**1\&\&2** ，代表搜索同时包含**1** 和**2**的日志。                                                                                                                                                                                                                                                                                                                                                                                                                                               | 1\&\&2                                                                                                                                                                                                                   |
| or   | or运算符。 or 作为运算符使用时前后需要使用空格分隔。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | request_method:GET or status:200                                                                                                                                                                                         |
| OR   | 或运算符，等同于or。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | request_method:GET OR status:200                                                                                                                                                                                         |
| \|\| | 或运算符。\|\| 作为运算符使用时不需要使用空格分隔。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | request_method:GET \|\| status:200                                                                                                                                                                                       |
| not  | 非运算符。 - not 作为运算符使用时需要使用空格分隔。  - not 运算符和字段搜索配合使用时还会匹配到不包含对应字段的日志。                                                                                                                                                                                                                                                                                                        | request_method:GET not status:200、not status:200                                                                                                                                                                         |
| ( )  | 用于提高括号内搜索条件的优先级。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | (request_method:GET or request_method:POST) and status:200                                                                                                                                                               |
| :    | 用于字段搜索（key:value）。 如果字段名称（key）或者字段值（value）内有空格或冒号（:）等保留字符，请使用双引号（""）包裹字段名称（key）或者字段值（value）。例如： - **"request method":GET**  - **message:"This is a log"**  - **time:"09:00:00"**  - **ipv6:"2024:AC8:2ac::d09"**   | request_method:GET                                                                                                                                                                                                       |
| ""   | 使用双引号（""）包裹一个语法关键词，可以将该语法关键词转换成普通字符，例如："and"表示搜索包含and的日志，此处的and不代表运算符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | request_method:"GET"                                                                                                                                                                                                     |
| \\   | 转义符号，用于转义双引号（""），转义后的引号表示符号本身。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 例如：日志内容为instance_id:nginx"01"，您可以使用instance_id:nginx\\"01\\"进行查询。                                                                                                                                                        |
| \*   | 通配符搜索，匹配零个、单个、多个字符。 \*不支持放在关键词开头，推荐放在关键词的中间部分或者结尾。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | request_method:P\*T                                                                                                                                                                                                      |
| ?    | 通配符搜索，匹配单个字符。 ?不支持放在关键词开头，推荐放在关键词的中间部分或者结尾。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 例如：request_method:P?T，可以匹配到PUT，无法匹配到POST。                                                                                                                                                                                |
| \>   | 搜索某字段值大于某数值的日志。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | request_time\>100                                                                                                                                                                                                        |
| \>=  | 搜索某字段值大于或等于某数值的日志。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | request_time\>=100                                                                                                                                                                                                       |
| \<   | 搜索某字段值小于某数值的日志。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | request_time\<100                                                                                                                                                                                                        |
| \<=  | 搜索某字段值小于或等于某数值的日志。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | request_time\<=100                                                                                                                                                                                                       |
| =    | 搜索某字段值等于某数值的日志，仅适用于float、long类型的字段。对于该类型的字段，等号（=）和冒号（:）作用相同。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | request_time=100等同于request_time:100                                                                                                                                                                                      |
| in   | 搜索某字段值处于某数值范围内的日志，中括号表示闭区间，小括号表示开区间，两个数字之间使用空格分隔。 in只能为小写字母，且作为运算符使用时前后需要使用空格分隔。                                                                                                                                                                                                                                                                                                                                                                                                                                                 | - request_time in \[100 200\]  - request_time in (100 200\]   |
| #""  | 用于搜索包含目标短语的日志，可以保证关键词出现的顺序。 短语搜索中的星号（\*）和问号（?）会被视为普通字符，因此短语搜索不支持模糊搜索，可以用来搜索日志中的星号（\*）和问号（?）。                                                                                                                                                                                                                                                                                                                                                                                                                                     | request_method:#"GET POST"                                                                                                                                                                                               |
   
 #### 搜索语句示例
同一条搜索语句，针对不同的日志内容和索引配置时，会有不同的搜索结果。本文基于如下日志样例和索引介绍搜索语句示例。
图1搜索示例   
![](https://support.huaweicloud.com/usermanual-lts/zh-cn_image_0000001580789472.png "点击放大")
表4普通搜索示例 
| 搜索需求                               | 搜索语句                                                                                                                                                                                                                                                                                                                                                                                     |
|:---|:---|
| 搜索POST请求且状态码为200的日志。               | request_method:POST and status=200                                                                                                                                                                                                                                                                                                                                                       |
| 搜索GET请求或POST请求成功（状态码为200\~299）的日志。 | (request_method:POST or request_method:GET) and status in \[200 299\]                                                                                                                                                                                                                                                                                                                    |
| 搜索GET请求或POST请求失败的日志。               | (request_method:POST or request_method:GET) not status in \[200 299\]                                                                                                                                                                                                                                                                                                                    |
| 搜索非GET请求的日志。                       | not request_method:GET                                                                                                                                                                                                                                                                                                                                                                   |
| 搜索GET请求成功且请求时间小于60秒的日志。            | request_method:GET and status in \[200 299\] not request_time\>=60                                                                                                                                                                                                                                                                                                                       |
| 搜索请求时间为60秒的日志。                     | - request_time:60  - request_time=60                                     |
| 搜索请求时间大于等于60秒，并且小于200秒的日志。         | - request_time\>=60 and request_time\<200  - request_time in \[60 200)   |
| 搜索包含and的日志。                        | content:"and" 此处使用双引号将and包裹，and为普通字符串，不代表运算符。                                                                                                                                                                                                                                                                                  |
| 搜索不存在user字段的日志。                    | not user:\*                                                                                                                                                                                                                                                                                                                                                                              |
| 搜索user字段值为空的日志。                    | user:""                                                                                                                                                                                                                                                                                                                                                                                  |
| 搜索星期字段值不为星期一的日志。                   | not week:星期一                                                                                                                                                                                                                                                                                                                                                                             |
| 搜索sec-ch-ua-mobile字段值为?0的日志。       | sec-ch-ua-mobile:#"?0" 日志内容中包含\*或?且需要搜索时，需要采用短语查询。                                                                                                                                                                                                                                      |
   
更复杂的搜索示例请参考[表5]。
 表5模糊搜索 
| 搜索需求                                                | 搜索语句                |
|:---|:---|
| 搜索包含以GE开头的词的日志。                                     | GE\*                |
| 搜索包含以GE开头，结尾只有一个字符的词的日志。                            | GE?                 |
| 搜索request_method字段值包含以G开头的词的日志。                     | request_method:G\*  |
| 搜索request_method字段值包含以P开头，以T结尾，中间还有单个字符的词的日志。       | request_method:P?T  |
| 搜索request_method字段值包含以P开头，以T结尾，中间包含零个、单个或多个字符的词的日志。 | request_method:P\*T |
   
基于分词符的搜索，例如：User-Agent字段值为**Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36**。
- 设置分词符为空时，该字段值将被当成一个整体，则您使用**User-Agent:Chrome**搜索语句进行搜索时，无法搜索到日志。
- 设置分词符为**, '";=()\[\]{}?@\&\<\>/:\\n\\t\\r** 后，该字段值会被拆分为**Mozilla** 、**5.0** 、**Windows** 、**NT** 、**10.0** 、**Win64** 、**x64** 、**AppleWebKit** 、**537.36** 、**KHTML** 、**like** 、**Gecko** 、**Chrome** 、**113.0.0.0** 、**Safari** 、**537.36。**
  此时可以使用**User-Agent:Chrome**等搜索语句进行搜索。
  表6基于分词符的搜索 
  | 搜索需求                                  | 搜索语句                                    |
  |:---|:---|
  | 搜索User-Agent字段值中包含Chrome的日志。          | User-Agent:Chrome                       |
  | 搜索User-Agent字段值中包含以Win开头的词的日志。        | User-Agent:Win\*                        |
  | 搜索User-Agent字段值中包含Chrome和Linux的日志。    | User-Agent:"Chrome Linux"               |
  | 搜索User-Agent字段值中包含Firefox或Chrome的日志。  | User-Agent:Chrome OR User-Agent:Firefox |
  | 搜索User-Agent字段值包含Chrome，但不包含Linux的日志。 | User-Agent:Chrome NOT User-Agent:Linux  |
     
  
 
