# 脚本代码性能检查规则说明
#### 使用说明
低代码平台支持对已开发好的脚本代码，进行性能检查和兼容性检查，本节将带您了解代码性能检查的规则。
在标准/高级页面编辑页面上方，单击"性能分析"，即可进入性能分析页面。在该页面中，可查看脚本代码的性能检查结果报告和兼容性检查结果报告。
图1进入性能分析页面   
![](https://support.huaweicloud.com/usermanual-astrozero/zh-cn_image_0000001932888408.png "点击放大")
- 脚本代码性能检查 低代码平台对脚本进行性能检查遵循的总体原则是：主要检查SELECT语句中，WHERE查询字段是否创建索引，另外对SELECT查询字段和WHERE限制条件进行检查。
  - 静态检查规则
    - [规则1：SELECT语句需要带上where条件]
    
    - [规则2：SELECT语句中单次limit查询数量需要低于平台最高查询个数5000的限制]
    
    - [规则3：SELECT语句中谨慎使用区间查询条件]
    
    - [规则4：SELECT语句中查询字段不在表的索引库中]
    
    - [规则5：SELECT语句中尽量避免同时从大于等于4张表中取数据]
    
    - [规则6：SELECT语句中聚集函数必须增加别名]
    
    - [规则7：SELECT语句中严禁使用"select from..."形式查询语句]
    
    - [规则8：SELECT语句中拼接的参数值请谨慎使用入参变量]
    
    - [规则9："for"循环中请谨慎使用SELECT语句]
    
    - [规则10：SELECT语句中谨慎使用order by]
     
  
  - 动态检查规则 脚本运行时，触发动态检查。动态检查规则以静态检查规则为基础，无法检查SQL注入以及for循环中的SQL项。
    - 当存在脚本性能问题时，通过弹框界面提示给用户，方便用户直观发现脚本中的问题。
    
    - 当不存在性能问题时，便不展示弹框页面，以免影响用户开发。
     
   
- 兼容性检查 根据当前应用所运行的版本，检查脚本代码中是否存在兼容性问题。
  
 #### 规则1：SELECT语句需要带上where条件
SELECT语句中缺少查询条件，存在由于查询结果数量过大，导致脚本性能不佳的风险。请确认查询结果，如果查询结果数量过大，建议增加限制条件或采用分页查询，分页查询请见下方推荐代码示例。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select object_name from object_demo order by createddate desc")
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select object_name from object_demo where id = ? order by createddate desc")
  ```
  
- 推荐代码示例
  ```
  import * as db from 'db';
  let se = db.sql()
  let sqlResult = []
  for(let i=0; i <1000; i++){
      let query_sql = se.exec("select object_name from object_demo limit ${5000*i},5000")
      sqlResult.push(query_sql)
      if(query_sql.length<5000){
          break
      }
  }
  ```
  
 
 #### 规则2：SELECT语句中单次limit查询数量需要低于平台最高查询个数5000的限制
SELECT语句中单次limit查询数量大于平台限制个数，存在由于查询结果数量过大，导致脚本性能不佳的风险。如果查询结果过大，请判断是否需要增加限制条件或采用分页查询，分页查询请见下方推荐代码示例。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select object_name from object_demo  where object_type = 'A' limit 100000")
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select object_name from object_demo  where object_type = 'A' limit 3000")
  ```
  
- 推荐代码示例
  ```
  import * as db from 'db';
  let se = db.sql()
  let sqlResult = []
  for(let i=0; i <1000; i++){
      let query_sql = se.exec(`select object_name from object_demo limit ${5000*i},5000`)
      sqlResult.push(query_sql)
      if(query_sql.length<5000){
          break
      }
  }
  ```
  
 
 #### 规则3：SELECT语句中谨慎使用区间查询条件
SELECT语句中使用区间查询（"\<\>"、"\<"、"\>"、"\>="、"\<="），存在由于查询结果数量过大，导致脚本性能不佳的风险。如果必须采用区间查询，建议增加limit限制条件，以免影响查询效率。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select object_name from object_demo  where object_num > 50")
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select object_name from object_demo  where object_num > 50 limit 3000")
  ```
  
 
 #### 规则4：SELECT语句中查询字段不在表的索引库中
如果SELECT语句where条件中，查询字段并未创建索引，请判断该字段是否需要创建索引，以提高代码查询效率。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select object_name from object_demo  where object_id = ?")
  ```
  表"object_demo"中的"object_id"并没有创建索引。
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select object_name from object_demo where id = ?")
  ```
  表"object_demo"中的"id"创建了索引。
  
 
 #### 规则5：SELECT语句中尽量避免同时从大于等于4张表中取数据
SELECT语句中，进行多表关联查询时，尽量不要同时从大于或等于4张表中获取数据。如果必须要查询大于或等于4张表的数据时，建议先通过关联少于4张表进行查询，然后根据查询结果再做关联查询，保证每次关联查询的表数量少于4，以提高查询效率。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select a.item as item1, b.item as item2, c.item as item3 ,d.item as item4, e.item as itmem5 from object_demo1 as a object_demo2 as b, object_demo3 as c ,object_demo4 as d, object_demo5 as e where a.id=b.objectid and b.name = c.objectid and c.name = d.objectid and d.name = e.objectid and e.name ='A'")
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  let sqlResult1 = db.sql().exec("select c.item as item3, d.item as item4, e.item as itmem5 from object_demo3 as c ,object_demo4 as d, object_demo5 as e where c.name = d.objectid and d.name = e.objectid and e.name ='A'")
  let sqlResult = []
  let item3s = "'"+sqlResult1.map(item=>{item.item3}).join("','")+"'"
  let sqlResult2 = db.sql().exec('select a.item as item1, b.item as item2, c.item as item3 from object_demo1 as a object_demo2 as b, object_demo3 as c where a.id=b.objectid and b.name = c.objectid and c.item in ('+item3s+')')
  for(let i in sqlResult1){
   for(let j in sqlResult2){
    if i.item3 == j.item3:
     sqlResult.append({
      "item1":j.item1,
      "item2":j.item2,
      "item3":i.item3,
      "item4":i.item4,
      "item5":i.item5
     })
   }
  }
  ```
  
 
 #### 规则6：SELECT语句中聚集函数必须增加别名
SELECT语句中，聚合函数必须使用别名方式存储查询结果，以免因聚合函数返回的结果不一致，导致存在兼容性问题。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select count(*) from object_demo where object_name = 'A'")
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select count(*) as count from object_demo where object_name = 'A'")
  ```
  

- 推荐代码示例
  ```
  ***聚合函数示例 ****
  select count(*) as count_res，
  select max(*) as max_res,
  select min(*) as min_res,
  select avg(*) as avg_res,
  select sum(*) as sum_res
  ```
  
 
 #### 规则7：SELECT语句中严禁使用"select from..."形式查询语句
严禁使用"select ..."形式查询语句，请指出select的具体字段。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select from object_demo where object_name = 'test'")
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select id, object_type from object_demo where object_name = 'test'")
  ```
  
 
 #### 规则8：SELECT语句中拼接的参数值请谨慎使用入参变量
SELECT语句中，拼接的参数值请谨慎使用入参变量，以免引起SQL注入的风险。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = "select id,name from object_demo where id = ";
  errorDemo += input.parameter 
  let errorDemoResult = db.sql().exec(errorDemo)
  ```
  其中，"input.parameter"为脚本入参。
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = "select id,name from object_demo where id = ?";
  let correctDemoResult = db.sql().exec(correctDemo, { params: [input.parameter] })
  ```
  其中，"input.parameter"为脚本入参。
  
 
 #### 规则9："for"循环中请谨慎使用SELECT语句
"for"循环中，请谨慎使用SELECT语句，以免后续进行结果赋值时，由于数据过多，导致内存溢出。
- 错误代码示例
  ```
  import * as db from 'db';
  for (let i = 0; i < input.para.length; i++) {
    db.sql().exec("select id,name from object_demo where id = 'A'");
  }
  ```
  
- 正确代码示例
  ```
  import * as db from 'db';
  db.sql().exec("select id,name from object_demo where id = 'A'");
  ```
  
 
 #### 规则10：SELECT语句中谨慎使用order by
SELECT语句中，请谨慎使用order by。如果需要使用order by，请为排序字段增加索引，以提高查询效率。如果无法增加索引，需要关注是否存在查询性能低下的风险。
- 错误代码示例
  ```
  import * as db from 'db';
  let errorDemo = db.sql().exec("select object_name from object_demo  where object_id = 'A' Order by createdDate")
  ```
  表"object_demo"中的"createdDate"，并没有创建索引。
  
- 正确代码示例
  ```
  import * as db from 'db';
  let correctDemo = db.sql().exec("select object_name from object_demo where id = 'A' Order by createdDate")
  ```
  "object_demo"中的"createdDate"，创建了索引。