Changes between Version 21 and Version 22 of SemanticQuery

Timestamp:

Sep 17, 2014, 4:41:18 PM (11 years ago)

Author:

manualwiki

Comment:

--

SemanticQuery

@@ -21 +21 @@
 semantic_query    ::= initial_selection ['.' query_sequence]
 query_sequence    ::= query ['.' query_sequence]
-query             ::= selection | iteration | closure | property_query
+query             ::= selection | iteration | closure | property_query | set_op_query
 initial_selection ::= initial_selector ['[' filter ']']
 selection         ::= selector ['[' filter ']']
@@ -28 +28 @@
                       '(' query_sequence ')+' ['[' filter ']']
 property_query    ::= property ['[' filter ']']
+set_op_query      ::= '(' (query_sequence | semantic_query) set_op (query_sequence | semantic_query) ')'
+set_op            ::= union | minus | intersect
 }}}
 
@@ -37 +39 @@
 * closure (calculates the transitive closure of a query sequence)
 * property query (selects a property of an entity)
+* set_op query (combines the results of two queries by the given set operator)
 
 == Language elements ==
@@ -84 +87 @@
 
 Atoms, strings, integers and properties can be used in comparisons. 
-The language uses {{{/=, ==, >=, =<, <, >, ~}}} and {{{in}}}. 
+The language uses {{{/=, ==, >=, =<, <, >}}} and {{{~}}}. 
 The results of comparisons are the same as in Erlang. 
 The resulting expressions can be combined by {{{and}}}, {{{or}}}, and {{{not}}} operators, and parentheses can be used, too. 
 The {{{~}}} operator is a regular expression matching operator, and it can be used anywhere,
-where other binary comparison operators can be used. The same expressions can be used, which can be used in the {{{re}}} module.
-The {{{in}}} operator is similar to the {{{in}}} operator defined in SQL. To illustrate its usage, consider the following 2 semantic queries,
-which are semantically equivalent with each other.
- * mods.funs[name = a or name = b or name = c]
- * mods.funs[name in |a,b,c|]
+ where other binary comparison operators can be used. The same expressions can be used, which can be used in the {{{re}}} module.
 
 The operator precedence for the filters is as follows:
@@ -99 +98 @@
 ||{{{not}}} ||unary || 
 ||{{{/=, ==, >=, =<, <, >, =:=, =/=, ~}}} ||left associative || 
-||{{{in}}} ||left associative ||
 ||{{{and}}} ||left associative ||
 ||{{{or}}} ||left associative ||
@@ -116 +114 @@
 }}}
 
-''Example:'' you may be interested in all the module, whose name equals with one element of the following set : {a,b,c}
-{{{
-mods[ name in |a,b,c| ]
-}}}
+==== Variables ====
+It is possible to bind property value to a variable for later use. All variable name begins with a capital letter, just like erlang variables.
+
+Usage of variables is only allowed in filters. Variables may only bind to properties. Once bound, a variable can be compared to other properties, variables or literals of the same type using {{{/=, ==, >, <}}} etc. operators.
+
+''Example:'' to obtain all function that has the same name as its containing module use the following query:
+{{{
+mods[name=A].funs[name==A]
+}}}
+Note that variables' semantics are different compared to erlang. In the example above, the value of variable {{{A}}} changes from module to module.
+
+More detailed description can be found at [SemanticQuery/Variables Variables].
 
 ==== Embedded queries ====
@@ -140 +146 @@
 }}}
 
+===== In, any_in, all_in filters =====
+Entities can also be filtered by in conditions in filters. Their operands can be
+lists, embedded queries or semantic queries.
+{{{
+filter ::= (list | semantic_query | query_sequence) (all_in|any_in) query_sequence
+filter ::= query_sequence (all_in|any_in) (list | semantic_query)
+filter ::= (property | query_sequence) in (list | semantic_query)
+filter ::= list in (property | query_sequence)
+}}}
+Any_in will evaluate its operands for every entity selected before the filter and returns true
+if there is any value selected by the first operand that can also be found in the second operand's value list.
+[[BR]][[BR]]
+''any_in:''
+{{{
+mods.funs[.exprs.sub.val all_in (mods.funs--.file.funs).exprs.sub.val]
+}}}
+The query returns functions with subexpression values which can all be found in other files functions.
+[[BR]][[BR]]
+''any_in:''
+{{{
+mods.funs[.calls any_in mods[name=m1].funs]
+}}}
+This query will select every function that calls any function in module "m1".
+[[BR]][[BR]]
+All_in returns true only if all values of the first operand are also selected by the second operand.
+[[BR]][[BR]]
+''all_in:''
+{{{
+mods[.funs.calls all_in mods[name=m1].funs] 
+}}}
+The query will yield all modules that only call for m1's functions.
+[[BR]][[BR]]
+''all_in:''
+{{{
+mods[.funs.name all_in @mod.funs.name] 
+}}}
+Lists all modules whose functions names can also be found in the given module's functions names.
+[[BR]][[BR]]
+''in:''
+In is mainly for checking if a property value can be found in a list or a semantic query's result.
+For properties and lists this operator is symmetrical: "name in |e1, e2, ...|" means the same as "|e1, e2, ...| in name".
+{{{
+mods.func[name in mods.funs.exprs.esub.macro_value] 
+}}}
+The query gives back any function whose name has been defined as a macro value.
+
 === Iteration ===
 
@@ -170 +222 @@
 The result shown after this semantic query is the list of all possible call 
 chains starting from a given function.
+
+=== Set operators ===
+
+Set operators (and their operands) can take the place of query-sequences
+or initial selectors. Operands are first evaluated (which can be semantic queries,
+ query-sequences or set operators themselves), then the result is calculated based on the given operator.
+When the operands are not property-queries their results have to be of the same entity-type
+or the operator throws a type-mismatch error. If the operands return properties, but
+of different types, they would be converted to strings. Duplicates of the result entities
+are filtered. 
+When the operator is nested or used as a semantic query, the enclosing parentheses can be ommited.
+In the former case the evaluation order will be right to left.
+
+''Example:''
+{{{
+mods[name in |m1, m2|].funs(.calls union .called_by).vars
+}}}
+The query above will list all variables defined in functions which call or are
+called by any functions in modules named "m1" or "m2".
+
+''Example:''
+{{{
+mods.funs(.calls minus @mod.funs)(.name union .exprs.macro_value) 
+}}}
+This query lists all macro values and names for functions that aren't defined in the given
+module and are called by any module in the database.
+
+== Specifying grouping of results ==
+
+By default the results of queries are grouped by the second to last selector
+(unless the result is a statistic or a list of chains). This behavior can be changed
+by passing a groupby value to the semantic query (if the used interface supports the options list).
+The option {groupby, n} sets the grouping to the n-th query-element(filters are not counted).
+
+''Example:''
+{{{
+ri:q("mods.funs.vars", [{groupby, 1}]).
+}}}
+The results from the above example are grouped by the first selector i.e. modules.