The PRINT statement specifies output data. Each execution of a PRINT statement adds a JSON object to the results array which will be part of the query output. A PRINT statement can appear anywhere that query-body statements are permitted.
Each PRINT statement contains a list of expressions for output data. The optional WHERE clause filters the output. If the condition is false for any items, then those items are excluded from the output.
Each printExpr contributes one key-value pair to the PRINT statement's JSON object result. The optional AS clause sets the key for the expression, overriding the default key (explained below).
Each printExpr may be one of the following:
A literal value
A global or local variable (including VERTEX and EDGE variables)
An attribute of a vertex variable, e.g., Person.name
A global accumulator
An expression whose terms are among the types above. The following operators may be used:
Parentheses can be used for controlling order of precedence.
A vertex set variable
A vertex expression set vExprSet (only available if the output API is set to "v2". Vertex expression sets are explained in a separate section below.
If a printExpr includes the optional AS name clause, then the name sets the key for that expression in the JSON output. Otherwise, the following rules determine the key: If the expression is simply a single variable (local variable, global variable, global accumulator, or vertex set variable), then the key is the variable name. Also, for a vertex expression set, the key is the vertex set variable name. Otherwise, the key is the entire expression, represented as a string.
Each data type has a distinct output format.
Simple numeric, string, and boolean data types follow JSON standards.
Lists, sets, bags, and arrays are printed as JSON arrays (i.e., a list enclosed in square brackets).
Maps and tuples are printed as JSON objects (i.e., a list of key:value pairs enclosed in curly braces).
Vertices and edges have a custom JSON object, shown below.
A vertex set variable is treated as a list of vertices.
Accumulator output format is determined by the accumulator's return type. For example, an AvgAccum outputs a DOUBLE value, and a BitwiseAndAccum outputs a INT value. For container accumulators, simply consider whether the output is a list, set, bag, or map.
ListAccum, SetAccum, BagAccum, ArrayAccum: list
HeapAccum, GroupByAccum: list of tuples
Vertex (when not part of a vertex set variable)
The output is just the vertex id as a string:
Vertex (as part of a vertex set variable)
List, Set or Bag
Vertex Set Variable
A vertex expression set is a list of expressions which is applied to each vertex in a vertex set variable. The expression list is used to compute an alternative set of values to display in the "attributes" field of each vertex.
The easiest way to understand this is to consider examples containing only one term and then consider combinations. Consider the following example query. C is a vertex set variable containing the set of all company vertices. Furthermore, each vertex has a vertex-attached accumulator @count.
If we print the full vertex set, the "attributes" field of each vertex will contain 3 fields: "id", "country", and "@count". Now consider some simple vertex expression sets:
prints the vertex set variable C, except that the "attributes" field will contain only "country", instead of 3 fields.
prints the vertex set variable C, except that the "attributes" field will contain only "@count", instead of 3 fields.
PRINT C[C.id, C.@count]
prints the vertex set variable C, except that the "attributes" field will contain only "id" and "@count".
PRINT C[C.id+"_ex", C.@count+1]
prints the vertex set variable C, except that the "attributes" field contains the following:
One field consists of each vertex's id value, with the string "_ex" appended to it.
Another field consists of the @count value incremented by 1. Note: the value of @count itself has not changed, only the displayed value is incremented.
The last example illustrates the general format for a vertex expression set:
The vertex expression set begins with the name of a vertex set variable. It is followed by a list of attribute expressions, enclosed in square brackets. Each attribute expression follows the same rules described earlier in the Print Expressions section. That is, each attribute expression may refer to one or more attributes or vertex-attached accumulators of the current vertices, as well as literals, local or global variables, and global accumulators. The allowed operators (for numeric, string, or set operations) are the same ones mentioned above.
The key for the vertex expression set is the vertex set variable name.
The value for the vertex expression set is a modified vertex set variable, where the regular "attributes" value for each vertex is replaced with a set of key:value pairs corresponding to the set of attribute expressions given in the print expression.
An example which shows all of the cases described above, in combination, is shown below.
Instead of printing output in JSON format, output can be written to a FILE object in comma-separated values (CSV) format. To select this option, at the end of the PRINT statement, include the keyword TO_CSV followed by the FILE object name:
Each execution of the PRINT statement appends one line to the FILE. If the PRINT statement includes multiple expressions, then each printed value is separated from its neighbor by a comma. If an expression evaluates to a set or list, then the collection's values are delimited by single spaces. Due to the simpler format of CSV vs. JSON, the TO_CSV feature only supports data with a simple one- or two-dimension structure.
Instead of printing CSV output to a FILE object, data can be written to a regular file.
This feature is deprecated because printing to a FILE object covers the same functionality.
The table below shows the differences between printing TO_CSV <FILE object> vs. TO_CSV <fllepath>.
One of the two ways to write data to a FILE object is with the FILE println statement. (The other way is with the PRINT statement's TO_CSV option.)
println is a method (function) of a FILE object variable. The println statement can be used either at the query-body level or a a DML-sub-statement, e.g., within the ACCUM clause of a SELECT block. Each time println is called, it adds one new line of values to the FILE object, and then to the corresponding file.
The println function can print most of the expressions handled by PRINT. Note, however, that this does not include vertex expression sets (vExprSet). If the println statement has a list of expressions to print, then this will produce a comma-separated list of values. If an expression refers to a list or set, then the output will be a list of values separated by spaces, the same format produced by TO_CSV.
All of the PRINT statements in this example use the TO_CSV option, so there is no JSON output to the console.
All the output in this case goes the the FILE object. In the query definition, the footer is the last FILE statement, but the println statements from the SELECT block happen to be delayed and are printed AFTER the footer line.
A FILE Object can be passed from one query to a subquery. The subquery can then also write to the FILE object.
The LOG statement is another means to output data. It works as a function that outputs information to a log file.
The first argument of the LOG statement is a boolean condition that enables or disables logging. This allows logging to be easily turned on/off, for uses such as debugging. After the condition, LOG takes one or more expressions (separated by commas). These expressions are evaluated and output to the log file.
Unlike the PRINT statement, which can only be used as a query-body statement, the LOG statement can be used as both a query-body statement and a DML-sub-statement.
The values will be recorded in the GPE log. To find the log file after the query has completed, open a Linux shell and use the command "gadmin log gpe". It may show you more than one log file name; use the one ending in "INFO". Search this file for "UDF_".
The RETURN statement specifies data that a sub-query passes back to an outer query that called the sub-query. In order for a query to be used as a subquery, its initial CREATE QUERY statement must include the optional RETURNS clause, and its body must end with a RETURN statement. Exactly one type is allowed in the RETURNS clause, and thus RETURN statement can only return one expression.The returned expression must have the same type as the RETURNS clause indicates. A sub-query must be created before its corresponding super-query. A sub-query must be install either before or in the same INSTALL QUERY command with its super-query.
The return type can be any base type or any accumulator type, except GroupByAccum and any accumulator containing any tuple type. For the purposes of return type, SetAccum is equivalent to SET, and BagAccum is equivalent to BAG. A vertex set variable can be returned if SET<VERTEX<type>> or SetAccum<VERTEX<type>> (<type> is optional) is used in the RETURNS clause.
See also Section 5.11 - Queries ad Functions.