DSL Syntax

Match<Vertex> v(['1','2']); v.repeat(bothV()).times(2).limit(3); return v;

DSL Statement Construction

Statements are DSL program fragments that are executed in sequence. To enrich DSL's capability of expressing user-defined algorithms, DSL supports the following statements: selection statement, loop statement, expression statement, operator operand, declaration statement, and jump statement. Typically, the DSL structure consists of a declaration statement, an expression statement, and a jump statement. For example:

GlobalAcc<Sum,int> g=0; // Declaration statement, which declares an aggregator variable g
g+=1*3+2;                // Expression statement, which is used to perform the aggregation operation on the aggregator g. g = g + 1 x 3 + 2
return g;                // Jump statement, which ends DSL and returns g

Currently, only the following selection and loop statements are supported, which are written in selection, loop, and lambda expressions:

1. Assignment/aggregation of various expressions
2. Update operator of the Vertex matcher
3. Gather operator of the Vertex matcher

Table 1 DSL syntax description

Syntax	Keyword	Description
Select statement	if	Executes a statement conditionally.
Loop statement	while	Executes statements repeatedly.
Jump statement	return	Returns different types of results.
Declaration statement	Match< ? >	Declares a matcher Match to quickly match graph data for more operations.
	VertexAcc< ?, ?>	Declares a vertex aggregator to define additional properties/variables on a vertex. Match can be used to perform operations on additional variables on vertices in batches.
	GlobalAcc< ?, ?>	Declares a global aggregator to define globally operable variables.
Expression statement	operator=	Assigns values to variables.
	operator+=	Variable aggregation operation
	Arithmetic operations +, -, *, /	Arithmetic operations
	Comparison operations >, >=, ==, <, <=, !=	Comparative operations
	lambda expression	Anonymous expressions
Operator operation statement	repeat	Allows users to perform multi-hop filtering query. The syntax includes emit, times, and limit.
	update	Performs a set of batch operations defined on the matcher
	gather	Performs a set of batch operations defined on the matcher
	pick	Quickly obtains N random vertices
	init	Reinitializes the vertex set of the vertex matcher
	insert	Adds a matching vertex set to the vertex matcher
	move	Quickly moves the vertex set in other_match_vertex to the match_vertex matcher
	subgraph	It is mainly used in the return statement. It can return guidance subgraphs of the match_vertex vertex matcher.
	intersection	Takes the intersection of two vertex matchers
	pattern	Executes a complete Cypher statement and places the result in the vertex matcher

1. Select statement: if

   if(expression) {
           true Branching statement
       }

   Executes a statement conditionally.

   GlobalAcc<Sum, int> threshold = 10;   
   Match<Vertex> v(['1', '2']); 
   if(threshold < 20) {
        v.repeat(outV().has('name', 'peter')).times(2).emit();
   }

2. Loop statement: while

   while(expression) {
           true Branching statement
       }

   Executes some code repeatedly and conditionally

   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. Jump statement: return

   Returns JSON files of different types and formats

   Type	Return Type	Description
   Match	Vertex set	-
   VertexAcc	map	By default, values that are not changed after initialization are not output.
   GlobalAcc	Single value	-
   subgraph	Vertex set and edge set	-

   If some vertices are matched, they can be directly returned:

   Match<Vertex> v(['1','2']);
   return v;
   {
       "vertices": [
           {
               "id": "1",
               "label": "movie",
               "properties": {
                   "genres": [
                       "Comedy"
                   ]
               }
           }
           ...
       ]
   }

   Alternatively, ACC values can be directly returned.

   GlobalAcc<Max,int> g1=10; 
   g1+=2;
   return g1;
   {
       "data": {
           "value": 10
       }
   }

   Assume that you want to obtain the guidance subgraph of a match vertex set for subsequent task execution (for example, drawing on the canvas).

   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. Expression statement

   An expression is a sequence of operators and operands, which specifies a calculation. Different statements may use expressions. For example, loop statements and selection statements may use expressions to express branches or loop conditions. Expressions can also be used to assign values to variables and perform aggregation operations.

   • The following table lists common operators:

     Common Operator	Form	Symbol
     Assignment	a=b;	=
     Aggregation	a+=b	+=
     Mathmetical	a+b;a-b;a*b;a/b	+, -, *, /
     Comparison	a>b; a=b;a<=b;a==b;a!=b	>, >=, ==, <, <=, !=

     

     The calculation of aggregation operations is determined by the definition of Aggregator.

   • The following table lists the priorities among expressions:

     Priority	Operator	Combination
     1	() Function call [] Subscript .Member access a++ Suffix auto-increment a-- Suffix auto-decrement	Left to right
     2	a*b a/b Multiplication and division	Left to right
     3	a+b a-b Addition and subtraction	Left to right
     4	< <= > >= Relational operators	Left to right
     5	== != Equality operators	Left to right
     6	and Logical AND	Left to right
     7	or Logical OR	Left to right
     8	= += Assignment, aggregation operations	Right to left

   • Expression types

     Due to the particularity of variables (different types of aggregators), DSL classifies expressions into the following types:

     1. numeric expression - Numerical expression
     2. vertexacc expression - Expression containing the vertexacc variable
     3. globalacc expression - Expression containing the globalacc variable

     1+2*3 // Numerical expression
     
     GlobalAcc<Sum, int> diff = 0;
     VertexAcc<Sum, int> score = 0;
     Match<Vertex> v(['Tom']);
     
     1+diff*2 // Expression with globalAcc, which belongs to globalacc expression
     1+v.score*2 // Expression with vertexAcc, which belongs to vertexacc expression

   • Expression upgrade table

     There are different constraints on assignment and calculation for different types of expressions. That is, whether the assignment and calculation between different types are valid is restricted.

     The following expressions are used to indicate whether assignment/aggregation operations support different expressions.

     Left Value/Right Value	Numeric Expression	VertexAcc Expression	GlobalAcc Expression
     vertexacc variable	vertexacc expression	Partially supported, the same matcher required	vertexacc expression
     globalacc variable	globalacc expression	Not supported	globalacc expression

   • Value promotion strategy

     During the calculation of an expression, a right value can be converted into a value of another type. The following lists only the supported value promotion strategies:

     1. Integer value promotion: Boolean values can be converted to integer values. The value false changes to 0, and the value true changes to 1.
     2. Floating-point value promotion: Right values of the floating-point type can be converted to values of the double type without changing the values.
   • Value conversion

     Value conversion is currently not supported. Unlike promotion, value conversions can change values and have potential precision losses.

   • Lambda expressions

     ($parameters)->{statements;}

     It is mainly used to receive some steps of a function. For example, both the gather and update steps support transferring lambda expressions as parameters. Variables such as GlobalAcc and VertexAcc are used in lambda expressions to assign and aggregate values. Note the following:

     1. The parameter type does not need to be declared and can be identified in a unified manner.
     2. GlobalAcc in the context can be accessed by lambda expressions.
     3. Lambda expressions can be executed as independent function bodies. The input parameters must be empty.

     GlobalAcc<Sum,int> g1=0;
     g1+=2*10+1;
     ()->{g1+=2*10+1;} // Same result as the previous statement
     
     // update receives lambda as a parameter:
     v.update((v1)->{g1+=v1.acc1*2+g2+v1.acc2;});

Aggregator

1. Aggregator description

   Aggregators are used to simplify the expression of values during calculation. Different types of aggregators define different scopes of batch aggregation operations.

   

   DSL does not support direct definition of variables of various numeric types to carry data generated during calculation. Instead, DSL provides aggregators to simplify operations in various application scenarios.

   1. VertexAcc can be used to define additional "properties (variables)" on vertices, and Match<Vertex> can be used to perform operations on additional variables on vertices in batches.
   2. GlobalAcc can be used to define globally operable variables.

   Aggregator declaration syntax:
   Accumulator<Aggregator Operator, NumericType> v;
   
   Parameter description:
   NumericType: int, (float and double types are not supported currently)
   Aggregator Operator: Sum,Max,Min

   DSL allows you to define different aggregators to simplify algorithm operations. Currently, two types of aggregate variables are supported:

   1. VertexAcc<Aggregator Operator, type>
   2. GlobalAcc<Aggregator Operator, type>

   You can perform the following operations on an aggregator:

   1. Initialization: Define an aggregator and assign initial values.
   2. Assignment: Reset the aggregator values.
   3. Aggregation: Perform aggregation operations based on defined aggregator operators.
2. Aggregator operator description

   Different aggregation operations are provided, such as Sum, Max, and Min. Variables are updated using operators + and =.

   $match_vertex.$vertex_accumulator += $value;
   $global_accumulator += $value;

3. Vertex aggregator VertexAcc<Aggregator Operator, type>

   VertexAcc can be used to quickly define additional "property (variables)" on vertices. and Match<Vertex> can be used to perform operations on additional variables on vertices in batches. This significantly facilitates the calculation process.

   VertexAcc<Sum, float> score = 0.5;

   Each time a VertexAcc is defined, DSL allocates a variable of the type type to each vertex in the full graph. You can use Match<Vertex> to perform operations on the defined VertexAcc. For example:

   VertexAcc<Sum, int> score = 0;
   // Tom.score = 0, Jack.score = 0
   Match<Vertex> v(['Tom', 'Jack']);
   // Tom.score = 0, Jack.score = 0
   v.score += 1; // This operation aggregates the scores of Tom and Jack. That is, their scores are increased by 1.
   // Tom.score = 1, Jack.score = 1
   v.score = 10; //This operation assigns values to the scores of Tom and Jack. That is, their scores are updated to 10.
   // Tom.score = 10, Jack.score = 10
   v.score += 5; // This operation aggregates the scores of Tom and Jack. That is, their scores are increased by 5.
   // Tom.score = 15, Jack.score = 15

   VertexAcc can be operated by expressions. Currently, numeric, GlobalAcc, and VertexAcc expressions can be used for aggregation and assignment.

   VertexAcc<Sum, int> score = 0;
   VertexAcc<Sum, int> factor = 1;
   GlobalAcc<Sum, int> alpha = 10;
   Match<Vertex> v(['Tom']);
   // Tom.score = 0.
   v.score = alpha x 2 + 3; // This operation assigns a value to Tom's score.
   // Tom.score = alpha x 2 + 3 = 10 x 2 + 3 = 23
   
   v.score += v.factor*2; // This operation assigns a value to Jack's score.
   // Tom.score = Tom.score + Tom.factor x 2 = 23 + 1 x 2 = 25

4. Global aggregator GlobalAcc<Aggregator Operator, type>

   Each time a GlobalAcc is defined, DSL creates a variable of the type type in the DSL scope. Then, perform operations on GlobalAcc directly. For example:

   GlobalAcc<Sum, int> diff = 0;// Define a GlobalAcc.
   diff += 1;// Perform an aggregation operation, that is, diff = Sum (0,1)
   // diff = 1
   diff = 2 x 3;// Assign a value, that is, diff = 2 x 3
   // diff = 6
   GlobalAcc<Sum, int> g2 = 6;// Define a GlobalAcc.
   diff += g2;// Perform an aggregation operation, that is, diff = Sum(6,g2)
   // diff = 12

   GlobalAcc can be operated by expressions. Currently, numeric and GlobalAcc expressions can be used for aggregation and assignment.

   GlobalAcc<Sum, int> alpha = 0;
   GlobalAcc<Sum, int> beta= 10;
   alpha = beta*2+3;
   // alpha = beta x 2 + 3 = 10 x 2 + 3 = 23