DSL语法说明

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的

关于选择语句&循环语句，当前仅有如下语句支持，写在选择、循环&lambda表达式中：

1. 各类expression赋值/聚合
2. Vertex匹配器的update算子
3. Vertex匹配器的gather算子

表1 DSL语法说明

语法	关键词	说明
选择语句	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了一些点，可以直接返回：

   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	>, >=, ==, <, <=, !=

     

     聚合操作的计算由聚合器的定义决定。

   • 表达式之间有一定的优先级，如下表所示：

     优先级	运算符	结合性
     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;});

聚合器

1. 聚合器说明

   使用聚合器来简化数值在计算过程中的表达。不同类型的聚合器定义了不同范围的批量聚合操作。

   

   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