IRelation

All Known Implementing Classes:

AggregateProxy, DivideByPerProxy, ExtendProxy, GroupProxy, GTCloseProxy, IntersectProxy, IntersectUsingProxy, JoinProxy, JoinUsingProxy, MinusProxy, MinusUsingProxy, PackProxy, ProjectProxy, Relation, RelationProxy, RelvarProxy, RenameProxy, RestrictProxy, SemiJoinProxy, SemiJoinUsingProxy, SemiMinusProxy, SemiMinusUsingProxy, SummarizebyProxy, TCloseProxy, TransformProxy, UngroupProxy, UnionProxy, UnionUsingProxy, UnpackProxy
```
public interface IRelation
```
Author:

erwin

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`IRelation`	`aggregate(java.util.Map<NameIdentifier,java.lang.String> expressions)` Computes the aggregation of this relation, per the given aggregation specs.
`boolean`	`contains(IRelation r)` Checks whether this relation contains all tuples of the given relation.
`boolean`	`contains(Tuple t)` Checks whether this relation contains the given tuple.
`boolean`	`containsUsing(IRelation r, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Checks whether this relation contains all tuples of the given relation, with the given usingAttributes treated in 'USING' mode.
`boolean`	`containsUsing(Tuple t, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Checks whether this relation contains the given tuple, with the given usingAttributes treated in 'USING' mode.
`IRelation`	`dividedyper(IRelation divisor, IRelation per)` Computes the division of this relation by the given divisor, per the given 'per' relation.
`IRelation`	`extend(java.util.Map<NameIdentifier,java.lang.String> extendExpressions)` Computes the extend of this relation, according to the specs provided in extendExpressions.
`java.lang.String`	`getHostExpressionEvaluationText()` Gets The expression text for the expression to be evaluated by the host
`RelationBuffer`	`getRelationBuffer()` Gets the RelationBuffer holding the tuples collection.
`IRelation`	`group(java.util.Map<NameIdentifier,java.util.Set<NameIdentifier>> groupAttributes)` Computes the grouping of this relation, according to the specs provided in groupAttributes.
`IRelation`	`gtclose(java.util.Map<NameIdentifier,NameIdentifier> matchby, java.util.Map<NameIdentifier,java.lang.String> expressions)` Computes the generalized transitive closure of this relation, according to the specs provided in matchby and expressions.
`IRelation`	`intersect(IRelation intersectWith)` Computes the intersection of this relation with the given one.
`IRelation`	`intersectUsing(IRelation intersectWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the intersection of this relation with the given one, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`boolean`	`isProxy()` Checks whether this object is a proxy for a relation.
`IRelation`	`join(IRelation joinwith)` Computes the join of this relation with the given one, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`IRelation`	`joinUsing(IRelation joinwith, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the join of this relation with the given one, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`IRelation`	`leftJoin(IRelation leftjoinwith, java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions)` Computes the leftjoin of this relation with the given one.
`IRelation`	`leftJoinUsing(IRelation leftjoinwith, java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the leftjoin of this relation with the given one.
`IRelation`	`minus(IRelation subtrahend)` Computes the difference of this relation with the given subtrahend, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`IRelation`	`minusFrom(IRelation minuend)` Computes the difference between the given relation and this one.
`IRelation`	`minusUsing(IRelation subtrahend, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the difference of this relation with the given subtrahend, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`IRelation`	`minusUsingFrom(IRelation minuend, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the difference between the given relation and this one, with the attributes mentioned in usingAttributes treated in 'USING' mode.
`IRelation`	`pack(NameIdentifier... packAttributes)` Computes an pack of this relation.
`IRelation`	`project(NameIdentifier... attributes)` Computes the projection of this relation over the attributes provided.
`IRelation`	`rename(java.util.Map<NameIdentifier,NameIdentifier> renames)` Computes the rename of this relation according to the provided rename specs.
`IRelation`	`restrict(java.lang.String restrictExpression)` Computes the restriction of this relation to the set of tuples that satisfy the given boolean expression.
`IRelation`	`semijoin(IRelation semiJoinWith)` Computes the semijoin between this relation and the given one.
`IRelation`	`semiJoinFor(IRelation semiJoinLeftArg)` Computes the semijoin between the given relation and this one.
`IRelation`	`semijoinUsing(IRelation semiJoinWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the semijoin between this relation and the given one.
`IRelation`	`semijoinUsingFor(IRelation semiJoinLeftArg, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the semijoin between the given relation and this one, with the attributes mentioned in usingAttributes treated in 'USING' mode.
`IRelation`	`semiminus(IRelation semiDiffWith)` Computes the semidifference between this relation and the given one.
`IRelation`	`semiminusFor(IRelation semiMinusLeftArg)` Computes the semiminus between the given relation and this one.
`IRelation`	`semiminusUsing(IRelation semiDiffWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the semidifference between this relation and the given one.
`IRelation`	`semiminusUsingFor(IRelation semiMinusLeftArg, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the semiminus between the given relation and this one, with the attributes mentioned in usingAttributes treated in 'USING' mode.
`IRelation`	`summarizeby(java.util.Set<NameIdentifier> byAttributes, java.util.Map<NameIdentifier,java.lang.String> expressions)` Computes the summaries specified by expressions groups of tuples in this relation, with the grouping as specified in byAttributes.
`IRelation`	`tclose(java.util.Map<NameIdentifier,NameIdentifier> matchby)` Computes the transitive closure of the given relation using the attribute matching as specified by matchby.
`IRelation`	`transform(java.util.Map<NameIdentifier,java.lang.String> transformSpecs)` Computes the specified transformation of this relation.
`IRelation`	`ungroup(NameIdentifier... ungroupAttributes)` Computes the ungrouping of this relation using the specified ungroup attributes.
`IRelation`	`union(IRelation unionWith)` Computes the union of this relation with another one, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`IRelation`	`unionUsing(IRelation unionWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the union of this relation with another one, with explicitly specified attributes (and only those) to be treated in 'USING' mode.
`IRelation`	`unpack(NameIdentifier... unpackAttributes)` Computes an unpack of this relation.
`IRelation`	`xminus(IRelation symdiffWith)` Computes the symmetric difference between this relation and the given one.
`IRelation`	`xminusUsing(IRelation symdiffWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes)` Computes the symmetric difference between this relation and the given one, with the attributes mentioned in usingAttributes treated in 'USING' mode.

- Method Detail
  - aggregate
```
IRelation aggregate(java.util.Map<NameIdentifier,java.lang.String> expressions)
```
    Computes the aggregation of this relation, per the given aggregation specs. For more details about relational aggregation, see AGGREGATE.
    
    Parameters:
    
    expressions - the map defining the names for the attributes holding the computed aggregation values in the result, and the expressions texts of the expressions for computing them
    
    Returns:
    
    the result of aggregating this relation according to the aggregation specs in expressions
  - contains
```
boolean contains(IRelation r)
          throws EvaluationException
```
    Checks whether this relation contains all tuples of the given relation.
    
    Parameters:
    
    r - the relation to be checked for containment within this relation
    
    Returns:
    
    true if this relation contains all tuples of the given relation.
    
    Throws:
    
    EvaluationException - If immediate evaluation was attempted and that evaluation failed for any reason
  - contains
```
boolean contains(Tuple t)
          throws EvaluationException
```
    Checks whether this relation contains the given tuple.
    
    Parameters:
    
    t - the tuple to be checked for containment in this relation
    
    Returns:
    
    true if this relation contains the given tuple
    
    Throws:
    
    EvaluationException - If immediate evaluation was attempted and that evaluation failed for any reason
  - containsUsing
```
boolean containsUsing(IRelation r,
                      java.util.LinkedHashSet<NameIdentifier> usingAttributes)
               throws EvaluationException
```
    Checks whether this relation contains all tuples of the given relation, with the given usingAttributes treated in 'USING' mode.
    
    Parameters:
    
    r - the relation to be checked for containment within this relation
    
    usingAttributes - the in-order list of interval-typed attributes to be treated in 'USING' mode for the intersection and the packing of the result
    
    Returns:
    
    true if this relation contains all tuples of the given relation, with the given usingAttributes treated in 'USING' mode.
    
    Throws:
    
    EvaluationException - If immediate evaluation was attempted and that evaluation failed for any reason
  - containsUsing
```
boolean containsUsing(Tuple t,
                      java.util.LinkedHashSet<NameIdentifier> usingAttributes)
               throws EvaluationException
```
    Checks whether this relation contains the given tuple, with the given usingAttributes treated in 'USING' mode.
    
    Parameters:
    
    t - the tuple to be checked for containment in this relation
    
    usingAttributes - the in-order list of interval-typed attributes to be treated in 'USING' mode for the intersection and the packing of the result
    
    Returns:
    
    true if this relation contains the given tuple, with the given usingAttributes treated in 'USING' mode
    
    Throws:
    
    EvaluationException - If immediate evaluation was attempted and that evaluation failed for any reason
  - dividedyper
```
IRelation dividedyper(IRelation divisor,
                      IRelation per)
               throws ValidationException,
                      EvaluationException
```
    Computes the division of this relation by the given divisor, per the given 'per' relation. For more details about relational division, see DIVIDEBYPER.
    
    Parameters:
    
    divisor - the divisor by which this relation is to be relationally divided
    
    per - the 'per' relation as per TTM divide
    
    Returns:
    
    the result of dividing this relation by the divisor per the 'per' relation
    
    Throws:
    
    EvaluationException - If immediate evaluation was attempted and that evaluation failed for any reason
    
    ValidationException - If the given combination of relations do not constitute a valid relational division operation
  - extend
```
IRelation extend(java.util.Map<NameIdentifier,java.lang.String> extendExpressions)
```
    Computes the extend of this relation, according to the specs provided in extendExpressions. For more details about grouping, see EXTEND.
    
    Parameters:
    
    extendExpressions - the map defining the names for the attributes holding the computed extend values in the result, and the expressions texts of the expressions for computing them
    
    Returns:
    
    the result of extending this relation according to the specs given in the extendExpressions
  - getHostExpressionEvaluationText
```
java.lang.String getHostExpressionEvaluationText()
```
    Gets The expression text for the expression to be evaluated by the host
    
    Returns:
    
    The expression text for the expression to be evaluated by the host
  - getRelationBuffer
```
RelationBuffer getRelationBuffer()
                          throws EvaluationException
```
    Gets the RelationBuffer holding the tuples collection.
    
    Returns:
    
    the RelationBuffer holding the tuples collection
    
    Throws:
    
    EvaluationException - If an expression evaluation on the server failed for any reason. The exception reflecting that reason will be contained as cause in the EvaluationException object.
  - group
```
IRelation group(java.util.Map<NameIdentifier,java.util.Set<NameIdentifier>> groupAttributes)
         throws EvaluationException
```
    Computes the grouping of this relation, according to the specs provided in groupAttributes. For more details about grouping, see GROUP.
    
    Parameters:
    
    groupAttributes - The specification of the groupings to be applied. Each entry consists of an attribute name for the relation-valued attribute in the result, and the set of attributes of this relation that that relation-typed attribute is to include.
    
    Returns:
    
    the result of grouping this relation according to the specs given in groupAttributes
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - gtclose
```
IRelation gtclose(java.util.Map<NameIdentifier,NameIdentifier> matchby,
                  java.util.Map<NameIdentifier,java.lang.String> expressions)
```
    Computes the generalized transitive closure of this relation, according to the specs provided in matchby and expressions. For more details about generalized transitive closure, see GTCLOSE.
    
    Parameters:
    
    matchby - The specification of the closure's matching scheme
    
    expressions - the specifications of the expressions for determining the values of all the attributes of the involved relation that are not part of the closure's matching scheme (i.e. the attributes not mentioned in matchby)
    
    Returns:
    
    the result of computing the generalized transitive closure of this relation according to the specs in matchby and expressions
  - intersect
```
IRelation intersect(IRelation intersectWith)
             throws EvaluationException
```
    Computes the intersection of this relation with the given one. For more details about relational intersection, see INTERSECT.
    
    Parameters:
    
    intersectWith - the relation to intersect with this one
    
    Returns:
    
    the result of intersecting this relation with the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - intersectUsing
```
IRelation intersectUsing(IRelation intersectWith,
                         java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                  throws EvaluationException
```
    Computes the intersection of this relation with the given one, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about relational intersection, see INTERSECT.
    
    Parameters:
    
    intersectWith - the relation to intersect with this one
    
    usingAttributes - the in-order list of interval-typed attributes to be treated in 'USING' mode for the intersection and the packing of the result
    
    Returns:
    
    the result of intersecting this relation with the given one, with the attributes specified in usingAttributes (and only those) treated in 'using' mode
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - isProxy
```
boolean isProxy()
```
    Checks whether this object is a proxy for a relation. Proxies for relations have most of their validation and evaluation done only upon the invocation of the getRelationBuffer() method.
    
    Returns:
    
    true if this relation object is actually a proxy for a relation on some host/server, false if it is a 'materialized' relation value at the local client site
  - join
```
IRelation join(IRelation joinwith)
        throws EvaluationException
```
    Computes the join of this relation with the given one, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about relational join, see JOIN.
    
    Parameters:
    
    joinwith - the relation to join with this one
    
    Returns:
    
    the result of joining this relation with the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - joinUsing
```
IRelation joinUsing(IRelation joinwith,
                    java.util.LinkedHashSet<NameIdentifier> usingAttributes)
             throws EvaluationException
```
    Computes the join of this relation with the given one, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about relational join, see JOIN.
    
    Parameters:
    
    joinwith - the relation to join with this one
    
    usingAttributes - the names of the interval-typed attributes to be treated in 'USING' mode by the join
    
    Returns:
    
    the result of joining this relation with the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - leftJoin
```
IRelation leftJoin(IRelation leftjoinwith,
                   java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions)
            throws EvaluationException,
                   ValidationException
```
    Computes the leftjoin of this relation with the given one. For more details about relational leftjoin, see LEFTJOIN.
    
    Parameters:
    
    leftjoinwith - the relation to leftjoin this one to
    
    missingAttributeValueExpressions - The map of attributeName to default value epxression texts for all the attributes that appear in the leftjoinwith argument and are not join attributes
    
    Returns:
    
    the result of left-joining this relation with the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - if the leftjoinwith argument is not join-compatible with this one, or if the missingAttributeValueExpressions do not define a map with expressions of the appropriate type for all and exactly the attributes of the leftjoinwith argument that do not appear in this relation
  - leftJoinUsing
```
IRelation leftJoinUsing(IRelation leftjoinwith,
                        java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions,
                        java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                 throws EvaluationException,
                        ValidationException
```
    Computes the leftjoin of this relation with the given one. For more details about relational leftjoin, see LEFTJOIN.
    
    Parameters:
    
    leftjoinwith - the relation to leftjoin this one to
    
    missingAttributeValueExpressions - The map of attributeName to default value epxression texts for all the attributes that appear in the leftjoinwith argument and are not join attributes
    
    usingAttributes - the names of the interval-typed attributes to be treated in 'USING' mode by the join
    
    Returns:
    
    the result of left-joining this relation with the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - if the leftjoinwith argument is not join-compatible with this one, or if the missingAttributeValueExpressions do not define a map with expressions of the appropriate type for all and exactly the attributes of the leftjoinwith argument that do not appear in this relation
  - minus
```
IRelation minus(IRelation subtrahend)
         throws EvaluationException
```
    Computes the difference of this relation with the given subtrahend, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about relational difference, see MINUS.
    
    Parameters:
    
    subtrahend - the relation to subtract from this one
    
    Returns:
    
    the result of subtracting the subtrahend from this relation
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - minusFrom
```
IRelation minusFrom(IRelation minuend)
             throws EvaluationException
```
    Computes the difference between the given relation and this one. For more details about relational difference, see MINUS
    
    Parameters:
    
    minuend - the relation that is the minuend in a relational difference in which we are the subtrahend
    
    Returns:
    
    the result from computing the difference between the given relation and this one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - minusUsing
```
IRelation minusUsing(IRelation subtrahend,
                     java.util.LinkedHashSet<NameIdentifier> usingAttributes)
              throws EvaluationException
```
    Computes the difference of this relation with the given subtrahend, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about relational difference, see MINUS.
    
    Parameters:
    
    subtrahend - the relation to be 'subtracted' from this one, with the specified usingAttributes being treated in 'using' mode
    
    usingAttributes - the in-order list of interval-typed attributes to be treated in 'USING' mode for the difference and the subsequent packing of the result
    
    Returns:
    
    the relational difference between this relation and the given subtrahnd, with the attributes specified in usingAttributes (and only those) treated in 'using' mode
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - minusUsingFrom
```
IRelation minusUsingFrom(IRelation minuend,
                         java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                  throws EvaluationException
```
    Computes the difference between the given relation and this one, with the attributes mentioned in usingAttributes treated in 'USING' mode. For more details about relational difference, see MINUSUSING
    
    Parameters:
    
    minuend - the relation that is the minuend in a relational difference in which we are the subtrahend
    
    usingAttributes - the interval-typed attributes over which this relation is to be unpacked
    
    Returns:
    
    the result from computing the difference between the given relation and this one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - pack
```
IRelation pack(NameIdentifier... packAttributes)
        throws EvaluationException,
               ValidationException
```
    Computes an pack of this relation. For more details about pack, see PACK.
    
    Parameters:
    
    packAttributes - the interval-typed attributes over which this relation is to be packed
    
    Returns:
    
    the result from packing this relation over the specified interval-typed attributes
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - If an invalid list of PACK attributes was provided
  - project
```
IRelation project(NameIdentifier... attributes)
           throws EvaluationException,
                  ValidationException
```
    Computes the projection of this relation over the attributes provided. For more details about projection, see PROJECT.
    
    Parameters:
    
    attributes - the attributes to be retained in a projection of this relation
    
    Returns:
    
    the result of projecting this relation on the attributes mentioned in attributes
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - If an invalid list of projection attribute names was provided
  - rename
```
IRelation rename(java.util.Map<NameIdentifier,NameIdentifier> renames)
          throws EvaluationException
```
    Computes the rename of this relation according to the provided rename specs. For more details about rename, see RENAME.
    
    Parameters:
    
    renames - the specification of the renames to be applied to this relation. Each entry consists of the attribute name for an attribute in this relation, and the attribute name for the corresponding attribute in the resulting relation.
    
    Returns:
    
    the result of applying the given renames to this relation
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - restrict
```
IRelation restrict(java.lang.String restrictExpression)
            throws EvaluationException
```
    Computes the restriction of this relation to the set of tuples that satisfy the given boolean expression. For more details about restrict, see RESTRICT.
    
    Parameters:
    
    restrictExpression - the expression text of a boolean expression to be applied to this relation
    
    Returns:
    
    the result of applying the given restrictExpression to this relation
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - semijoin
```
IRelation semijoin(IRelation semiJoinWith)
            throws EvaluationException,
                   ValidationException
```
    Computes the semijoin between this relation and the given one. For more details about semijoin, see SEMIJOIN.
    
    Parameters:
    
    semiJoinWith - the relation to which this relation is to be semijoined
    
    Returns:
    
    the result of applying the semijoin between this relation and the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - if the given semiJoinWith argument is not join-compatible with this relation
  - semiJoinFor
```
IRelation semiJoinFor(IRelation semiJoinLeftArg)
               throws EvaluationException,
                      ValidationException
```
    Computes the semijoin between the given relation and this one. For more details about semiJoin, see SEMIJOIN
    
    Parameters:
    
    semiJoinLeftArg - the relation that is to be semijoined to this one
    
    Returns:
    
    the result from computing the semijoin of the given relation and this one
    
    Throws:
    
    ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - semijoinUsing
```
IRelation semijoinUsing(IRelation semiJoinWith,
                        java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                 throws EvaluationException,
                        ValidationException
```
    Computes the semijoin between this relation and the given one. For more details about semijoin, see SEMIJOIN.
    
    Parameters:
    
    semiJoinWith - the relation to which this relation is to be semijoined
    
    usingAttributes - the interval-typed attributes that are to be treated in 'USING' mode by the semijoin. Must be a subset of the interval-typed attributes that are common between the heading of this relation and that of the semiJoinWith relation.
    
    Returns:
    
    the result of applying the semijoin between this relation and the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - if the given semiJoinWith argument is not join-compatible with this relation
  - semijoinUsingFor
```
IRelation semijoinUsingFor(IRelation semiJoinLeftArg,
                           java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                    throws EvaluationException,
                           ValidationException
```
    Computes the semijoin between the given relation and this one, with the attributes mentioned in usingAttributes treated in 'USING' mode. For more details about semiJoin, see SEMIJOIN
    
    Parameters:
    
    semiJoinLeftArg - the relation that is to be semijoined to this one
    
    usingAttributes - the interval-typed attributes over which this relation is to be unpacked
    
    Returns:
    
    the result from computing the semijoin of the given relation and this one
    
    Throws:
    
    ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - semiminus
```
IRelation semiminus(IRelation semiDiffWith)
             throws EvaluationException,
                    ValidationException
```
    Computes the semidifference between this relation and the given one. For more details about semidifference, see SEMIMINUS.
    
    Parameters:
    
    semiDiffWith - the relation to which this relation is to be semidiffed
    
    Returns:
    
    the result of applying the semidifference between this relation and the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - If the given semiDiffWith relation is not join-compatible with this one
  - semiminusFor
```
IRelation semiminusFor(IRelation semiMinusLeftArg)
                throws EvaluationException,
                       ValidationException
```
    Computes the semiminus between the given relation and this one. For more details about semiminus, see SEMIMINUS
    
    Parameters:
    
    semiMinusLeftArg - the relation that is to be semijoined to this one
    
    Returns:
    
    the result from computing the semijoin of the given relation and this one
    
    Throws:
    
    ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - semiminusUsing
```
IRelation semiminusUsing(IRelation semiDiffWith,
                         java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                  throws EvaluationException,
                         ValidationException
```
    Computes the semidifference between this relation and the given one. For more details about semidifference, see SEMIMINUS.
    
    Parameters:
    
    semiDiffWith - the relation to which this relation is to be semidiffed
    
    usingAttributes - the interval-typed attributes that are to be treated in 'USING' mode by the semidifference. Must be a subset of the interval-typed attributes that are common between the heading of this relation and that of the semiDiffWith relation.
    
    Returns:
    
    the result of applying the semidifference between this relation and the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - If the given semiDiffWith relation is not join-compatible with this one
  - semiminusUsingFor
```
IRelation semiminusUsingFor(IRelation semiMinusLeftArg,
                            java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                     throws EvaluationException,
                            ValidationException
```
    Computes the semiminus between the given relation and this one, with the attributes mentioned in usingAttributes treated in 'USING' mode. For more details about semiminus, see SEMIMINUS
    
    Parameters:
    
    semiMinusLeftArg - the relation that is to be semijoined to this one
    
    usingAttributes - the interval-typed attributes over which this relation is to be unpacked
    
    Returns:
    
    the result from computing the semijoin of the given relation and this one
    
    Throws:
    
    ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - summarizeby
```
IRelation summarizeby(java.util.Set<NameIdentifier> byAttributes,
                      java.util.Map<NameIdentifier,java.lang.String> expressions)
               throws EvaluationException
```
    Computes the summaries specified by expressions groups of tuples in this relation, with the grouping as specified in byAttributes. For more details about summarizeby, see SUMMARIZEBY.
    
    Parameters:
    
    byAttributes - The set of attributes per which summaries are to be included in the result.
    
    expressions - The map of summary attributes to be computed and the expressions for computing their values in the result
    
    Returns:
    
    the summary of this relation, using the grouping specifications provided in byAttributes and the computation expressions provided in expressions
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - tclose
```
IRelation tclose(java.util.Map<NameIdentifier,NameIdentifier> matchby)
          throws EvaluationException
```
    Computes the transitive closure of the given relation using the attribute matching as specified by matchby. For more details about transitive closure, see TCLOSE.
    
    Parameters:
    
    matchby - the specification of how attributes are matched in the closure to determine additional tuples in the result
    
    Returns:
    
    the transitive closure of this relation, using the attribute matching specifications provided in matchby
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - transform
```
IRelation transform(java.util.Map<NameIdentifier,java.lang.String> transformSpecs)
             throws EvaluationException
```
    Computes the specified transformation of this relation. For more details about transform, see TRANSFORM.
    
    Parameters:
    
    transformSpecs - The specification of how to transform the input relation.
    
    Returns:
    
    the result of transforming this relation according to the provided transformation specs
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - ungroup
```
IRelation ungroup(NameIdentifier... ungroupAttributes)
           throws EvaluationException,
                  ValidationException
```
    Computes the ungrouping of this relation using the specified ungroup attributes. For more details about transform, see UNGROUP.
    
    Parameters:
    
    ungroupAttributes - the relation-typed attributes of this relation that are to be ungrouped in the result
    
    Returns:
    
    the result of the ungrouping of this relation over the specified ungroupAttributes
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - if an invalid list of ungroupAttributes was provided
  - union
```
IRelation union(IRelation unionWith)
         throws EvaluationException
```
    Computes the union of this relation with another one, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about union, see UNION
    
    Parameters:
    
    unionWith - the relation to be unioned with this one
    
    Returns:
    
    the result from computing the union of this relation and the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - unionUsing
```
IRelation unionUsing(IRelation unionWith,
                     java.util.LinkedHashSet<NameIdentifier> usingAttributes)
              throws EvaluationException
```
    Computes the union of this relation with another one, with explicitly specified attributes (and only those) to be treated in 'USING' mode. For more details about union, see UNION
    
    Parameters:
    
    unionWith - the relation to be unioned with this one
    
    usingAttributes - the in-order list of interval-typed attributes to be treated in 'USING' mode for the union and the packing of the result
    
    Returns:
    
    the result of intersecting this relation with the given one, with the attributes specified in usingAttributes (and only those) treated in 'using' mode
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - unpack
```
IRelation unpack(NameIdentifier... unpackAttributes)
          throws EvaluationException,
                 ValidationException
```
    Computes an unpack of this relation. For more details about unpack, see UNPACK
    
    Parameters:
    
    unpackAttributes - the interval-typed attributes over which this relation is to be unpacked
    
    Returns:
    
    the result from unpacking this relation over the specified interval-typed attributes
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
    
    ValidationException - If an invalid list of unpackAttributes was provided
  - xminus
```
IRelation xminus(IRelation symdiffWith)
          throws EvaluationException
```
    Computes the symmetric difference between this relation and the given one. For more details about symmetric difference, see XMINUS
    
    Parameters:
    
    symdiffWith - the relation to be symdiffed with this one
    
    Returns:
    
    the result from computing the symmetric difference of this relation and the given one
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception
  - xminusUsing
```
IRelation xminusUsing(IRelation symdiffWith,
                      java.util.LinkedHashSet<NameIdentifier> usingAttributes)
               throws EvaluationException
```
    Computes the symmetric difference between this relation and the given one, with the attributes mentioned in usingAttributes treated in 'USING' mode. For more details about symmetric difference, see XMINUS
    
    Parameters:
    
    symdiffWith - the relation to be symdiffed with this one
    
    usingAttributes - the interval-typed attributes over which this relation is to be unpacked
    
    Returns:
    
    the result from computing the symmetric difference of this relation and the given one, with the attribute named in usingAttributes treated in 'USING' mode
    
    Throws:
    
    EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

Interface IRelation

Method Summary

Method Detail

aggregate

contains

contains

containsUsing

containsUsing

dividedyper

extend

getHostExpressionEvaluationText

getRelationBuffer

group

gtclose

intersect

intersectUsing

isProxy

join

joinUsing

leftJoin

leftJoinUsing

minus

minusFrom

minusUsing

minusUsingFrom

pack

project

rename

restrict

semijoin

semiJoinFor

semijoinUsing

semijoinUsingFor

semiminus

semiminusFor

semiminusUsing

semiminusUsingFor

summarizeby

tclose

transform

ungroup

union

unionUsing

unpack

xminus

xminusUsing