be.SIRAPRISE.ra

Interface 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

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 aggregatin specs.
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	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	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	semijoinUsing(IRelation semiJoinWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes) Computes the semijoin between this relation and the given one.
IRelation	semiminus(IRelation semiDiffWith) Computes the semidifference between this relation and the given one.
IRelation	semiminusUsing(IRelation semiDiffWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes) Computes the semidifference between this relation and the given one.
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 aggregatin 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

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

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

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

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

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

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

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