org.modeshape.jcr.query.process

## Class SelectComponent

- java.lang.Object
- - org.modeshape.jcr.query.process.ProcessingComponent
  - - org.modeshape.jcr.query.process.DelegatingComponent
    - - org.modeshape.jcr.query.process.SelectComponent

-     public class SelectComponent
      extends DelegatingComponent

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static interface` | `SelectComponent.CompareOperation` Interface defining the `Comparison` functionality for a specific `Operator`.
    `static interface` | `SelectComponent.ConstraintChecker` Interface used to determine whether a tuple satisfies all of the constraints applied to the SELECT node.

    - ### Nested classes/interfaces inherited from class org.modeshape.jcr.query.process.ProcessingComponent

      `ProcessingComponent.DynamicOperation`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SelectComponent(ProcessingComponent delegate, Constraint constraint, Map<String,Object> variables)` Create a SELECT processing component that pass those tuples that satisfy the supplied constraint.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected SelectComponent.ConstraintChecker` | `createChecker(TypeSystem types, Schemata schemata, QueryResults.Columns columns, Constraint constraint, Map<String,Object> variables)` Create the constraint evaluator that is used by the `SelectComponent` to evaluate the supplied `criteria`.
    `protected SelectComponent.ConstraintChecker` | `createChecker(TypeSystem types, Schemata schemata, QueryResults.Columns columns, ProcessingComponent.DynamicOperation dynamicOperation, Operator operator, StaticOperand staticOperand)`
    `List<Object[]>` | `execute()` Execute this stage of processing and return the resulting tuples that each conform to the `columns`.

    - ### Methods inherited from class org.modeshape.jcr.query.process.DelegatingComponent

      `close, delegate`

    - ### Methods inherited from class org.modeshape.jcr.query.process.ProcessingComponent

      `createDynamicOperation, createSortComparator, emptyTuples, getColumns, getContext, getLocationIndexes, problems`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### SelectComponent

          public SelectComponent(ProcessingComponent delegate,
                         Constraint constraint,
                         Map<String,Object> variables)

      Create a SELECT processing component that pass those tuples that satisfy the supplied constraint. Certain constraints (including `FullTextSearch`, `SameNode` and `PropertyExistence`) are evaluated in a fairly limited fashion, essentially operating upon the tuple values themselves.

      For example, the `SameNode` constraint is satisfied when the selected node has the same path as the constraint's `path`. And the `PropertyExistence` constraint is satisfied when the `property` is represented in the tuple with a non-null value. Similarly, `FullTextSearch` always evaluates to true. Obviously these implementations will likely not be sufficient for many purposes. But in cases where these particular constraints are handled in other ways (and thus not expected to be seen by this processor), this form may be sufficient.

      Parameters:
        `delegate` - the delegate processing component that this component should use to obtain the input tuples; may not be null
        `constraint` - the query constraint; may not be null
        `variables` - the map of variables keyed by their name (as used in `BindVariableName` constraints); may be null

  - ### Method Detail

    - #### execute

          public List<Object[]> execute()

      Description copied from class: `ProcessingComponent`
      Execute this stage of processing and return the resulting tuples that each conform to the `columns`.
      Specified by:
        `execute` in class `ProcessingComponent`
      Returns:
        the list of tuples, where each tuple corresonds to the `columns`; never null

    - #### createChecker

          protected SelectComponent.ConstraintChecker createChecker(TypeSystem types,
                                                        Schemata schemata,
                                                        QueryResults.Columns columns,
                                                        Constraint constraint,
                                                        Map<String,Object> variables)

      Create the constraint evaluator that is used by the `SelectComponent` to evaluate the supplied `criteria`.
      Parameters:
        `types` - the type system; may not be null
        `schemata` - the schemata; may not be null
        `columns` - the definition of the result columns and the tuples; may not be null
        `constraint` - the criteria that this `SelectComponent` is to evaluate
        `variables` - the variables that are to be substituted for the various `BindVariableName` `operands`; may not be null
      Returns:
        the constraint evaluator; never null

    - #### createChecker

          protected SelectComponent.ConstraintChecker createChecker(TypeSystem types,
                                                        Schemata schemata,
                                                        QueryResults.Columns columns,
                                                        ProcessingComponent.DynamicOperation dynamicOperation,
                                                        Operator operator,
                                                        StaticOperand staticOperand)

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