# DSL语法说明
#### 语法介绍
Algorithm query接口是GES提供的一种graph DSL，可以利用DSL来完成对图的查询与计算。服务规划为DSL增加各种查询算子，细粒度的基础计算模式算子，从而使得DSL支持用户自定义的图遍历，多跳过滤查询，模式匹配，相似性算法，社区算法，推荐算法，路径分析，业务定制算法等。
例如查询点1、2为起点，第二跳的邻居点集并返回：
```
Match<Vertex> v(['1','2']); v.repeat(bothV()).times(2).limit(3); return v;
```
#### DSL语句构造
语句(statement)是依序执行的DSL程序片段，为了丰富DSL表达自定义算法的能力，DSL支持以下几种语句：选择语句、循环语句、表达式语句、算子操作语、声明语句、跳转语句。一般DSL的结构通常由声明语句+表达式语句+跳转语句组成。如：
```
GlobalAcc<Sum,int> g=0;  //声明语句，声明了一个聚合器变量g
g+=1*3+2;                //表达式语句，对聚合器g进行聚合操作，g=g+1*3+2
return g;                //跳转语句，结束DSL并返回g
```
![](https://support.huaweicloud.com/api-ges/public_sys-resources/note_3.0-zh-cn.png)
**关于选择语句\&循环语句**，当前仅有如下语句支持，写在选择、循环\&lambda表达式中：
1. 各类expression赋值/聚合
2. Vertex匹配器的update算子
3. Vertex匹配器的gather算子
 
表1DSL语法说明 
| 语法     | 关键词                          | 说明                                           |
|:---|:---|:---|
| 选择语句   | if                           | 有条件地执行语句。                                    |
| 循环语句   | while                        | 重复执行语句。                                      |
| 跳转语句   | return                       | 返回不同类型的结果。                                   |
| 声明语句   | Match\< ? \>                 | 声明一个匹配器Match，可快速匹配图数据进而进行更多操作。               |
| 声明语句   | VertexAcc\< ?, ?\>           | 声明一个点聚合器，可以定义点上额外的属性/变量。并通过Match批量操作点上额外的变量。 |
| 声明语句   | GlobalAcc\< ?, ?\>           | 声明一个全局聚合器，定义全局可操作的变量。                        |
| 表达式语句  | operator=                    | 变量赋值。                                        |
| 表达式语句  | operator+=                   | 变量聚合操作。                                      |
| 表达式语句  | 算术运算+, -, \*, /              | 算术运算。                                        |
| 表达式语句  | 比较运算\>, \>=, ==, \<, \<=, != | 比较运算。                                        |
| 表达式语句  | lambda表达式                    | 匿名表达式。                                       |
| 算子操作语句 | repeat                       | 支持用户进行多跳过滤查询。包括相关语法emit, times, limit等。      |
| 算子操作语句 | update                       | 用于执行定义在匹配器上一组批量操作。                           |
| 算子操作语句 | gather                       | 用于执行定义在匹配器上一组批量操作。                           |
| 算子操作语句 | pick                         | 快速获取n个随机点。                                   |
| 算子操作语句 | init                         | 重新初始化点匹配器的点集。                                |
| 算子操作语句 | insert                       | 向点匹配器中增加匹配的点集。                               |
| 算子操作语句 | move                         | 将other_match_vertex中的点集快速移动至match_vertex匹配器。 |
| 算子操作语句 | subgraph                     | 主要用于return语句，可以支持返回点匹配器match_vertex的诱导子图。    |
| 算子操作语句 | intersection                 | 对两个点匹配器取交集。                                  |
| 算子操作语句 | pattern                      | 执行一条完整的cypher语句，并将结果放置到点匹配器中。                |
   
1. **选择语句** ：**if语句**
   ```
   if(expression) {
           true 分支语句
       }
   ```
   有条件地执行语句。
   ```
   GlobalAcc<Sum, int> threshold = 10;   
   Match<Vertex> v(['1', '2']); 
   if(threshold < 20) {
        v.repeat(outV().has('name', 'peter')).times(2).emit();
   }
   ```
   
2. **循环语句** ：**while语句**
   ```
   while(expression) {
           true 分支语句
       }
   ```
   有条件地重复执行一些代码。
   ```
   GlobalAcc<Sum, int> loop = 0;   
   VertexAcc<Sum, int> score = 1;
   Match<Vertex> v(['1', '2']); 
   while(loop < 10) {
        loop +=1;
        v.update((v)->{v.score = 1 + 2 * v.score;});
   }
   ```
   
3. **跳转语句** **：return语句**
   支持返回不同类型和格式的json，如下表所示：
   
   | 类型        | 返回类型   | 说明                   |
   |:---|:---|:---|
   | Match     | 点集     | -                    |
   | VertexAcc | map    | 默认情况下，初始化后未更改的值不会输出。 |
   | GlobalAcc | 单值     | -                    |
   | subgraph  | 点集\&边集 | -                    |
      
   如Match了一些点，可以直接返回：
   - commands语句：
     ```
     Match<Vertex> v(['1','2']);
     return v;
     ```
     返回结果：
     ```
     {
         "vertices": [
             {
                 "id": "1",
                 "label": "movie",
                 "properties": {
                     "genres": [
                         "Comedy"
                     ]
                 }
             }
             ...
         ]
     }
     ```
     
   
   - 也可以直接返回ACC的值：
     ```
     GlobalAcc<Max,int> g1=10; 
     g1+=2;
     return g1;
     ```
     返回结果：
     ```
     {
         "data": {
             "value": 10
         }
     }
     ```
     
   
   - 假设想得到某个match点集的诱导子图以便于后续任务执行(如在页面上绘图)：
     ```
     Match<Vertex> v(['1','2']);
     return v.subgraph();
     ```
     返回结果：
     ```
     {
         "data": {
             "vertices": [
                 {
                     "id": "1",
                     "label": "user",
                     "properties": {
                         //balabala
                     }
                 },
                 {
                     "id": "2",
                     "label": "movie",
                     "properties": {
                         //balabala
                     }
                 }
             ],
             "edges": [
                 {
                     "index": "0",
                     "source": "1",
                     "label": "rate",
                     "properties": {
                         //balabala
                     },
                     "target": "2"
                 }
             ]
         }
     }
     ```
     
    
4. **表达式语句**
   表达式是运算符和操作数的序列，其指定一项计算。不同的语句都有可能使用到表达式，如循环语句与选择语句可能会用到表达式来做分支或循环条件的表达，表达式也可以用于对变量的赋值，聚合操作。
   - 常见的运算符如下表所示：
     
     | 常见运算符         | 形式                        | 符号                       |
     |:---|:---|:---|
     | 赋值            | a=b;                      | =                        |
     | 聚合            | a+=b                      | +=                       |
     | 算数Mathmetical | a+b;a-b;a\*b;a/b          | +, -, \*, /              |
     | 比较Comparison  | a\>b; a=b;a\<=b;a==b;a!=b | \>, \>=, ==, \<, \<=, != |
        
     ![](https://support.huaweicloud.com/api-ges/public_sys-resources/note_3.0-zh-cn.png)
     聚合操作的计算由[聚合器]的定义决定。
     
   
   - 表达式之间有一定的优先级，如下表所示：
     
     | **优先级** | **运算符**                                                                                                                                                | **结合性** |
     |:---|:---|:---|
     | 1       | ()函数调用 \[\]下标 .成员访问 a++后缀自增 a--后缀自减 | 从左到右    |
     | 2       | a\*b a/b 乘法除法                                                                                                                                          | 从左到右    |
     | 3       | a+b a-b 加法减法                                                                                                                                           | 从左到右    |
     | 4       | \< \<= \> \>= 关系运算符                                                                                                                                    | 从左到右    |
     | 5       | == != 相等性运算符                                                                                                                                           | 从左到右    |
     | 6       | and 逻辑与                                                                                                                                                | 从左到右    |
     | 7       | or 逻辑或                                                                                                                                                 | 从左到右    |
     | 8       | = += 赋值，聚合操作                                                                                                                                           | 从右到左    |
        
     
   
   - **表达式类型**
     由于变量的特殊性（即存在不同类型的聚合器），DSL将表达式分为以下几类：
     1. numeric expression - 纯数值计算表达式。
     
     2. vertexacc expression - 表达式中包含vertexacc变量。
     
     3. globalacc expression - 表达式中包含globalacc变量。
     
     
     ```
     1+2*3 //纯数值类型表达式
     GlobalAcc<Sum, int> diff = 0;
     VertexAcc<Sum, int> score = 0;
     Match<Vertex> v(['小明']);
     1+diff*2 //带有globalAcc一起计算的表达式， 属于globalacc expression
     1+v.score*2 //带有vertexAcc一起计算的表达式， 属于vertexacc expression
     ```
     
   
   - **表达式升格表**
     不同类型的表达式在赋值和计算上，存在不同的限制。即，不同类型互相之间的赋值和计算是否合法的限制。
     以下表达用于表示赋值/聚合操作对于不同表达式的支持情况。
     
     | **左值** **/** **右值** | **numeric expression** | **vertexacc expression** | **globalacc expression** |
     |:---|:---|:---|:---|
     | vertexacc variable  | vertexacc expression   | 支持部分，需为同一个Match          | vertexacc expression     |
     | globalacc variable  | globalacc expression   | 不支持                      | globalacc expression     |
        
     
   
   - **数值提升策略**
     在表达式的计算过程中，纯数值可转化为某些其他类型的数值进行计算。下面仅列出当前支持的数值类型的提升策略：
     1. 整数提升：bool可转换到int，值false变为0，true变为1。
     
     2. 浮点提升：float类型的纯数值可转化为double类型，值不更改。
      
   
   - **数值转换**
     暂不支持数值转换。不同于提升，数值转换可以更改值，而且有潜在的精度损失。
     
   
   - **Lambda表达式**
     ```
     ($parameters)->{statements;}
     ```
     主要用于可用于接收Function的某些step，如gather,update均支持传入Lambda。在Lambda中操纵GlobalAcc,VertexAcc等变量来完成相应的赋值, 聚合。需要注意：
     1. 不需要声明参数类型，可以统一识别。
     
     2. Lambda中可访问context中的GlobalAcc。
     
     3. Lambda可作为单独的函数体执行，其传入参数需要为空。
     
     
     ```
     GlobalAcc<Sum,int> g1=0;
     g1+=2*10+1;
     ()->{g1+=2*10+1;} //与上一句同样的效果
     //update接收lambda作为参数：
     v.update((v1)->{g1+=v1.acc1*2+g2+v1.acc2;});
     ```
     
    
 #### 变量声明
**Match匹配器**
1. Match匹配器说明 DSL支持用户定义能够进行匹配和相关操作的点，路径，子图等对象。声明并初始化匹配器后，可以使用匹配器算子批量操作点集，详情请查看[Match匹配器算子]一节。使用以下语句声明并初始化匹配器：
   ```
   Match<[Vertex|Path|Subgraph]> $variable;
   ```
   DSL支持用户定义能够进行匹配和相关操作的点，路径，子图等。
   ```
   Match<Vertex>      快速匹配、操作点
   ```
   
2. Match\<Vertex\>匹配器：可快速匹配，操作点集的Match匹配器。
   ```
   Match<[ Vertex ]> $match_vertex_variable; 
   Match<[ Vertex ]> $match_vertex_variable($VertexList);
   ```
   可以有多种方式为Match\<Vertex\>匹配或初始化点集：
   ```
   Match<Vertex> v(['1','2']); //以点ID的方式直接匹配
   Match<Vertex> v();          //仅定义Match变量，匹配的点为空
   Match<Vertex> v; 
   v.pattern('match (n:user) where n.age>30 return n limit 10');  //以Cypher语句的结果来匹配过滤后的点
   ```
   DSL为Match\<Vertex\>提供一些大量的算子，如pattern, init, pick等，可查看[Match匹配器算子]章节了解详情。
   
3. Match匹配器与聚合器的关系 可以定义聚合器来保存数值和计算。每一种类型的匹配器都能批量操作其对应的聚合器。
   例如使用Match\<Vertex\>可以对指定的点集进行聚合计算。
   
 
**聚合器**
1. 聚合器说明
   使用聚合器来简化数值在计算过程中的表达。不同类型的聚合器定义了不同范围的批量聚合操作。
   ![](https://support.huaweicloud.com/api-ges/public_sys-resources/note_3.0-zh-cn.png)
   DSL不支持直接定义各种数值类型的变量来承载计算过程中产生的数据，而通过提供聚合器来保证各种使用场景下的简化操作。
   1. VertexAcc可以定义点上额外的"属性（变量）"。并通过Match\<Vertex\>批量操作点上额外的变量。
   
   2. GlobalAcc可以定义全局可操作的变量。
    
   ```
   聚合器声明语法：
   Accumulator<Aggregator Operator, NumericType> v;
   参数说明：
   NumericType： int(暂不支持float,double)
   Aggregator Operator: Sum,Max,Min
   ```
   DSL支持用户定义不同的聚合器来简化算法的操作。目前支持两种类型的聚合变量：
   1. VertexAcc\<Aggregator Operator, type\>
   
   2. GlobalAcc\<Aggregator Operator, type\>
   
   
   聚合器可进行以下操作：
   1. 初始化操作：定义一个聚合器并赋初值
   
   2. 赋值操作：重置聚合器数值
   
   3. 聚合操作：根据定义的Aggregator Operator来进行聚合操作
    
2. 聚合操作Aggregator Operator说明 提供不同的聚合操作，如Sum/Max/Min，通过operator+=来更新变量。
   ```
   $match_vertex.$vertex_accumulator += $value;
   $global_accumulator += $value;
   ```
   
3. 点聚合器VertexAcc\<Aggregator Operator, type\> VertexAcc可以用来快速定义点上额外的"属性/变量"。并通过Match\<Vertex\>批量操作点上额外的变量。为计算过程提供极大的便利。
   ```
   VertexAcc<Sum, float> score = 0.5;
   ```
   每定义一个VertexAcc, DSL会为全图的每一个点都分配一个type类型的变量。可以通过Match\<Vertex\>来操作定义的VertexAcc。如：
   ```
   VertexAcc<Sum, int> score = 0;
   //此时小明.score=0, 李雷.score=0
   Match<Vertex> v(['小明', '李雷']);
   //此时小明.score=0, 李雷.score=0
   v.score += 1; //该操作会同时对'小明', '李雷'上的score进行聚合(Sum)操作，即两者都加1。
   //此时小明.score=1, 李雷.score=1
   v.score = 10; //该操作会同时给'小明', '李雷'上的score赋值，即两者更新为10。
   //此时小明.score=10, 李雷.score=10
   v.score += 5; //该操作会同时对'小明', '李雷'上的score进行聚合(Sum)操作，即两者都加5。
   //此时小明.score=15, 李雷.score=15
   ```
   VertexAcc可以被表达式操作，目前支持数值表达式，globalacc表达式，vertexacc表达式进行聚合和赋值操作。
   ```
   VertexAcc<Sum, int> score = 0;
   VertexAcc<Sum, int> factor = 1;
   GlobalAcc<Sum, int> alpha = 10;
   Match<Vertex> v(['小明']);
   //此时小明.score=0
   v.score = alpha*2+3; //该操作会对'小明'上的score值进行赋值操作。
   //此时小明.score=alpha*2+3=10*2+3=23
   v.score += v.factor*2; //该操作会对'小明'上的score值进行聚合操作。
   //此时小明.score=小明.score+小明.factor*2=23+1*2=25
   ```
   
4. 全局聚合器 GlobalAcc\<Aggregator Operator, type\> 每定义一个GlobalAcc, DSL会在DSL作用域内创建一个type类型的变量。直接操作GlobalAcc即可。如：
   ```
   GlobalAcc<Sum, int> diff = 0;//定义一个GlobalAcc
   diff += 1;//进行聚合操作，即diff=Sum(0,1)
   //此时diff=1
   diff = 2*3;//进行赋值操作，即diff=2*3
   //此时diff=6
   GlobalAcc<Sum, int> g2 = 6;//定义一个GlobalAcc
   diff += g2;//进行聚合操作，即diff=Sum(6, g2)
   //此时diff=12
   ```
   GlobalAcc可以被表达式操作，目前支持数值表达式，globalacc表达式对GlobalAcc进行聚合和赋值操作。
   ```
   GlobalAcc<Sum, int> alpha = 0;
   GlobalAcc<Sum, int> beta= 10;
   alpha = beta*2+3;
   //此时alpha=beta*2+3=10*2+3=23
   ```
   
 #### 算子介绍
**Match匹配器算子**
定义了一个[Match匹配器]后，可以通过不同的操作算子来辅助图上的计算和查询。如repeat, gather, update, pattern等。
不同的类型的Match，对应的操作算子有所不同。
| **算子**               | **说明**          | **匹配器** | **匿名表达式** | **选择** **/** **循环语句** |
|:---|:---|:---|:---|:---|
| repeat               | 类gremlin多跳过滤    | Vertex  | ×         | ×                     |
| pick                 | 随机取点            | Vertex  | ×         | ×                     |
| pattern(2.3.11)      | 执行cypher        | Vertex  | ×         | ×                     |
| update               | 实现定义在匹配器上一组批量操作 | Vertex  | √         | √                     |
| gather               | 实现定义在匹配器上一组批量操作 | Vertex  | √         | √                     |
| init(2.3.12)         | 指定id初始化匹配点集     | Vertex  | ×         | ×                     |
| insert(2.3.12)       | 向匹配器中增加新的点      | Vertex  | ×         | ×                     |
| move(2.3.12)         | 快速搬移其他匹配器点集     | Vertex  | ×         | ×                     |
| intersection(2.3.12) | 求点交集            | Vertex  | ×         | ×                     |
| subgraph(2.3.12)     | 求诱导子图           | Vertex  | ×         | ×                     |
   
- **repeat**
  支持用户进行多跳过滤查询，其语法与gremlin中的repeat非常接近。其语义表达能力丰富，特别适用于关系链路查询。
  例如，表示从点1,2出发向out方向执行过滤name=peter两跳查询，用gremlin可以表示为：
  ```
  g.V('1','2').repeat(out().has('name','peter')).times(2).emit().dedup()
  ```
  在DSL可以将以上功能写为：
  ```
  Match<Vertex> v(['1','2']);
  v.repeat(outV().has('name','peter')).times(2).emit();
  ```
  - repeat step包含一些独特的关联step：
    
    | **参数** | **是否必选** | **类型**         | **默认** | **说明**                                                           |
    |:---|:---|:---|:---|:---|
    | repeat | 是        | Traversal step | 无      | 执行repeat的规则。                                                     |
    | times  | 否        | Integer        | 2      | 用于限制最长步数。默认值为2，最大值为20。                                           |
    | emit   | 否        | Boolean        | false  | 是否返回所有元素。默认为false。在输出select-as或path模式下，emit的值决定了是否输出不在最终完整路径上的点。 |
    | limit  | 否        | Integer        | 10000  | 控制点/边/path输出个数。                                                  |
       
    
  
  - repeat中的规则组成：遍历步骤+过滤条件。可存在多个规则，以逗号分隔。
    表2遍历步骤说明 
    | 遍历步骤   | 说明           |
    |:---|:---|
    | outV   | out方向邻居点。    |
    | inV    | in方向邻居点。     |
    | bothV  | out,in方向邻居点。 |
    | outE   | out方向边。      |
    | inE    | in方向边。       |
    | bothE  | both方向边。     |
    | otherV | 邻点。          |
       
    表3过滤条件说明 
    | 过滤条件                                      | 说明                          |
    |:---|:---|
    | has(key)                                  | 属性名key是否存在。                 |
    | has(key, value)                           | 属性名key的值是否为value。           |
    | hasLabel(values) (V2.3.5)                 | label值是否为values中的一个。        |
    | and(filter operator A, filter operator B) | 过滤条件的逻辑操作符，需同时满足A与B条件。可嵌套。  |
    | or(filter operator A, filter operator B)  | 过滤条件的逻辑操作符，满足A与B条件其一即可。可嵌套。 |
       
    ```
    and(has('person'), or(has('name', 'peter'), has('age', '30')))
    has('person') //存在属性名'person'
    has('name', 'peter') //属性名'name'的值为'peter'
    hasLabel('movie','user') //label值为movie或user
    and( has('name', 'peter'), has('age', '30')) //属性name为peter且age等于30
    ```
    
   
- **update**
  ```
  $match_vertex.update($lambda_func);
  ```
  update算子用于实现定义在匹配器上一组批量操作。当前仅支持：Match\<Vertex\>
  Match\<Vertex\>上的Update操作会将传入的Lambda函数中定义的所有操作作用在Match匹配的点上。
  点匹配器Match\<Vertex\>仅接收包含一个输入参数的Lambda表达式。
  ```
  Match<Vertex> v(['1',2']);
  VertexAcc<Max,int> acc=1; 
  GlobalAcc<Sum,int> g=0;
  v.update( (v1)->{g+=v1.acc*2;} ); //g='1'.acc*2+'2'.acc*2=1*2+1*2=4
  return g; //将返回g=4;
  ```
  
- **gather**
  ```
  $match_vertex.gather($lambda_func);
  ```
  gather算子用于实现定义在匹配器上一组批量操作。当前仅支持Match\<Vertex\>
  - **Match\<Vertex\>的gather**
    Match\<Vertex\>上的Gather操作会将传入的Lambda函数中定义的所有操作作用在Match匹配的点的边上。
    点匹配器Match仅接收包含两个输入参数的Lambda表达式。第一个参数指代边上的source点，第二个参数指代边上的target点。
    ```
    Match<Vertex> v(['1',2']);
    VertexAcc<Max,int> acc=1; 
    GlobalAcc<Sum,int> g=0;
    v.gather( (s,t)->{g+=s.acc*2+t.acc;} ); //该操作会同时作用在点1,点2的边上。即1-2, 1-3, 2-3,  2-1
    //g=g + 1.acc*2+2.acc + 1.acc*2+3.acc + 2.acc*2+1.acc + 2.acc*2+3.acc
    //g=0 + 3 + 3 + 3 + 3=12
    return g;
    ```
    
   
- **pick**
  ```
  $match_vertex.pick(n);
  ```
  pick支持向Match\<Vertex\>中随机匹配选择n个点。该功能能够帮助用户快速获取n个随机点。
  ```
  Match<Vertex> v();
  v.pick(10); //v中随机匹配选择10个点
  return v; //将返回10个随机点信息
  ```
  
- **init(2.3.12)**
  ```
  $match_vertex.init([vertex_list]); //可指定点id列表
  $match_vertex.init(vertexid); //指定单id
  ```
  重新设置点匹配器的点集。
  ```
  Match<Vertex> v(['1','2']);
  return v;//这里返回点1和2的信息
  Match<Vertex> v(['1','2']);
  v.init(['3','4']);
  return v;//这里返回点3和4的信息
  ```
  
- **insert(2.3.12)**
  ```
  $match_vertex.insert([vertex_list]); //可指定点id列表
  $match_vertex.insert(vertexid); //指定单id
  ```
  向点匹配器中增加匹配的点集。
  ```
  Match<Vertex> v(['1','2']);
  return v;//这里返回点1和2的信息
  Match<Vertex> v(['1','2']);
  v.insert(['3','4']);
  return v;//这里返回点1,2,3,4的信息
  ```
  
- **move(2.3.12)**
  ```
  $match_vertex.move(other_match_vertex);
  ```
  将other_match_vertex中的点集快速移动至match_vertex匹配器。该算子可以完成一个匹配器对另一个匹配器的赋值，但是不产生复制效果，而是类似于c++中的移动语义，将原有的匹配器点集搬移至新的匹配器。操作后，原有的匹配器点集会被清空。
  ```
  Match<Vertex> v1(['1','2']);
  Match<Vertex> v2(['3','4']);
  v1.move(v2);//v1=[3,4],v2=[]
  return v1;//这里返回点3和4的信息
  ```
  
- **subgraph(2.3.12)**
  ```
  $match_vertex.subgraph();//返回匹配器点集的诱导子图
  $match_vertex.subgraph(filter_step);//返回匹配器点集的诱导子图，带边上过滤
  ```
  主要用于return语句，可以支持返回点匹配器match_vertex的诱导子图。
  取subgraph时，可以设置边上的过滤条件：filter_step, 其语法参考repeat章节中的filter operator:
  ```
  Match<Vertex> v(['1','2']);
  return v.subgraph();//这里返回点1和2,以及1和2之间的边集
  Match<Vertex> v(['1','2','3']);
  return v.subgraph(has(year, 2022));//这里返回点1和2,以及1和2之间的边集
  ```
  
- **Set basic operations（2.3.12）**
  集合操作可以支持对各个匹配器中对象进行并集，交集等集合类操作。
  intersection（2.3.12）
  ```
  Match<Vertex> start(['1','2']);
  Match<Vertex> target(['2']);
  Match<Vertex> set;
  start.intersection(target);
  return start;//返回点2
  ```
  
- **Pattern Matching ：pattern(2.3.11)**
  DSL借用cypher的语法来表达模式匹配的功能。如点集的匹配，路径的匹配，子图的匹配等。
  支持cypher的语句：
  
  | 语句             | 支持情况 |
  |:---|:---|
  | match(2.3.11)  | 部分支持 |
  | limit(2.3.11)  | 支持   |
  | return(2.3.11) | 支持   |
     
  DSL使用模式匹配时通过Match变量的step-pattern来实现。
  例如需要通过某种规则来匹配点：
  ```
  Match<Vertex> v;
  v.pattern('match (n:user) where n.age>30 return n limit 10');
  ```
  pattern中是一句完整的cypher语句，其过滤了10个点并返回给Match\<Vertex\>。
  **关于cypher中string的问题**
  由于pattern的语法是由单引号包含整条完整的cypher语句，当cypher中出现需要表达的string时，如id或属性值，需要使用双引号。
  当使用Rest API调用DSL时，需要对双引号加转义字符\\。如：
  ```
  Match<Vertex> v;
  v.pattern('match (n) where id(n)=\"12\" return n');
  return v;
  ```