Graql (Grakn 0.10.0 API)

java.lang.Object
- ai.grakn.graql.Graql

```
public class Graql
extends Object
```

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Pattern`	`and(Collection<? extends Pattern> patterns)`
`static Pattern`	`and(Pattern... patterns)`
`static Aggregate<Map<VarName,Concept>,Optional<Double>>`	`average(String name)` Create an aggregate that will find the mean of a variable's values.
`static ComputeQueryBuilder`	`compute()`
`static ValuePredicate`	`contains(String substring)`
`static ValuePredicate`	`contains(Var var)`
`static Aggregate<Object,Long>`	`count()` Create an aggregate that will count the results of a query.
`static ValuePredicate`	`eq(Object value)`
`static ValuePredicate`	`eq(Var var)`
`static Aggregate<Map<VarName,Concept>,Map<Concept,List<Map<VarName,Concept>>>>`	`group(String varName)` Create an aggregate that will group a query by a variable name.
`static <T> Aggregate<Map<VarName,Concept>,Map<Concept,T>>`	`group(String varName, Aggregate<? super Map<VarName,Concept>,T> aggregate)` Create an aggregate that will group a query by a variable name and apply the given aggregate to each group
`static ValuePredicate`	`gt(Comparable value)`
`static ValuePredicate`	`gt(Var var)`
`static ValuePredicate`	`gte(Comparable value)`
`static ValuePredicate`	`gte(Var var)`
`static InsertQuery`	`insert(Collection<? extends Var> vars)`
`static InsertQuery`	`insert(Var... vars)`
`static ValuePredicate`	`lt(Comparable value)`
`static ValuePredicate`	`lt(Var var)`
`static ValuePredicate`	`lte(Comparable value)`
`static ValuePredicate`	`lte(Var var)`
`static MatchQuery`	`match(Collection<? extends Pattern> patterns)`
`static MatchQuery`	`match(Pattern... patterns)`
`static <T extends Comparable<T>> Aggregate<Map<VarName,Concept>,Optional<T>>`	`max(String name)` Create an aggregate that will find the maximum of a variable's values.
`static Aggregate<Map<VarName,Concept>,Optional<Number>>`	`median(String name)` Create an aggregate that will find the median of a variable's values.
`static <T extends Comparable<T>> Aggregate<Map<VarName,Concept>,Optional<T>>`	`min(String name)` Create an aggregate that will find the minimum of a variable's values.
`static Var`	`name(String name)`
`static ValuePredicate`	`neq(Object value)`
`static ValuePredicate`	`neq(Var var)`
`static Pattern`	`or(Collection<? extends Pattern> patterns)`
`static Pattern`	`or(Pattern... patterns)`
`static <T extends Query<?>> T`	`parse(String queryString)`
`static List<Query<?>>`	`parseList(String queryString)`
`static java.util.stream.Stream<Pattern>`	`parsePatterns(InputStream inputStream)`
`static List<Pattern>`	`parsePatterns(String patternsString)`
`static <T extends Query<?>> T`	`parseTemplate(String template, Map<String,Object> data)`
`static ValuePredicate`	`regex(String pattern)`
`static <S,T> Aggregate<S,Map<String,T>>`	`select(NamedAggregate<? super S,? extends T>... aggregates)` Create an aggregate that will collect together several named aggregates into a map.
`static <S,T> Aggregate<S,Map<String,T>>`	`select(Set<NamedAggregate<? super S,? extends T>> aggregates)` Create an aggregate that will collect together several named aggregates into a map.
`static Aggregate<Map<VarName,Concept>,Number>`	`sum(String name)` Create an aggregate that will sum the values of a variable.
`static Var`	`var()`
`static Var`	`var(String name)`
`static Var`	`var(VarName name)`
`static QueryBuilder`	`withoutGraph()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - withoutGraph
```
public static QueryBuilder withoutGraph()
```
    Returns:
    
    a query builder without a specified graph
  - match
```
public static MatchQuery match(Pattern... patterns)
```
    Parameters:
    
    patterns - an array of patterns to match in the graph
    
    Returns:
    
    a match query that will find matches of the given patterns
  - match
```
public static MatchQuery match(Collection<? extends Pattern> patterns)
```
    Parameters:
    
    patterns - a collection of patterns to match in the graph
    
    Returns:
    
    a match query that will find matches of the given patterns
  - insert
```
public static InsertQuery insert(Var... vars)
```
    Parameters:
    
    vars - an array of variables to insert into the graph
    
    Returns:
    
    an insert query that will insert the given variables into the graph
  - insert
```
public static InsertQuery insert(Collection<? extends Var> vars)
```
    Parameters:
    
    vars - a collection of variables to insert into the graph
    
    Returns:
    
    an insert query that will insert the given variables into the graph
  - compute
```
public static ComputeQueryBuilder compute()
```
    Returns:
    
    a compute query builder without a specified graph
  - parsePatterns
```
public static java.util.stream.Stream<Pattern> parsePatterns(InputStream inputStream)
```
    Parameters:
    
    inputStream - a stream representing a list of patterns
    
    Returns:
    
    a stream of patterns
  - parsePatterns
```
public static List<Pattern> parsePatterns(String patternsString)
```
    Parameters:
    
    patternsString - a string representing a list of patterns
    
    Returns:
    
    a list of patterns
  - parse
```
public static <T extends Query<?>> T parse(String queryString)
```
    Parameters:
    
    queryString - a string representing a query
    
    Returns:
    
    a query, the type will depend on the type of query.
  - parseList
```
public static List<Query<?>> parseList(String queryString)
```
    Parameters:
    
    queryString - a string representing several queries
    
    Returns:
    
    a list of queries
  - parseTemplate
```
public static <T extends Query<?>> T parseTemplate(String template,
                                                   Map<String,Object> data)
```
    Parameters:
    
    template - a string representing a templated graql query
    
    data - data to use in template
    
    Returns:
    
    a query, the type will depend on the type indicated in the template
  - var
```
public static Var var(String name)
```
    Parameters:
    
    name - the name of the variable
    
    Returns:
    
    a new query variable
  - var
```
public static Var var(VarName name)
```
    Parameters:
    
    name - the name of the variable
    
    Returns:
    
    a new query variable
  - var
```
public static Var var()
```
    Returns:
    
    a new, anonymous query variable
  - name
```
public static Var name(String name)
```
    Parameters:
    
    name - the name of a concept
    
    Returns:
    
    a query variable that identifies a concept by name
  - and
```
public static Pattern and(Pattern... patterns)
```
    Parameters:
    
    patterns - an array of patterns to match
    
    Returns:
    
    a pattern that will match only when all contained patterns match
  - and
```
public static Pattern and(Collection<? extends Pattern> patterns)
```
    Parameters:
    
    patterns - a collection of patterns to match
    
    Returns:
    
    a pattern that will match only when all contained patterns match
  - or
```
public static Pattern or(Pattern... patterns)
```
    Parameters:
    
    patterns - an array of patterns to match
    
    Returns:
    
    a pattern that will match when any contained pattern matches
  - or
```
public static Pattern or(Collection<? extends Pattern> patterns)
```
    Parameters:
    
    patterns - a collection of patterns to match
    
    Returns:
    
    a pattern that will match when any contained pattern matches
  - count
```
public static Aggregate<Object,Long> count()
```
    Create an aggregate that will count the results of a query.
  - sum
```
public static Aggregate<Map<VarName,Concept>,Number> sum(String name)
```
    Create an aggregate that will sum the values of a variable.
  - max
```
public static <T extends Comparable<T>> Aggregate<Map<VarName,Concept>,Optional<T>> max(String name)
```
    Create an aggregate that will find the maximum of a variable's values.
    
    Parameters:
    
    name - the variable to find the maximum of
  - min
```
public static <T extends Comparable<T>> Aggregate<Map<VarName,Concept>,Optional<T>> min(String name)
```
    Create an aggregate that will find the minimum of a variable's values.
    
    Parameters:
    
    name - the variable to find the maximum of
  - average
```
public static Aggregate<Map<VarName,Concept>,Optional<Double>> average(String name)
```
    Create an aggregate that will find the mean of a variable's values.
    
    Parameters:
    
    name - the variable to find the mean of
  - median
```
public static Aggregate<Map<VarName,Concept>,Optional<Number>> median(String name)
```
    Create an aggregate that will find the median of a variable's values.
    
    Parameters:
    
    name - the variable to find the median of
  - group
```
public static Aggregate<Map<VarName,Concept>,Map<Concept,List<Map<VarName,Concept>>>> group(String varName)
```
    Create an aggregate that will group a query by a variable name.
    
    Parameters:
    
    varName - the variable name to group results by
  - group
```
public static <T> Aggregate<Map<VarName,Concept>,Map<Concept,T>> group(String varName,
                                                                       Aggregate<? super Map<VarName,Concept>,T> aggregate)
```
    Create an aggregate that will group a query by a variable name and apply the given aggregate to each group
    
    Type Parameters:
    
    T - the type the aggregate returns
    
    Parameters:
    
    varName - the variable name to group results by
    
    aggregate - the aggregate to apply to each group
  - select
```
@SafeVarargs
public static <S,T> Aggregate<S,Map<String,T>> select(NamedAggregate<? super S,? extends T>... aggregates)
```
    Create an aggregate that will collect together several named aggregates into a map.
    
    Type Parameters:
    
    S - the type that the query returns
    
    T - the type that each aggregate returns
    
    Parameters:
    
    aggregates - the aggregates to join together
  - select
```
public static <S,T> Aggregate<S,Map<String,T>> select(Set<NamedAggregate<? super S,? extends T>> aggregates)
```
    Create an aggregate that will collect together several named aggregates into a map.
    
    Type Parameters:
    
    S - the type that the query returns
    
    T - the type that each aggregate returns
    
    Parameters:
    
    aggregates - the aggregates to join together
  - eq
```
public static ValuePredicate eq(Object value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    a predicate that is true when a value equals the specified value
  - eq
```
public static ValuePredicate eq(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that is true when a value equals the specified value
  - neq
```
public static ValuePredicate neq(Object value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    a predicate that is true when a value does not equal the specified value
  - neq
```
public static ValuePredicate neq(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that is true when a value does not equal the specified value
  - gt
```
public static ValuePredicate gt(Comparable value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    a predicate that is true when a value is strictly greater than the specified value
  - gt
```
public static ValuePredicate gt(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that is true when a value is strictly greater than the specified value
  - gte
```
public static ValuePredicate gte(Comparable value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    a predicate that is true when a value is greater or equal to the specified value
  - gte
```
public static ValuePredicate gte(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that is true when a value is greater or equal to the specified value
  - lt
```
public static ValuePredicate lt(Comparable value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    a predicate that is true when a value is strictly less than the specified value
  - lt
```
public static ValuePredicate lt(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that is true when a value is strictly less than the specified value
  - lte
```
public static ValuePredicate lte(Comparable value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    a predicate that is true when a value is less or equal to the specified value
  - lte
```
public static ValuePredicate lte(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that is true when a value is less or equal to the specified value
  - regex
```
public static ValuePredicate regex(String pattern)
```
    Parameters:
    
    pattern - a regex pattern
    
    Returns:
    
    a predicate that returns true when a value matches the given regular expression
  - contains
```
public static ValuePredicate contains(String substring)
```
    Parameters:
    
    substring - a substring to match
    
    Returns:
    
    a predicate that returns true when a value contains the given substring
  - contains
```
public static ValuePredicate contains(Var var)
```
    Parameters:
    
    var - the variable representing a resource
    
    Returns:
    
    a predicate that returns true when a value contains the given substring

Class Graql

Method Summary

Methods inherited from class java.lang.Object

Method Detail

withoutGraph

match

match

insert

insert

compute

parsePatterns

parsePatterns

parse

parseList

parseTemplate

var

var

var

name

and

and

or

or

count

sum

max

min

average

median

group

group

select

select

eq

eq

neq

neq

gt

gt

gte

gte

lt

lt

lte

lte

regex

contains

contains