
# 映射富化函数
本文介绍映射富化函数的语法规则，包括参数解释、函数示例等。
#### 函数列表
| **类型** |                                                                      **函数**                                                                      |                  **说明**                  |
|---|---|---|
| 字段映射   | [e_dict_map]          | 与目标数据字典进行映射，根据输入的字段映射一个新字段。支持和其他函数组合使用。  |
| 字段映射   | [e_table_map]         | 与目标表格进行映射，根据输入的字段名称返回字段值。支持和其他函数组合使用。    |
| 搜索映射   | [e_search_dict_map]   | 对关键字（查询字符串）以及其匹配的值的字典数据进行映射。支持和其他函数组合使用。 |
| 搜索映射   | [e_search_table_map] | 对某列（查询字符串）以及其匹配的值的表格数据进行映射。              |
   
 #### e_dict_map
与目标数据字典进行映射，根据输入的字段映射一个新字段。
- **函数格式**
  ```
  e_dict_map(data, field, output_field, case_insensitive=true, missing=None, mode="overwrite")
  ```
  
- **参数说明**
  
  |     **参数名称**     |      **数据类型**       | **是否必填** |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       **说明**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
  |---|---|---|---|
  | data             | Dict                | 是        | 目标数据字典。必须为标准的{key01:value01,key01:value02,...}格式，且必须是字符串。例如{"1": "TCP", "2": "UDP", "3": "HTTP", "\*": "Unknown"}。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  | field            | String或者String List | 是        | 一个字段名或者多个字段名的列表。多个字段时： - 依次对匹配到的值进行映射。  - 如果匹配命中多条日志，且mode的取值为overwrite时，则最后一个会覆盖前面的结果。  - 当没有匹配到任何字段，则使用missing参数的值作为匹配值。   |
  | output_field     | String              | 是        | 输出字段的名称。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
  | case_insensitive | Boolean             | 否        | 匹配时大小写是否不敏感。 如果字典中存在同一个关键字的不同大小写，且case_insensitive为true时，会优先选择大小写完全匹配的值。如果没有，则随机选择一个。 - true（默认值）：不敏感。  - false：敏感                                                                                                                                                                                      |
  | missing          | String              | 否        | 无匹配字段时，将该参数的取值赋给输出字段output_field。默认为None表示不做映射赋值操作。 如果字典中包含匹配星号（\*），由于星号（\*）的优先级高于missing，此时missing参数不生效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
  | mode             | String              | 否        | 字段的覆盖模式。默认为overwrite。 取值为：fill，fill-auto,add,add-auto,overwrite,overwrite-auto                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
     
  
- **返回结果**
  返回附带新字段的日志。
  
- **函数示例**
  1. 示例1：根据测试数据中pro字段的值和目标数据字典，输出新字段protocol。
     - 测试数据
       ```
       {
        "data":  123,
        "pro":  1
       }
       ```
       
     
     - 加工规则
       ```
       e_dict_map(
           {"1": "TCP", "2": "UDP", "3": "HTTP", "6": "HTTPS", "*": "Unknown"},
           "pro",
           "protocol",
       )
       ```
       
     
     - 加工结果
       ```
       data:  123
       pro:  1
       protocol:  TCP
       ```
       
      
  
  2. 示例2：根据测试数据中status字段的值和目标数据字典，输出新字段message。
     - 测试数据（三条测试日志）
       ```
       {
         "status":"500"
       }
       ```
       ```
       {
         "status":"400"
       }
       ```
       ```
       {
         "status":"200"
       }
       ```
       
     
     - 加工规则
       ```
       e_dict_map({"400": "错误", "200": "正常", "*": "其他"}, "status", "message")
       ```
       
     
     - 加工结果
       ```
       status:  500
       message:  其他
       ```
       ```
       status:  400
       message:  错误
       ```
       ```
       status:  200
       message:  正常
       ```
       
      
   
- **更多参考**
  支持和其他函数组合使用。
  
 
 #### e_table_map
与目标表格进行映射，根据输入的字段名称返回字段值。
- **函数格式**
  ```
  e_table_map(data, field, output_fields, missing=None, mode="fill-auto")
  ```
  
- **参数说明**
  
  |   **参数名称**    |           **数据类型**            | **是否必填** |                                                                                                                                    **说明**                                                                                                                                     |
  |---|---|---|---|
  | data          | Table                         | 是        | 目标表格。                                                                                                                                                                                                                                                                         |
  | field         | String、String List或Tuple List | 是        | 日志中映射到表格的源字段。如果日志中不存在对应字段，则不进行任何操作。                                                                                                                                                                                                                                           |
  | output_fields | String、String List或Tuple List | 是        | 映射后的字段。例如\["province", "pop"\]。                                                                                                                                                                                                                                               |
  | missing       | String                        | 否        | 无匹配字段时，将该参数的取值赋给输出字段output_fields。默认为None表示不做映射赋值操作。如果目标字段是多列，则missing可以是一个长度与目标字段数一致的默认值列表。 **说明** 如果表格中包含匹配星号（\*），由于星号（\*）的优先级高于missing，此时missing参数将不起作用。 |
  | mode          | String                        | 否        | 字段的覆盖模式。默认为fill-auto。                                                                                                                                                                                                                                                         |
     
  
- **返回结果**
  返回附带新字段值的日志。
  
- **函数示例**
  1. 示例1：在映射表格中查找对应行，根据city字段返回province字段的值。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj"
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city,pop,province\nnj,800,js\nsh,2000,sh"), "city", "province"
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj
       province: js
       ```
       
      
  
  2. 示例2：在映射表格中查找对应行，根据city字段返回province字段和pop字段的值。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj"
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city,pop,province\nnj,800,js\nsh,2000,sh"),
           "city",
           ["province", "pop"],
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj
       province: js
       pop: 800
       ```
       
      
  
  3. 示例3：使用tab_parse_csv函数构建映射表格，根据city字段返回province字段和pop字段的值。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj"
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city#pop#province\nnj#800#js\nsh#2000#sh", sep="#"),
           "city",
           ["province", "pop"],
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj
       province: js
       pop: 800
       ```
       
      
  
  4. 示例4：使用tab_parse_csv函数构建映射表格，根据city字段返回province字段和pop字段的值。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj"
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv(
               "city,pop,province\n|nj|,|800|,|js|\n|shang hai|,2000,|SHANG,HAI|", quote="|"
           ),
           "city",
           ["province", "pop"],
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj
       province: js
       pop: 800
       ```
       
      
  
  5. 示例5：日志匹配字段与映射表格中字段不一样。在映射表格中查找对应行，根据cty或city字段返回province字段的值。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj"
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city,pop,province\nnj,800,js\nsh,2000,sh"),
           [("city", "city")],
           "province"
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj 
       province: js
       ```
       
      
  
  6. 示例6：日志匹配字段与映射表格中字段不一样，并且对输出字段进行重命名。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj"
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city,pop,province\nnj,800,js\nsh,2000,sh"),
           [("city", "city")],
           [("province", "pro")],
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj 
       pro: js
       ```
       
      
  
  7. 示例7：多个日志匹配字段。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj",
        "pop": 800
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city,pop,province\nnj,800,js\nsh,2000,sh"),
           ["city", "pop"],
           "province",
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj 
       pop: 800
       province: js
       ```
       
      
  
  8. 示例8：多个日志匹配字段，且日志匹配字段与映射表格字段不一样。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj",
        "pp": 800
       }
       ```
       
     
     - 加工规则
       ```
       e_table_map(
           tab_parse_csv("city,pop,province\nnj,800,js\nsh,2000,sh"),
           [("city", "city"), ("pp", "pop")],
           "province",
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj 
       pp: 800
       province: js
       ```
       
      
   
- **更多参考**
  支持和其他函数组合使用。
  
 
 #### e_search_dict_map
对关键字（查询字符串）以及其匹配的值的字典数据进行映射。
- **函数格式**
  ```
  e_search_dict_map(data, output_field, multi_match=false, multi_join=" ", missing=None, mode="overwrite")
  ```
  
- **参数说明**
  
  |   **参数名称**   | **数据类型** | **是否必填** |                                                                                                            **说明**                                                                                                             |
  |---|---|---|---|
  | data         | Dict     | 是        | 映射关系的字典。必须为标准的{key01:value01,key01:value02,...}格式，且关键字key必须是查询字符串。                                                                                                                                                            |
  | output_field | String   | 是        | 输出字段的名称。                                                                                                                                                                                                                      |
  | multi_match  | Boolean  | 否        | 是否允许匹配多个字段。默认为false表示不匹配多个字段，会返回匹配到的最后一个字段值。支持使用multi_join拼接多个匹配的值。                                                                                                                                                           |
  | multi_join   | String   | 否        | 匹配多个字段时，多值的连接字符串，默认为空格。当multi_match值为true时生效。                                                                                                                                                                                 |
  | missing      | String   | 否        | 无匹配字段时，将该参数的取值赋给输出字段output_field。默认为None表示不做映射赋值操作。 如果字典中包含默认匹配星号（\*），由于星号（\*）的优先级高于missing，此时missing将不起作用。 |
  | mode         | String   | 否        | 字段的覆盖模式。默认为overwrite。                                                                                                                                                                                                         |
     
  
- **返回结果**
  返回查询匹配中后的映射结果。
  
- **函数示例**
  1. 示例1：匹配模式。
     - 测试数据
       ```
       {
        "data":123 ,
        "pro":1
       }
       ```
       
     
     - 加工规则
       ```
       e_search_dict_map ({"pro==1": "TCP", "pro==2": "UDP", "pro==3": "HTTP"}, "protocol")
       ```
       
     
     - 加工结果
       ```
       data:123 
       pro:1 
       protocol:TCP
       ```
       
      
  
  2. 示例2：根据字段值的不同开头进行映射。
     - 测试数据
       ```
       {
        "status":"200,300"
       }
       ```
       
     
     - 加工规则
       ```
       e_search_dict_map(
           { 
              "status:2??": "ok", 
              "status:3??": "redirect",
               "status:4??": "auth",
               "status:5??": "server_error",
           },
           "status_desc", 
          multi_match=true, 
          multi_join="测试",
       )
       ```
       
     
     - 加工结果
       ```
       status:200,300 
       status_desc:ok测试redirect
       ```
       
      
   
- 更多参考 支持和其他函数组合使用。
  
 
 #### e_search_table_map
对某列（查询字符串）以及其匹配的值的表格数据进行映射。
- **函数格式**
  ```
  e_search_table_map(data, inpt, output_fields, multi_match=false, multi_join=" ", missing=None, mode="fill-auto")
  ```
  
- **参数说明**
  
  |   **参数名称**    |           **数据类型**            | **是否必填** |                                                                                                         **说明**                                                                                                         |
  |---|---|---|---|
  | data          | Table                         | 是        | 映射关系的表格，表格某一列必须是查询字符串。                                                                                                                                                                                                 |
  | inpt          | String                        | 是        | 表格中用于匹配搜索的字段名。                                                                                                                                                                                                         |
  | output_fields | String，String List或Tuple List | 是        | 表格中映射出的字段，可以是字符串、列表或者其名称映射元组的列表。                                                                                                                                                                                       |
  | multi_match   | Boolean                       | 否        | 是否允许匹配多个字段。默认为false表示不匹配多个字段，会返回匹配到的第一个字段值。支持使用multi_join来拼接多个匹配的值。                                                                                                                                                    |
  | multi_join    | String                        | 否        | 匹配多个字段时，多值的连接字符串，默认为空格。当multi_match值为true时生效。                                                                                                                                                                          |
  | missing       | String                        | 否        | 无匹配字段时，将该参数的取值赋给输出字段output_fields。默认为None表示不做映射赋值操作。 如果表格中包含默认匹配\*，由于\*的优先级高于missing，此时missing将不起作用。 |
  | mode          | String                        | 否        | 字段的覆盖模式。默认为fill-auto。                                                                                                                                                                                                  |
     
  
- **返回结果**
  返回查询匹配中后的映射结果。
  
- **函数示例**
  1. 示例1：根据映射关系的表格，将日志中city字段映射出pop和province字段。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "sh"
       }
       ```
       例如，以下映射关系的表格，其中search列是查询字符串。
       
       | **search** | **pop** | **province** |
       |---|---|---|
       | city==nj   | 800     | js           |
       | city==sh   | 2000    | sh           |
          
       
     
     - 加工规则
       ```
       e_search_table_map(
           tab_parse_csv("search,pop,province\ncity==nj,800,js\ncity==sh,2000,sh"),
           "search",
           ["pop", "province"],
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: sh 
       province: sh 
       pop: 2000
       ```
       
      
  
  2. 示例2：overwrite模式。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj",
        "province":""
       }
       ```
       
     
     - 加工规则
       ```
       e_search_table_map(
         tab_parse_csv("search,pop,province\ncity==nj,800,js\ncity==sh,2000,sh"),
         "search",
         ["pop", "province"],
       )
       ```
       
     
     - 加工结果
       ```
       pop: 800
       data: 123
       city: nj 
       province: js
       ```
       
      
  
  3. 示例3：无匹配时目标字段的值由missing指定。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "wh",
        "province":""
       }
       ```
       
     
     - 加工规则
       ```
       e_search_table_map(
           tab_parse_csv("search,pop,province\ncity==nj,800,\ncity==sh,2000,sh"),
           "search",
           "province",
           missing="Unknown",
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: wh 
       province: Unknown
       ```
       
      
  
  4. 示例4：允许匹配多个字段（multi_match模式）。
     - 测试数据
       ```
       {
        "data": 123,
        "city": "nj,sh",
        "province":""
       }
       ```
       
     
     - 加工规则
       ```
       e_search_table_map(
           tab_parse_csv("search,pop,province\ncity:nj,800,js\ncity:sh,2000,sh"),
           "search",
           "province",
           multi_match=true,
           multi_join=",",
       )
       ```
       
     
     - 加工结果
       ```
       data: 123
       city: nj,sh
       province: js,sh
       ```
       
      
   
 
