SELECT Statement

Search…
SELECT Statement
GSQL Syntax Versions
NOTE: Starting with TigerGraph 2.6, there are now two versions of the GSQL Query Language. Both are available in the product. The original version is called GSQL Syntax V1. GSQL Syntax V2 was introduced to provide more flexible and powerful Pattern Matching. A query indicates which grammar to use in the SYNTAX clause of the CREATE QUERY header. V1 is the default.
As new features are being added to GSQL, some are available only V2. In the future, we plan to transition so that Syntax V2 will be the default.
The key differences between the two grammars:
1.SQL-like Tabular SELECT is only in Syntax V2 (since TigerGraph 3.1)
2.Multi-hop Pattern Matching is only in Syntax V2 (since TigerGraph 2.6)
In V2, each SELECT statement can traverse a multi-hop path.
The traversal direction is under the control of the query writer, with arrowheads on each edge set to show the direction. 
There is no arrowhead outside the parentheses:
Start:s -( (ForwardEdge> | <BackwardEdge):e )- Target:t
Users can write paths that explicitly show multiple hops, and they can use a Kleene star (*) to indicate repetition.
Start:s -(Edge1>:e1)- Middle:m -(<Edge2:e2)- Target:t or
Start:s -(Edge*1..3)- Target:t
In V1 (default), each SELECT statement can traverse one hop (from a set of vertices to their adjacent vertices).
To write a multi-hop query, you write a sequence of SELECT statements.
The traversal action is from left to right, and the notation uses "ASCII art" to depict a connection, either with a rightward facing arrowhead or no arrowhead:
Start:s -( Edges:e )-> Target:t or 
Start:s -( Edges:e )- Target:t
This section discusses the SELECT statement in-depth and covers the following EBNF syntax. Note that there are now two forms for a SELECT statement, the classic GSQL form gsqlSelectBlock, and the new SQL-like form sqlSelectBlock. Since GSQL has always been similar to SQL in many ways, there are only a few differences to know about.
EBNF for Select Statement
1
selectStmt  := gsqlSelectBlock
2
             | sqlSelectBlock
3
 
4
gsqlSelectBlock := gsqlSelectClause
5
               fromClause
6
               [sampleClause]
7
               [whereClause]
8
               [accumClause]
9
               [postAccumClause]*
10
               [havingClause]
11
               [orderClause]
12
               [limitClause]
13
                    
14
sqlSelectBlock := sqlSelectClause
15
               fromClause
16
               [whereClause]
17
               [groupByClause]
18
               [havingClause]
19
               [orderClause]
20
               [limitClause]
21
               
22
gsqlSelectClause := ertexSetName "=" SELECT vertexAlias
23
sqlSelectClause := SELECT [DISTINCT] columnExpr ("," columnExpr)*
24
                   INTO tableName
25
columnExpr := expr [AS columnName]
26
            | aggregator "("[DISTINCT] expr ")" [AS columnName]
27
columnName := name
28
tableName := name
29
​
30
fromClause := FROM (step | stepV2 | pathPattern ["," pathPattern]*)
31
​
32
step   :=  stepSourceSet ["-" "(" stepEdgeSet ")" ("-"|"->") stepVertexSet]
33
stepV2 :=  stepVertexSet ["-" "(" stepEdgeSet ")" "-" stepVertexSet]
34
 
35
stepSourceSet := vertexSetName [":" vertexAlias]
36
stepEdgeSet := [stepEdgeTypes] [":" edgeAlias]
37
stepVertexSet := [stepVertexTypes] [":" vertexAlias]
38
alias := (vertexAlias | edgeAlias)
39
vertexAlias := name
40
edgeAlias := name
41
​
42
stepEdgeTypes := atomicEdgeType | "(" edgeSetType ["|" edgeSetType]* ")"               
43
atomicEdgeType := "_" | ANY | edgeSetType
44
edgeSetType := edgeType | paramName | globalAccumName
45
​
46
stepVertexTypes := atomicVertexType | "(" vertexSetType ["|" vertexSetType]* ")"
47
atomicVertexType := "_" | ANY | vertexSetType
48
vertexSetType := vertexType | paramName | globalAccumName
49
​
50
#----------# Pattern Matching #----------#
51
pathPattern := stepVertexSet ["-" "(" pathEdgePattern ")" "-" stepVertexSet]*
52
​
53
pathEdgePattern := atomicEdgePattern
54
                 | "(" pathEdgePattern ")"
55
                 | pathEdgePattern "." pathEdgePattern
56
                 | disjPattern
57
                 | starPattern
58
                 
59
atomicEdgePattern  := atomicEdgeType		
60
        	        | atomicEdgeType ">"	
61
        	        | "<" atomicEdgeType	
62
               
63
disjPattern := atomicEdgePattern ("|" atomicEdgePattern)*
64
​
65
starPattern := ([atomicEdgePattern] | "(" disjPattern ")") "*" [starBounds]
66
​
67
starBounds := CONST_INT ".." CONST_INT 
68
            | CONST_INT ".." 
69
            | ".." CONST_INT 
70
            | CONST_INT 
71
#----------------------------------------#           
72
sampleClause := SAMPLE ( expr | expr "%" ) EDGE WHEN condition
73
              | SAMPLE expr TARGET WHEN condition
74
              | SAMPLE expr "%" TARGET PINNED WHEN condition
75
 
76
whereClause := WHERE condition
77
​
78
accumClause := [perClauseV2] ACCUM dmlSubStmtList
79
​
80
perClauseV2 := PER "(" alias ["," alias] ")"
81
 
82
postAccumClause := "POST-ACCUM" dmlSubStmtList
83
    
84
dmlSubStmtList := dmlSubStmt ["," dmlSubStmt]*
85
​
86
dmlSubStmt := assignStmt           // Assignment   
87
            | funcCallStmt         // Function Call
88
            | gAccumAccumStmt      // Assignment
89
            | lAccumAccumStmt      // Assignment
90
            | attrAccumStmt        // Assignment
91
            | vAccumFuncCall       // Function Call
92
            | localVarDeclStmt     // Declaration
93
            | dmlSubCaseStmt       // Control Flow
94
            | dmlSubIfStmt         // Control Flow
95
            | dmlSubWhileStmt      // Control Flow
96
            | dmlSubForEachStmt    // Control Flow
97
            | BREAK                // Control Flow
98
            | CONTINUE             // Control Flow
99
            | insertStmt           // Data Modification
100
            | dmlSubDeleteStmt     // Data Modification
101
            | printlnStmt          // Output
102
            | logStmt              // Output
103
​
104
vAccumFuncCall := vertexAlias "." localAccumName ("." funcName "(" [argList] ")")+
105
​
106
groupByClause := GROUP BY groupExpr ("," groupExpr)*
107
groupExpr := expr
108
​
109
havingClause := HAVING condition
110
 
111
orderClause := ORDER BY expr [ASC | DESC] ["," expr [ASC | DESC]]*
112
 
113
limitClause := LIMIT ( expr | expr "," expr | expr OFFSET expr )
Copied!
The SELECT block uses a step pattern or path pattern to select some of the graph's vertices and edges. There are a number of optional clauses that define and/or refine the selection by constraining the vertex or edge set or the result set. The final output of a query is either a vertex set known as the result set or a table.
Size limitation
There is a maximum size limit of 2GB for the result set of a SELECT block . If the result of the SELECT block is larger than 2GB, the system will return no data. NO error message is produced.
GSQL SELECT Statement
EBNF for GSQL Select Statement
1
gsqlSelectBlock := gsqlSelectClause
2
               fromClause
3
               [sampleClause]
4
               [whereClause]
5
               [accumClause]
6
               [postAccumClause]*
7
               [havingClause]
8
               [orderClause]
9
               [limitClause]
10
               
11
gsqlSelectClause := vertexSetName "=" SELECT vertexAlias
Copied!
In classic GSQL, the SELECT statement is an assignment statement with a SELECT block on the right hand side. The initial clause is the SELECT clause: SELECT vertexAlias. Its purpose is to specify which set of vertices from the FROM clause is to become the output. The classic SELECT clause may contain only one item: a vertex alias defined in the FROM clause. As of v3.1, the vertex alias may be from anywhere in a multi-hop pattern, not only an endpoint. GSQL now also supports SQL-like SELECT statements with tabular output.
The fromClause defines a path pattern to traverse in the graph, and each vertex in the path pattern can be given a vertexAlias name. Thus, the SELECT clause picks the set of vertices at one of these points in the pattern -- the source vertices, the target vertices, or those from an interior point in a multi-hop path -- to be the output vertices.

The SELECT block has many optional clauses, which fit together in a logical flow. Overall, the SELECT block starts from a source set of vertices and returns a result set that is either a subset of the source vertices or a subset of their neighboring vertices. Along the way, computations can be performed on the selected vertices and edges. The figure below graphically depicts the overall SELECT data flow. While the ACCUM and POST-ACCUM clauses do not directly affect which vertices are included in the result set, they affect the data (accumulators) which are attached to those vertices.
Basic data flow for a classic 1-hop GSQL SELECT statement
FROM Clause: Vertex and Edge Sets
In classic (Syntax v1) GSQL, the FROM clause described one step or hop pattern. In Pattern Matching (Syntax v2), the pattern can be multiple hops long. Path patterns also have many other options for finer control and greater flexibility.
FROM clause
1
fromClause := FROM (step | stepV2 | pathPattern ["," pathPattern]*)
Copied!
A hop or step consists of going from a starting set of vertices, crossing over a set of their edges, to an ending set of vertices. We typically use the names Source and Target for the starting and ending vertex sets: Source -(Edges)-> Target
The step pattern defines constraints for the Source set, the Edge set, and the Target set. The result of the FROM clause can be interpreted as a 3-column virtual table called the match table. Each row is a 3-element tuple: (source vertex, connected edge, target vertex).
Source Vertex Set (SYNTAX v1)
Notice that the edge set and target set are optional: a step can be just source vertices (stepSourceSet). 
EBNF for source-only pattern (SYNTAX v1)
1
step   :=  stepSourceSet ["-" "(" stepEdgeSet ")" ("-"|"->") stepVertexSet]
Copied!
Rules for Source Vertex Set in Syntax V1:
1.The source set may only be a vertexSetName. If this the first SELECT statement in the query, then the vertexSetName is generally created as a seedsSet:
2.The vertexSetName is optionally followed by an alias, which used in subsequent clauses to refer to the source set:
1
stepSourceSet := vertexSetName [":" vertexAlias]
2
vertexAlias := name
Copied!
For example:
1
resultSet = SELECT s FROM Source:s;
Copied!
This statement can be interpreted as "Select all vertices s, from the vertex set Source ." The result is a vertex set. Below is a simple example of a vertex selection.
Vertex SELECT example
1
# displays all 'post'-type vertices 
2
CREATE QUERY printAllPosts() FOR GRAPH socialNet
3
{
4
  start =   {post.*};			   # initialized with all vertices of type 'post'
5
  results = SELECT s FROM start:s; # select these vertices
6
  PRINT results;
7
}
Copied!
Results of Query printAllPosts
1
GSQL > RUN QUERY printAllPosts()
2
{
3
  "error": false,
4
  "message": "",
5
  "version": {
6
    "edition": "developer",
7
    "schema": 0,
8
    "api": "v2"
9
  },
10
  "results": [{"results": [
11
    {
12
      "v_id": "0",
13
      "attributes": {
14
        "postTime": "2010-01-12 11:22:05",
15
        "subject": "Graphs"
16
      },
17
      "v_type": "post"
18
    },
19
    {
20
      "v_id": "10",
21
      "attributes": {
22
        "postTime": "2011-02-04 03:02:31",
23
        "subject": "cats"
24
      },
25
      "v_type": "post"
26
    },
27
    {
28
      "v_id": "2",
29
      "attributes": {
30
        "postTime": "2011-02-03 01:02:42",
31
        "subject": "query languages"
32
      },
33
      "v_type": "post"
34
    },
35
    {
36
      "v_id": "4",
37
      "attributes": {
38
        "postTime": "2011-02-07 05:02:51",
39
        "subject": "coffee"
40
      },
41
      "v_type": "post"
42
    },
43
    {
44
      "v_id": "9",
45
      "attributes": {
46
        "postTime": "2011-02-05 23:12:42",
47
        "subject": "cats"
48
      },
49
      "v_type": "post"
50
    },
51
    {
52
      "v_id": "3",
53
      "attributes": {
54
        "postTime": "2011-02-05 01:02:44",
55
        "subject": "cats"
56
      },
57
      "v_type": "post"
58
    },
59
    {
60
      "v_id": "5",
61
      "attributes": {
62
        "postTime": "2011-02-06 01:02:02",
63
        "subject": "tigergraph"
64
      },
65
      "v_type": "post"
66
    },
67
    {
68
      "v_id": "7",
69
      "attributes": {
70
        "postTime": "2011-02-04 17:02:41",
71
        "subject": "Graphs"
72
      },
73
      "v_type": "post"
74
    },
75
    {
76
      "v_id": "1",
77
      "attributes": {
78
        "postTime": "2011-03-03 23:02:00",
79
        "subject": "tigergraph"
80
      },
81
      "v_type": "post"
82
    },
83
    {
84
      "v_id": "11",
85
      "attributes": {
86
        "postTime": "2011-02-03 01:02:21",
87
        "subject": "cats"
88
      },
89
      "v_type": "post"
90
    },
91
    {
92
      "v_id": "8",
93
      "attributes": {
94
        "postTime": "2011-02-03 17:05:52",
95
        "subject": "cats"
96
      },
97
      "v_type": "post"
98
    },
99
    {
100
      "v_id": "6",
101
      "attributes": {
102
        "postTime": "2011-02-05 02:02:05",
103
        "subject": "tigergraph"
104
      },
105
      "v_type": "post"
106
    }
107
  ]}]
108
}
Copied!
1-Hop Step (SYNTAX v1)
Usually, a FROM clause has a full 1-hop step.
1
step   :=  stepSourceSet ["-" "(" stepEdgeSet ")" ("-"|"->") stepVertexSet]
Copied!
The symbols -( and )- enclose the stepEdgeSet and separate the three parts. Each of the three parts may also define an alias, which makes a convenient way to refer to each of the three sets of entities.
1
stepSourceSet := vertexSetName [":" vertexAlias]
2
stepEdgeSet := [setEdgeTypes] [":" edgeAlias]
3
stepVertexSet := [setVertexTypes] [":" vertexAlias]
Copied!
Below is a simple example:
1
Person:s -( (Bought|Rented):e )- (Product|Service):t
Copied!
The Source set is all Persons, but the pattern will not include all Persons. It will only include those Persons who Bought or Rented a Product or Service. Moreover, the result will be a set of matched triples: (s, e, t). For example, if Sam bought a TV and Andy rented a car, the results will include (Sam, Bought, TV) and (Andy, Rented, Car). However, these two facts do not imply (Sam, Rented, Car) or (Andy, Rented, TV). 
NOTE: The GSQL grammar allows the righthand enclosure to be either )- or
)->. Previously, we recommended the arrowhead )-> . However, for better compatibility with the new V2 pattern matching syntax, we now recommend the headless version: )- Syntax v2 has a specific semantic meaning for the arrowheads.
Edge Set and Target Vertex Set Options
Rules for Edge Set and Target Set in Syntax V1:
1.The edge set (stepEdgeSet) and target vertex set (stepVertexSet) obey very similar rules. Each may be a set specifier (stepEdgeTypes or stepVertexTypes) followed optionally by an alias.
2.The set specifier can be any of the following:
"_" or "ANY" or <blank>, which means any edge/vertex.
a named type (edgeType or vertexType)
a global SetAcum accumulator containing a set of edges or vertices
("@@"accumName)
a string or string set parameter which names one or more edge or vertex types 
(paramName) This parameterized type is one aspect of Dynamic Querying.
A list of types, string parameters, or global accumulators, e.g.,
"(" edgeSetType ["|" edgeSetType]* ")"
The list of types must contain the same type of specifiers.
1
stepEdgeSet := [setEdgeTypes] [":" edgeAlias]
2
stepVertexSet := [setVertexTypes] [":" vertexAlias]
3
alias := (vertexAlias | edgeAlias)
4
vertexAlias := name
5
edgeAlias := name
6
​
7
stepEdgeTypes := atomicEdgeType
8
               | "(" edgeSetType ["|" edgeSetType]* ")"               
9
atomicEdgeType := "_" | ANY | edgeSetType
10
edgeSetType := edgeType | paramName | globalAccumName
11
​
12
stepVertexTypes := atomicVertexType
13
                 | "(" vertexSetType ["|" vertexSetType]* ")"
14
atomicVertexType := "_" | ANY | vertexSetType
15
vertexSetType := vertexType | paramName | globalAccumName
Copied!
notation
 accepted vertex/edge types
(empty)
any type
_
any type
ANY
any type
vertex/edge type name
given type
string parameter holding a vertex/edge type name
given type
global SetAccum containing vertices or edges
given set
(name | name ...)
UNION of two or more collections
Parentheses are always needed around the edge type in a FROM clause:
FROM Source:s -(eType:e)- Target:t
Parentheses are also needed if a vertexEdgeType is the union of more than one or more individual edge types or vertex types:
FROM Source:s -((eType1 | eType2):e) - Target:t

Note the double set of parentheses for the edge specifier. If these is an edge alias, these parentheses are needed. If however there is no edge alias, it is legal to have just a single set of parentheses:
FROM Source:s -(eType1 | eType2) - Target:t
Either the source vertex set ( s ) or target vertex set ( t ) can be used as the SELECT argument, which determines the result of the SELECT statement. Note the small difference in the two SELECT statements below.
Selecting source or target vertices from edge-induced selection
1
resultSet1 = SELECT s FROM source:s-(eType:e)-tType:t;   //select from the source set
2
resultSet2 = SELECT t FROM source:s-(eType:e)-tType:t;   //select from the target set
Copied!
resultSet1 is based on the source end of the edges. resultSet2 is based on the target end of the selected edges. However, resultSet1 is NOT identical to the Source vertex set. It is only those members of Source which connect to an eType edge and then to a tType vertex. Other clauses (presented later in this "SELECT Statement" section, can do additional filtering of the Source set.
 We strongly suggest that an alias should be declared with every vertex and edge in the FROM clause, as there are several functions and features which are only available to vertex and edge aliases.
If is legal to declare an alias without explicitly stating an edge/target type. See the examples below.
Target vertex type inference
1
resultSet3 = SELECT v FROM Source:v-(eType:e)->(V1|V2):t;
2
resultSet4 = SELECT v FROM Source:v-(eType:e)->:t;
3
resultSet5 = SELECT v FROM Source:v-(eType:e)->ANY:t;
4
resultSet6 = SELECT v FROM Source:v-(eType:e)->_:t;
Copied!
Edge type inference
1
resultSet7 = SELECT v FROM Source:v-((E1|E2|E3):e)->tType:t;
2
resultSet8 = SELECT v FROM Source:v-(:e)->tType:t;
3
resultSet9 = SELECT v FROM Source:v-(_:e)->tType:t;
4
resultSet10 = SELECT v FROM Source:v-(ANY:e)->tType:t;
Copied!
The following are a set of queries that demonstrate edge-induced SELECT blocks. The allPostsLiked and allPostsMade queries show how the target vertex type can be omitted. The allPostsLikedOrMade query uses the "|" operator to select multiple types of edges.
Edge induced SELECT example
1
# uses various SELECT statements (some of which are equivalent) to print out
2
# either the posts made by the given user, the posts liked by the given
3
# user, or the posts made or liked by the given user.
4
CREATE QUERY printAllPosts2(vertex<person> seed) FOR GRAPH socialNet
5
{
6
	start = {seed}; # initialize starting set of vertices
7
​
8
​
9
	# --- statements produce equivalent results
10
	# select all 'post' vertices which can be reached from 'start' in one hop
11
	# 	using an edge of type 'liked'
12
	allPostsLiked = SELECT targetVertex FROM start -(liked:e)-> post:targetVertex;
13
 
14
	# select all vertices of any type which can be reached from 'start' in one hop
15
	# 	using an edge of type 'liked'
16
	allPostsLiked = SELECT targetVertex FROM start -(liked:e)-> :targetVertex;
17
	# ---- 
18
 
19
 
20
	# --- statements produce equivalent results
21
	# start with the vertex set from above, and traverse all edges of type "posted"
22
  	# 	(locally those edges are just given a name 'e' in case they need accessed)
23
  	# 	and return all vertices of type 'post' which can be reached within one-hop of 'start' vertices
24
	allPostsMade = SELECT targetVertex FROM start -(posted:e)-> post:targetVertex;
25
 
26
	# start with the vertex set from above, and traverse all edges of type "posted"
27
  	# 	(locally those edges are just given a name 'e' in case they need accessed)
28
  	# 	and return all vertices of any type which can be reached within one-hop of 'start' vertices
29
	allPostsMade = SELECT targetVertex FROM start -(posted:e)-> :targetVertex;
30
	# ---- 
31
 
32
 
33
	# --- statements produce equivalent results
34
	# select all vertices of type 'post' which can be reached from 'start' in one hop
35
	# 	using an edge of any type
36
	# not equivalent to any statement. because it doesn't restrict the edge type,
37
	# 	this will include any vertex connected by 'liked' or 'posted' edge types
38
	allPostsLikedOrMade = SELECT t FROM start -(:e)-> t;
39
 
40
	# select all vertices of type 'post' which can be reached from 'start' in one hop
41
	#	using an edge of type either 'posted' or 'liked'
42
	allPostsLikedOrMade = SELECT t FROM start -((posted|liked):e)-> post:t;
43
 
44
	# select all vertices of any type which can be reached from 'start' in one hop
45
	#	using an edge of type either 'posted' or 'liked/
46
	allPostsLikedOrMade = SELECT t FROM start -((posted|liked):e)-> :t;
47
	
48
	#option for simplified parentheses in edge pattern:
49
	allPostsLikedOrMade = SELECT t FROM start - (posted|liked)-> :t
50
	# ---- 
51
	
52
	PRINT allPostsLiked;
53
    PRINT allPostsMade;
54
    PRINT allPostsLikedOrMade;
55
}
Copied!
Results of Query printAllPosts2
1
GSQL > RUN QUERY printAllPosts2("person2")
2
{
3
  "error": false,
4
  "message": "",
5
  "version": {
6
    "edition": "developer",
7
    "schema": 0,
8
    "api": "v2"
9
  },
10
  "results": [
11
    {"allPostsLiked": [
12
      {
13
        "v_id": "0",
14
        "attributes": {
15
          "postTime": "2010-01-12 11:22:05",
16
          "subject": "Graphs"
17
        },
18
        "v_type": "post"
19
      },
20
      {
21
        "v_id": "3",
22
        "attributes": {
23
          "postTime": "2011-02-05 01:02:44",
24
          "subject": "cats"
25
        },
26
        "v_type": "post"
27
      }
28
    ]},
29
    {"allPostsMade": [{
30
      "v_id": "1",
31
      "attributes": {
32
        "postTime": "2011-03-03 23:02:00",
33
        "subject": "tigergraph"
34
      },
35
      "v_type": "post"
36
    }]},
37
    {"allPostsLikedOrMade": [
38
      {
39
        "v_id": "0",
40
        "attributes": {
41
          "postTime": "2010-01-12 11:22:05",
42
          "subject": "Graphs"
43
        },
44
        "v_type": "post"
45
      },
46
      {
47
        "v_id": "3",
48
        "attributes": {
49
          "postTime": "2011-02-05 01:02:44",
50
          "subject": "cats"
51
        },
52
        "v_type": "post"
53
      },
54
      {
55
        "v_id": "1",
56
        "attributes": {
57
          "postTime": "2011-03-03 23:02:00",
58
          "subject": "tigergraph"
59
        },
60
        "v_type": "post"
61
      }
62
    ]}
63
  ]
64
}
65
GSQL > RUN QUERY printAllPosts2("person6")
66
{
67
  "error": false,
68
  "message": "",
69
  "version": {
70
    "edition": "developer",
71
    "schema": 0,
72
    "api": "v2"
73
  },
74
  "results": [
75
    {"allPostsLiked": [{
76
      "v_id": "8",
77
      "attributes": {
78
        "postTime": "2011-02-03 17:05:52",
79
        "subject": "cats"
80
      },
81
      "v_type": "post"
82
    }]},
83
    {"allPostsMade": [
84
      {
85
        "v_id": "10",
86
        "attributes": {
87
          "postTime": "2011-02-04 03:02:31",
88
          "subject": "cats"
89
        },
90
        "v_type": "post"
91
      },
92
      {
93
        "v_id": "5",
94
        "attributes": {
95
          "postTime": "2011-02-06 01:02:02",
96
          "subject": "tigergraph"
97
        },
98
        "v_type": "post"
99
      }
100
    ]},
101
    {"allPostsLikedOrMade": [
102
      {
103
        "v_id": "10",
104
        "attributes": {
105
          "postTime": "2011-02-04 03:02:31",
106
          "subject": "cats"
107
        },
108
        "v_type": "post"
109
      },
110
      {
111
        "v_id": "5",
112
        "attributes": {
113
          "postTime": "2011-02-06 01:02:02",
114
          "subject": "tigergraph"
115
        },
116
        "v_type": "post"
117
      },
118
      {
119
        "v_id": "8",
120
        "attributes": {
121
          "postTime": "2011-02-03 17:05:52",
122
          "subject": "cats"
123
        },
124
        "v_type": "post"
125
      }
126
    ]}
127
  ]
128
}
Copied!
This example is another edge selection that uses the "|" operator to select edges that have target vertices of multiple types.
Edge induced SELECT example
1
# uses a SELECT statement to print out everything related to a given user
2
# 	this includes posts that the user liked, posts that the user made, and friends
3
# 	of the user
4
CREATE QUERY printAllRelatedItems(vertex<person> seed) FOR GRAPH socialNet
5
{
6
	sourceVertex = {seed};
7
	
8
	# -- statements produce equivalent output
9
	# returns all vertices of type either 'person' or 'post' that can be reached
10
	# 	from the sourceVertex set using one edge of any type
11
	everythingRelated = SELECT v FROM sourceVertex -(:e)-> (person|post):v;
12
 
13
	# returns all vertices of any type that can be reached from the sourceVertex
14
	# 	using one edge of any type
15
	# this statement is equivalent to the above one because the graph schema only
16
	#	has vertex types of either 'person' or 'post'. if there were more vertex
17
	#	types present, these would not be equivalent.
18
	everythingRelated = SELECT v FROM sourceVertex -(:e)-> :v;
19
	# -- 
20
​
21
	PRINT everythingRelated;
22
}
Copied!
Results
1
GSQL > RUN QUERY printAllRelatedItems("person2")
2
{
3
  "error": false,
4
  "message": "",
5
  "version": {
6
    "edition": "developer",
7
    "schema": 0,
8
    "api": "v2"
9
  },
10
  "results": [{"everythingRelated": [
11
    {
12
      "v_id": "0",
13
      "attributes": {
14
        "postTime": "2010-01-12 11:22:05",
15
        "subject": "Graphs"
16
      },
17
      "v_type": "post"
18
    },
19
    {
20
      "v_id": "person3",
21
      "attributes": {
22
        "gender": "Male",
23
        "id": "person3"
24
      },
25
      "v_type": "person"
26
    },
27
    {
28
      "v_id": "person1",
29
      "attributes": {
30
        "gender": "Male",
31
        "id": "person1"
32
      },
33
      "v_type": "person"
34
    },
35
    {
36
      "v_id": "3",
37
      "attributes": {
38
        "postTime": "2011-02-05 01:02:44",
39
        "subject": "cats"
40
      },
41
      "v_type": "post"
42
    },
43
    {
44
      "v_id": "1",
45
      "attributes": {
46
        "postTime": "2011-03-03 23:02:00",
47
        "subject": "tigergraph"
48
      },
49
      "v_type": "post"
50
    }
51
  ]}]
52
}
53
GSQL > RUN QUERY printAllRelatedItems("person6")
54
{
55
  "error": false,
56
  "message": "",
57
  "version": {
58
    "edition": "developer",
59
    "schema": 0,
60
    "api": "v2"
61
  },
62
  "results": [{"everythingRelated": [
63
    {
64
      "v_id": "person4",
65
      "attributes": {
66
        "gender": "Female",
67
        "id": "person4"
68
      },
69
      "v_type": "person"
70
    },
71
    {
72
      "v_id": "10",
73
      "attributes": {
74
        "postTime": "2011-02-04 03:02:31",
75
        "subject": "cats"
76
      },
77
      "v_type": "post"
78
    },
79
    {
80
      "v_id": "5",
81
      "attributes": {
82
        "postTime": "2011-02-06 01:02:02",
83
        "subject": "tigergraph"
84
      },
85
      "v_type": "post"
86
    },
87
    {
88
      "v_id": "person8",
89
      "attributes": {
90
        "gender": "Male",
91
        "id": "person8"
92
      },
93
      "v_type": "person"
94
    },
95
    {
96
      "v_id": "8",
97
      "attributes": {
98
        "postTime": "2011-02-03 17:05:52",
99
        "subject": "cats"
100
      },
101
      "v_type": "post"
102
    }
103
  ]}]
104
}
Copied!
Vertex and Edge Aliases
Vertex and edge aliases are declared within the FROM clause of a SELECT block, by using the character ":", followed by the alias name. Aliases can be accessed anywhere within the same SELECT block. They are used to reference a single selected vertex or edge of a set. It is through the vertex or edge aliases that attributes of these vertices or edges can be accessed.
For example, the following code snippets show two different SELECT statements. The first SELECT statement starts from a vertex set called allVertices, and the vertex alias name v can access each individual vertex from allVertices. The second SELECT statement selects a set of edges. It can use the vertex alias s to reference the source vertices, or the alias t to reference the target vertices.
Vertex variables
1
results = SELECT v FROM allVertices:v;
2
results = SELECT t FROM allVertices:s -()-> :t;
Copied!
The following example shows an edge-based SELECT statement, declaring aliases for all three parts of the edge. In the ACCUM clause, the e and t aliases are assigned to local vertex and edge variables.
Edge variables
1
results = SELECT v 
2
          FROM allVertices:s -(:e)-> :t
3
          ACCUM VERTEX v = t, EDGE eg = e;
Copied!
We strongly suggest that an alias should be declared with every vertex and edge in the FROM clause, as there are several functions and features only available to vertex and edge aliases.
Pattern Matching (SYNTAX v2) 
We give a brief overview of Pattern Matching syntax and semantics in the FROM clause, from the perspective of the formal notation and how the rules can be inferred from that. For a more practical explanation of Pattern Matching, we recommend the GSQL102 Pattern Matching tutorial.
There are three options for the syntax of the pattern in a FROM clause:
1
fromClause := FROM (step | stepV2 | pathPattern ["," pathPattern]*)
Copied!
1.step pattern, SYNTAX v1. This is the default syntax from classic GSQL.

2.stepV2 pattern, SYNTAX v2. The query or the GSQL session must specify that SYNTAX v2 is to be used. This is still a 1-Hop query, but there are two differences:
The source vertex set now has the same flexibility as the target vertex. It is not necessary to create a seedSet. Instead, the source can be one or more vertex types, given either statically or dynamically as string parameters, or the special symbol ANY or _.
The arrowhead -( )-> should not be used between the edge set and the target set. Simply use a dash -( )-.
3.One or more pathPattern s.
A pathPattern begins with a stepVertexSet and then has one or more hops across and edge set to a target set: -(pathEdgePattern)-setVertexSet.
1
pathPattern := stepVertexSet ["-" "(" pathEdgePattern ")" "-" stepVertexSet]*
Copied!
We have already studied stepVertexSet. Now we will look at the options for pathEdgePattern and their meanings.
1
pathEdgePattern := atomicEdgePattern
2
                 | "(" pathEdgePattern ")"
3
                 | pathEdgePattern "." pathEdgePattern
4
                 | disjPattern
5
                 | starPattern
6
                 
7
atomicEdgePattern  := atomicEdgeType		
8
        	        | atomicEdgeType ">"	
9
        	        | "<" atomicEdgeType	
10
        
11
atomicEdgeType := "_" | ANY | edgeSetType
12
edgeSetType := edgeType | paramName | globalAccumName       
Copied!
The most basic form for a pathEdgePattern is an atomicEdgePattern. This in turn can be, similar to stepVertexSet, one of the following:
"_" or "ANY"
an edgeType, a string parameter, or a global SetAccum accumulator.
Edge Direction
Moreover, an atomicEdgePattern can have either a left pointer "<" on the left or a right pointer ">" on the right. These indicate edge direction, of course. If no pointer is used, then the edge is undirected. Suppose we have 3 edge types or parameters called A, B, C.
A> is a rightward facing A edge
<B is a leftward facing B edge
C is an undirected C edge. If C is actually a directed edge type, then there is no match.
Disjunction, Repeats, and Dot Concatenation
Looking at the remaining options for pathEdgePattern, we see that we can have parentheses around it, we can use a dot "." between two pathEdgePatterns, or we can have a disjPattern or starPattern.
disjPattern is how we write "either this edge pattern or that edge pattern""
1
disjPattern := atomicEdgePattern ("|" atomicEdgePattern)*
Copied!
For example, we can combine the three direction-specfic examples from above: (A> | <B | C)
starPattern explains how the Kleene star and min..max range specifiers can be used to say "repeat this edge pattern from min to max times." 
1
starPattern := ([atomicEdgePattern] | "(" disjPattern ")") "*" [starBounds]
2
​
3
starBounds := CONST_INT ".." CONST_INT 
4
            | CONST_INT ".." 
5
            | ".." CONST_INT 
6
            | CONST_INT 
Copied!
For example,(A> | <B | C)*2..4 means "a series of 2 to 4 adjacent edges, where each edge has type A>, <B, or C. Note that we do not have to use the same edge type for all the repeats. Either iteration can select an option from disjPattern.
The dot operator means concatenate the two edge patterns into one. Naturally, there must be a vertex joining the two edges, but it is omitted from the syntax. The dot operator is a shorthand, when you don't care about the type of that intermediate vertex. 
(A>.<B.C) means a series of 3 edges, having the specifying types and directions.
Conjunctive Pattern Matching
The optional repeating phrase ["," pathPattern]* allows you to have multiple pathPatterns. They form a conjunction, meaning all of them must be satisfied in order to have a valid match result. 
1
fromClause := FROM (step | stepV2 | pathPattern ["," pathPattern]*)
Copied!
Recall that each step pattern or path pattern forms a match table, one row per matching path in the graph. Each vertex alias or edge alias is one column in the table.  When we have a conjunctive path, each path must share at least one vertex alias with another path. This enables the two path sets (and match tables) to be joined. Formally, we make the natural join of the two tables. 
This explains all of the syntax for the FROM clause with SYNTAX v2 (Pattern Matching). The other significant area to consider for SYNTAX v2 is the ACCUM and POST-ACCUM clauses.
SAMPLE Clause
The SAMPLE clause is an optional clause that selects a uniform random sample from the population of edges or target vertices specified in the FROM argument. 
If you want to sample from a set of vertices directly, not from edges or from neighboring (target) vertices, then the following technique is simpler and faster:
Select k random vertices from a vertex set S
1
random = SELECT s
2
         FROM S:s
3
         LIMIT k;
Copied!
The SAMPLE clause draws from the edge population consisting of those edges which satisfy all three parts – source set, edge type, and target type – of the FROM clause. The SAMPLE clause is intended to provide a representative sample of the distribution of edges (or vertices) connected to hub vertices, instead of dealing with all edges. A hub vertex is a vertex with a relatively high degree. (The degree of a vertex is the number of edges which connect to it. If edges are directional, one can distinguish between indegree and outdegree.)
EBNF for Sample Clause
1
sampleClause := SAMPLE ( expr | expr "%" ) EDGE WHEN condition # sample an absolute number (or a percentage) of edges for each source vertex. 
2
              | SAMPLE expr TARGET WHEN condition              # sample an absolute number of edges incident to each target vertex.
3
              | SAMPLE expr "%" TARGET PINNED WHEN condition   # sample a percentage of edges incident to each target vertex.
Copied!
The expression following SAMPLE specifies the sample size, either an absolute number or a percentage of the population. The expression in sampleClause must evaluate to a positive integer. There are two sampling methods. One is sampling based on edge id. The other is based on target vertex id: if a target vertex id is sampled, all edges from this source vertex to the sampled target vertex are sampled.
Note: Currently, the WHEN condition that can be used with a SAMPLE clause is limited strictly to checking if the result of a function call on a vertex is greater than or greater than/equal to some number.
Given that the sampling is random, some of the details of each of the example queries may change each time they are run.
The following query displays two modes of sampling: an absolute number of edges from a source vertex and a percentage of edges fro a source vertex. We use the computerNet graph (see Appendix D).  In computerNet, there are 31 vertices and 43 edges, but only 7 vertices are source vertices. Moreover, c1, c12, and c23 are hub nodes, with at least 10 outgoing edges each.  For the absolute count case, we set the size to 1 edge per source vertex, which is equivalent to a random walk. We expect exactly 7 edges to be selected.  For the percentage sampling case, we sample 33% of the edges for vertices which have 3 or more outgoing edges. We expect about 15 edges, but the number may vary. 

sampleEx3: SAMPLE based on edges per source vertex
1
CREATE QUERY sampleEx3() FOR GRAPH computerNet
2
{
3
    MapAccum<STRING,ListAccum<STRING>> @@absEdges; // record each selected edge as (src->tgt)
4
    SumAccum<INT> @@totalAbs;
5
    MapAccum<STRING,ListAccum<STRING>> @@pctEdges; // record each selected edge as (src->tgt)
6
    SumAccum<INT> @@totalPct;
7
​
8
    start = {computer.*};
9
​
10
    # Sample one outgoing edge per source vertex = Random Walk
11
    absSample = SELECT v FROM start:s -(:e)-> :v
12
             SAMPLE 1 EDGE WHEN s.outdegree() >= 1    # sample 1 target vertex from each source vertex
13
             ACCUM @@absEdges += (s.id -> v.id),
14
                   @@totalAbs += 1;
15
    PRINT @@totalAbs, @@absEdges;
16
​
17
    pctSample = SELECT v FROM start:s -(:e)-> :v
18
             SAMPLE 33% EDGE WHEN s.outdegree() >= 3  # select ~1/3 of edges when outdegree >= 3
19
             ACCUM @@pctEdges += (s.id -> v.id),
20
                   @@totalPct += 1;
21
    PRINT @@totalPct, @@pctEdges;
22
}