Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Alpha6
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.modeshape.jcr.query.model
Class QueryObjectModelFactory

    java.lang.Object
      org.modeshape.jcr.query.model.QueryObjectModelFactory

All Implemented Interfaces:
  QueryObjectModelConstants, QueryObjectModelFactory

    public class QueryObjectModelFactory

extends Object
implements QueryObjectModelFactory

An implementation of the JCR `QueryObjectModelFactory`. Note that this implementation constructs the query components but does not validate any of the parameters or the resulting query definition. All validation is performed when the query is `executed`.

Field Summary
`static String` | `LANGUAGE`

Fields inherited from interface javax.jcr.query.qom.QueryObjectModelConstants
`JCR_JOIN_TYPE_INNER, JCR_JOIN_TYPE_LEFT_OUTER, JCR_JOIN_TYPE_RIGHT_OUTER, JCR_OPERATOR_EQUAL_TO, JCR_OPERATOR_GREATER_THAN, JCR_OPERATOR_GREATER_THAN_OR_EQUAL_TO, JCR_OPERATOR_LESS_THAN, JCR_OPERATOR_LESS_THAN_OR_EQUAL_TO, JCR_OPERATOR_LIKE, JCR_OPERATOR_NOT_EQUAL_TO, JCR_ORDER_ASCENDING, JCR_ORDER_DESCENDING`

Constructor Summary
`QueryObjectModelFactory(JcrQueryContext context)`

Method Summary
`ArithmeticOperand` | `add(DynamicOperand left, DynamicOperand right)` Create an arithmetic dynamic operand that adds the numeric value of the two supplied operand(s).
`And` | `and(Constraint constraint1, Constraint constraint2)`
`ArithmeticOperand` | `arithmeticOperand(DynamicOperand left, ArithmeticOperator operator, DynamicOperand right)`
`Ordering` | `ascending(DynamicOperand operand)`
`Between` | `between(DynamicOperand operand, StaticOperand lowerBound, StaticOperand upperBound, boolean includeLowerBound, boolean includeUpperBound)` Tests that the value (or values) defined by the supplied dynamic operand are within a specified range.
`BindVariableValue` | `bindVariable(String bindVariableName)`
`ChildNode` | `childNode(String selectorName, String path)`
`ChildNodeJoinCondition` | `childNodeJoinCondition(String childSelectorName, String parentSelectorName)`
`Column` | `column(String selectorName, String propertyName, String columnName)`
`Comparison` | `comparison(DynamicOperand operand1, String operator, StaticOperand operand2)`
`QueryObjectModel` | `createQuery(SelectQuery command)` Creates a query for a select query command.
`SetQueryObjectModel` | `createQuery(SetQuery command)` Creates a set query.
`QueryObjectModel` | `createQuery(Source source, Constraint constraint, Ordering[] orderings, Column[] columns)`
`DescendantNode` | `descendantNode(String selectorName, String path)`
`DescendantNodeJoinCondition` | `descendantNodeJoinCondition(String descendantSelectorName, String ancestorSelectorName)`
`Ordering` | `descending(DynamicOperand operand)`
`ArithmeticOperand` | `divide(DynamicOperand left, DynamicOperand right)` Create an arithmetic dynamic operand that divides the numeric value of the first operand by the numeric value of the second.
`EquiJoinCondition` | `equiJoinCondition(String selector1Name, String property1Name, String selector2Name, String property2Name)`
`SetQuery` | `except(QueryCommand left, QueryCommand right, Ordering[] orderings, Limit limit, boolean all)` Creates a query command that returns all rows that are in the result of the left-hand query but not in the result of the right-hand query.
`FullTextSearch` | `fullTextSearch(String selectorName, String propertyName, StaticOperand fullTextSearchExpression)`
`FullTextSearchScore` | `fullTextSearchScore(String selectorName)`
`SetCriteria` | `in(DynamicOperand operand, StaticOperand... values)` Tests that the value (or values) defined by the supplied dynamic operand are found within the specified set of values.
`SetQuery` | `intersect(QueryCommand left, QueryCommand right, Ordering[] orderings, Limit limit, boolean all)` Creates a query command that returns all rows that are both in the result of the left-hand query and in the result of the right-hand query.
`Join` | `join(Source left, Source right, String joinType, JoinCondition joinCondition)`
`Length` | `length(PropertyValue propertyValue)`
`Limit` | `limit(int rowLimit, int offset)` Evaluates to a limit on the maximum number of tuples in the results and the number of rows that are skipped before the first tuple in the results.
`LiteralValue` | `literal(Value literalValue)`
`LowerCase` | `lowerCase(DynamicOperand operand)`
`ArithmeticOperand` | `multiply(DynamicOperand left, DynamicOperand right)` Create an arithmetic dynamic operand that multplies the numeric value of the first operand by the numeric value of the second.
`NodeDepth` | `nodeDepth(String selectorName)` Evaluates to a `LONG` value equal to the depth of a node in the specified selector.
`NodeLocalName` | `nodeLocalName(String selectorName)`
`NodeName` | `nodeName(String selectorName)`
`NodePath` | `nodePath(String selectorName)` Evaluates to a `PATH` value equal to the prefix-qualified path of a node in the specified selector.
`Not` | `not(Constraint constraint)`
`Or` | `or(Constraint constraint1, Constraint constraint2)`
`PropertyExistence` | `propertyExistence(String selectorName, String propertyName)`
`PropertyValue` | `propertyValue(String selectorName, String propertyName)`
`ReferenceValue` | `referenceValue(String selectorName)` Creates a dynamic operand that evaluates to the REFERENCE value of the any property on the specified selector.
`ReferenceValue` | `referenceValue(String selectorName, String propertyName)` Creates a dynamic operand that evaluates to the REFERENCE value of the specified property on the specified selector.
`SameNode` | `sameNode(String selectorName, String path)`
`SameNodeJoinCondition` | `sameNodeJoinCondition(String selector1Name, String selector2Name, String selector2Path)`
`SelectQuery` | `select(Source source, Constraint constraint, Ordering[] orderings, Column[] columns, Limit limit, boolean distinct)` Creates a query with one or more selectors.
`NamedSelector` | `selector(String nodeTypeName, String selectorName)`
`protected SelectorName` | `selectorName(String name)`
`SetQuery` | `setQuery(QueryCommand left, SetQuery.Operation operation, QueryCommand right, Ordering[] orderings, Limit limit, boolean all)`
`Subquery` | `subquery(QueryCommand subqueryCommand)` Creates a subquery that can be used as a `StaticOperand` in another query.
`ArithmeticOperand` | `subtract(DynamicOperand left, DynamicOperand right)` Create an arithmetic dynamic operand that subtracts the numeric value of the second operand from the numeric value of the first.
`SetQuery` | `union(QueryCommand left, QueryCommand right, Ordering[] orderings, Limit limit, boolean all)` Creates a query command that effectively appends the results of the right-hand query to those of the left-hand query.
`UpperCase` | `upperCase(DynamicOperand operand)`

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

Field Detail

### LANGUAGE

    public static final String LANGUAGE

See Also:
  Constant Field Values

Constructor Detail

### QueryObjectModelFactory

    public QueryObjectModelFactory(JcrQueryContext context)

Method Detail

### selectorName

    protected SelectorName selectorName(String name)

### createQuery

    public QueryObjectModel createQuery(Source source,
                                        Constraint constraint,
                                        Ordering[] orderings,
                                        Column[] columns)

  Specified by:
    `createQuery` in interface `QueryObjectModelFactory`

### createQuery

    public SetQueryObjectModel createQuery(SetQuery command)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a set query.

  Parameters:
    `command` - set query; non-null
  Returns:
    the executable query; non-null

### createQuery

    public QueryObjectModel createQuery(SelectQuery command)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a query for a select query command.

  Parameters:
    `command` - select query; non-null
  Returns:
    the executable query; non-null

### select

    public SelectQuery select(Source source,
                              Constraint constraint,
                              Ordering[] orderings,
                              Column[] columns,
                              Limit limit,
                              boolean distinct)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a query with one or more selectors.

  Parameters:
    `source` - the node-tuple source; non-null
    `constraint` - the constraint, or null if none
    `orderings` - zero or more orderings; null is equivalent to a zero-length array
    `columns` - the columns; null is equivalent to a zero-length array
    `limit` - the limit; null is equivalent to having no limit
    `distinct` - true if the query should return distinct values; or false if no duplicate removal should be performed
  Returns:
    the select query; non-null

### union

    public SetQuery union(QueryCommand left,
                          QueryCommand right,
                          Ordering[] orderings,
                          Limit limit,
                          boolean all)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a query command that effectively appends the results of the right-hand query to those of the left-hand query.

  Parameters:
    `left` - the query command that represents left-side of the set operation; non-null and must have columns that are equivalent and union-able to those of the right-side query
    `right` - the query command that represents right-side of the set operation; non-null and must have columns that are equivalent and union-able to those of the left-side query
    `orderings` - zero or more orderings; null is equivalent to a zero-length array
    `limit` - the limit; null is equivalent to having no limit
    `all` - true if duplicate rows in the left- and right-hand side results should be included, or false if duplicate rows should be eliminated
  Returns:
    the select query; non-null

### intersect

    public SetQuery intersect(QueryCommand left,
                              QueryCommand right,
                              Ordering[] orderings,
                              Limit limit,
                              boolean all)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a query command that returns all rows that are both in the result of the left-hand query and in the result of the right-hand query.

  Parameters:
    `left` - the query command that represents left-side of the set operation; non-null and must have columns that are equivalent and union-able to those of the right-side query
    `right` - the query command that represents right-side of the set operation; non-null and must have columns that are equivalent and union-able to those of the left-side query
    `orderings` - zero or more orderings; null is equivalent to a zero-length array
    `limit` - the limit; null is equivalent to having no limit
    `all` - true if duplicate rows in the left- and right-hand side results should be included, or false if duplicate rows should be eliminated
  Returns:
    the select query; non-null

### except

    public SetQuery except(QueryCommand left,
                           QueryCommand right,
                           Ordering[] orderings,
                           Limit limit,
                           boolean all)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a query command that returns all rows that are in the result of the left-hand query but not in the result of the right-hand query.

  Parameters:
    `left` - the query command that represents left-side of the set operation; non-null and must have columns that are equivalent and union-able to those of the right-side query
    `right` - the query command that represents right-side of the set operation; non-null and must have columns that are equivalent and union-able to those of the left-side query
    `orderings` - zero or more orderings; null is equivalent to a zero-length array
    `limit` - the limit; null is equivalent to having no limit
    `all` - true if duplicate rows in the left- and right-hand side results should be included, or false if duplicate rows should be eliminated
  Returns:
    the select query; non-null

### setQuery

    public SetQuery setQuery(QueryCommand left,
                             SetQuery.Operation operation,
                             QueryCommand right,
                             Ordering[] orderings,
                             Limit limit,
                             boolean all)

### selector

    public NamedSelector selector(String nodeTypeName,
                                  String selectorName)

  Specified by:
    `selector` in interface `QueryObjectModelFactory`

### column

    public Column column(String selectorName,
                         String propertyName,
                         String columnName)

  Specified by:
    `column` in interface `QueryObjectModelFactory`

### ascending

    public Ordering ascending(DynamicOperand operand)

  Specified by:
    `ascending` in interface `QueryObjectModelFactory`

### descending

    public Ordering descending(DynamicOperand operand)

  Specified by:
    `descending` in interface `QueryObjectModelFactory`

### and

    public And and(Constraint constraint1,
                   Constraint constraint2)

  Specified by:
    `and` in interface `QueryObjectModelFactory`

### bindVariable

    public BindVariableValue bindVariable(String bindVariableName)

  Specified by:
    `bindVariable` in interface `QueryObjectModelFactory`

### childNode

    public ChildNode childNode(String selectorName,
                               String path)

  Specified by:
    `childNode` in interface `QueryObjectModelFactory`

### childNodeJoinCondition

    public ChildNodeJoinCondition childNodeJoinCondition(String childSelectorName,
                                                         String parentSelectorName)

  Specified by:
    `childNodeJoinCondition` in interface `QueryObjectModelFactory`

### comparison

    public Comparison comparison(DynamicOperand operand1,
                                 String operator,
                                 StaticOperand operand2)

  Specified by:
    `comparison` in interface `QueryObjectModelFactory`

### descendantNode

    public DescendantNode descendantNode(String selectorName,
                                         String path)

  Specified by:
    `descendantNode` in interface `QueryObjectModelFactory`

### descendantNodeJoinCondition

    public DescendantNodeJoinCondition descendantNodeJoinCondition(String descendantSelectorName,
                                                                   String ancestorSelectorName)

  Specified by:
    `descendantNodeJoinCondition` in interface `QueryObjectModelFactory`

### equiJoinCondition

    public EquiJoinCondition equiJoinCondition(String selector1Name,
                                               String property1Name,
                                               String selector2Name,
                                               String property2Name)

  Specified by:
    `equiJoinCondition` in interface `QueryObjectModelFactory`

### fullTextSearch

    public FullTextSearch fullTextSearch(String selectorName,
                                         String propertyName,
                                         StaticOperand fullTextSearchExpression)
                                  throws RepositoryException

  Specified by:
    `fullTextSearch` in interface `QueryObjectModelFactory`
  Throws:
    `RepositoryException`

### fullTextSearchScore

    public FullTextSearchScore fullTextSearchScore(String selectorName)

  Specified by:
    `fullTextSearchScore` in interface `QueryObjectModelFactory`

### join

    public Join join(Source left,
                     Source right,
                     String joinType,
                     JoinCondition joinCondition)

  Specified by:
    `join` in interface `QueryObjectModelFactory`

### length

    public Length length(PropertyValue propertyValue)

  Specified by:
    `length` in interface `QueryObjectModelFactory`

### literal

    public LiteralValue literal(Value literalValue)
                         throws RepositoryException

  Specified by:
    `literal` in interface `QueryObjectModelFactory`
  Throws:
    `RepositoryException`

### lowerCase

    public LowerCase lowerCase(DynamicOperand operand)

  Specified by:
    `lowerCase` in interface `QueryObjectModelFactory`

### nodeLocalName

    public NodeLocalName nodeLocalName(String selectorName)

  Specified by:
    `nodeLocalName` in interface `QueryObjectModelFactory`

### nodeName

    public NodeName nodeName(String selectorName)

  Specified by:
    `nodeName` in interface `QueryObjectModelFactory`

### not

    public Not not(Constraint constraint)

  Specified by:
    `not` in interface `QueryObjectModelFactory`

### or

    public Or or(Constraint constraint1,
                 Constraint constraint2)

  Specified by:
    `or` in interface `QueryObjectModelFactory`

### propertyExistence

    public PropertyExistence propertyExistence(String selectorName,
                                               String propertyName)

  Specified by:
    `propertyExistence` in interface `QueryObjectModelFactory`

### propertyValue

    public PropertyValue propertyValue(String selectorName,
                                       String propertyName)

  Specified by:
    `propertyValue` in interface `QueryObjectModelFactory`

### sameNode

    public SameNode sameNode(String selectorName,
                             String path)

  Specified by:
    `sameNode` in interface `QueryObjectModelFactory`

### sameNodeJoinCondition

    public SameNodeJoinCondition sameNodeJoinCondition(String selector1Name,
                                                       String selector2Name,
                                                       String selector2Path)

  Specified by:
    `sameNodeJoinCondition` in interface `QueryObjectModelFactory`

### upperCase

    public UpperCase upperCase(DynamicOperand operand)

  Specified by:
    `upperCase` in interface `QueryObjectModelFactory`

### nodePath

    public NodePath nodePath(String selectorName)

  Description copied from interface: `QueryObjectModelFactory`
  Evaluates to a `PATH` value equal to the prefix-qualified path of a node in the specified selector.

  The query is invalid if `selector` is not the name of a selector in the query.

  Parameters:
    `selectorName` - the selector name; non-null
  Returns:
    the operand; non-null

### nodeDepth

    public NodeDepth nodeDepth(String selectorName)

  Description copied from interface: `QueryObjectModelFactory`
  Evaluates to a `LONG` value equal to the depth of a node in the specified selector.

  The query is invalid if `selector` is not the name of a selector in the query.

  Parameters:
    `selectorName` - the selector name; non-null
  Returns:
    the operand; non-null

### limit

    public Limit limit(int rowLimit,
                       int offset)

  Description copied from interface: `QueryObjectModelFactory`
  Evaluates to a limit on the maximum number of tuples in the results and the number of rows that are skipped before the first tuple in the results.

  Parameters:
    `rowLimit` - the maximum number of rows; must be a positive number, or `Integer.MAX_VALUE` if there is to be a non-zero offset but no limit
    `offset` - the number of rows to skip before beginning the results; must be 0 or a positive number
  Returns:
    the operand; non-null

### between

    public Between between(DynamicOperand operand,
                           StaticOperand lowerBound,
                           StaticOperand upperBound,
                           boolean includeLowerBound,
                           boolean includeUpperBound)

  Description copied from interface: `QueryObjectModelFactory`
  Tests that the value (or values) defined by the supplied dynamic operand are within a specified range. The range is specified by a lower and upper bound, and whether each of the boundary values is included in the range.

  Parameters:
    `operand` - the dynamic operand describing the values that are to be constrained
    `lowerBound` - the lower bound of the range
    `upperBound` - the upper bound of the range
    `includeLowerBound` - true if the lower boundary value is not be included
    `includeUpperBound` - true if the upper boundary value is not be included
  Returns:
    the constraint; non-null

### in

    public SetCriteria in(DynamicOperand operand,
                          StaticOperand... values)

  Description copied from interface: `QueryObjectModelFactory`
  Tests that the value (or values) defined by the supplied dynamic operand are found within the specified set of values.

  Parameters:
    `operand` - the dynamic operand describing the values that are to be constrained
    `values` - the static operand values; may not be null or empty
  Returns:
    the constraint; non-null

### subquery

    public Subquery subquery(QueryCommand subqueryCommand)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a subquery that can be used as a `StaticOperand` in another query.

  Parameters:
    `subqueryCommand` - the query command that is to be used as the subquery
  Returns:
    the constraint; non-null

### add

    public ArithmeticOperand add(DynamicOperand left,
                                 DynamicOperand right)

  Description copied from interface: `QueryObjectModelFactory`
  Create an arithmetic dynamic operand that adds the numeric value of the two supplied operand(s).

  Parameters:
    `left` - the left-hand-side operand; not null
    `right` - the right-hand-side operand; not null
  Returns:
    the dynamic operand; non-null

### subtract

    public ArithmeticOperand subtract(DynamicOperand left,
                                      DynamicOperand right)

  Description copied from interface: `QueryObjectModelFactory`
  Create an arithmetic dynamic operand that subtracts the numeric value of the second operand from the numeric value of the first.

  Parameters:
    `left` - the left-hand-side operand; not null
    `right` - the right-hand-side operand; not null
  Returns:
    the dynamic operand; non-null

### multiply

    public ArithmeticOperand multiply(DynamicOperand left,
                                      DynamicOperand right)

  Description copied from interface: `QueryObjectModelFactory`
  Create an arithmetic dynamic operand that multplies the numeric value of the first operand by the numeric value of the second.

  Parameters:
    `left` - the left-hand-side operand; not null
    `right` - the right-hand-side operand; not null
  Returns:
    the dynamic operand; non-null

### divide

    public ArithmeticOperand divide(DynamicOperand left,
                                    DynamicOperand right)

  Description copied from interface: `QueryObjectModelFactory`
  Create an arithmetic dynamic operand that divides the numeric value of the first operand by the numeric value of the second.

  Parameters:
    `left` - the left-hand-side operand; not null
    `right` - the right-hand-side operand; not null
  Returns:
    the dynamic operand; non-null

### arithmeticOperand

    public ArithmeticOperand arithmeticOperand(DynamicOperand left,
                                               ArithmeticOperator operator,
                                               DynamicOperand right)

### referenceValue

    public ReferenceValue referenceValue(String selectorName)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a dynamic operand that evaluates to the REFERENCE value of the any property on the specified selector.

  The query is invalid if:

  - `selector` is not the name of a selector in the query, or
  - `property` is not a syntactically valid JCR name.

  Parameters:
    `selectorName` - the selector name; non-null
  Returns:
    the operand; non-null

### referenceValue

    public ReferenceValue referenceValue(String selectorName,
                                         String propertyName)

  Description copied from interface: `QueryObjectModelFactory`
  Creates a dynamic operand that evaluates to the REFERENCE value of the specified property on the specified selector.

  The query is invalid if:

  - `selector` is not the name of a selector in the query, or
  - `property` is not a syntactically valid JCR name.

  Parameters:
    `selectorName` - the selector name; non-null
    `propertyName` - the reference property name; non-null
  Returns:
    the operand; non-null

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| ModeShape Distribution 3.0.0.Alpha6
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2008-2012 JBoss, a division of Red Hat. All Rights Reserved.