be.SIRAPRISE.client

Class RelationProxy

java.lang.Object

be.SIRAPRISE.client.RelationProxy

All Implemented Interfaces:

IRelation

Direct Known Subclasses:

AggregateProxy, DivideByPerProxy, ExtendProxy, GroupProxy, GTCloseProxy, IntersectProxy, IntersectUsingProxy, JoinProxy, JoinUsingProxy, MinusProxy, MinusUsingProxy, PackProxy, ProjectProxy, RelvarProxy, RenameProxy, RestrictProxy, SemiJoinProxy, SemiJoinUsingProxy, SemiMinusProxy, SemiMinusUsingProxy, SummarizebyProxy, TCloseProxy, TransformProxy, UngroupProxy, UnionProxy, UnionUsingProxy, UnpackProxy

public abstract class RelationProxy
extends java.lang.Object
implements IRelation

Author:

erwin

Constructor Summary

Constructors

Constructor and Description
RelationProxy(SiraPriseServer host)

Method Summary

Modifier and Type	Method and Description
AggregateProxy	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.
RelationProxy	dividedyper(IRelation divisor, IRelation per) Computes the division of this relation by the given divisor, per the given 'per' relation.
ExtendProxy	extend(java.util.Map<NameIdentifier,java.lang.String> extendExpressions) Computes the extend of this relation, according to the specs provided in extendExpressions.
SiraPriseServer	getHost() Gets the host
abstract 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.
GroupProxy	group(java.util.Map<NameIdentifier,java.util.Set<NameIdentifier>> groupAttributes) Computes the grouping of this relation, according to the specs provided in groupAttributes.
GTCloseProxy	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.
IntersectProxy	intersect(IRelation intersectWith) Computes the intersection of this relation with the given one.
RelationProxy	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.
JoinProxy	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.
JoinUsingProxy	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.
UnionProxy	leftJoin(IRelation leftjoinwith, java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions) Computes the leftjoin of this relation with the given one.
RelationProxy	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.
MinusProxy	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.
MinusProxy	minusFrom(IRelation minuend) Computes the difference between the given relation and this one.
MinusUsingProxy	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.
MinusUsingProxy	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.
PackProxy	pack(NameIdentifier... packAttributes) Computes an pack of this relation.
ProjectProxy	project(NameIdentifier... attributes) Computes the projection of this relation over the attributes provided.
RenameProxy	rename(java.util.Map<NameIdentifier,NameIdentifier> renames) Computes the rename of this relation according to the provided rename specs.
RestrictProxy	restrict(java.lang.String restrictExpression) Computes the restriction of this relation to the set of tuples that satisfy the given boolean expression.
SemiJoinProxy	semijoin(IRelation semiJoinWith) Computes the semijoin between this relation and the given one.
SemiJoinProxy	semiJoinFor(IRelation semiJoinLeftArg) Computes the semijoin between the given relation and this one.
SemiJoinUsingProxy	semijoinUsing(IRelation semiJoinWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes) Computes the semijoin between this relation and the given one.
SemiJoinUsingProxy	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.
SemiMinusProxy	semiminus(IRelation semiDiffWith) Computes the semidifference between this relation and the given one.
SemiMinusProxy	semiminusFor(IRelation semiMinusLeftArg) Computes the semiminus between the given relation and this one.
SemiMinusUsingProxy	semiminusUsing(IRelation semiDiffWith, java.util.LinkedHashSet<NameIdentifier> usingAttributes) Computes the semidifference between this relation and the given one.
SemiMinusUsingProxy	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.
SummarizebyProxy	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.
TCloseProxy	tclose(java.util.Map<NameIdentifier,NameIdentifier> matchby) Computes the transitive closure of the given relation using the attribute matching as specified by matchby.
TransformProxy	transform(java.util.Map<NameIdentifier,java.lang.String> transformSpecs) Computes the specified transformation of this relation.
UngroupProxy	ungroup(NameIdentifier... ungroupAttributes) Computes the ungrouping of this relation using the specified ungroup attributes.
UnionProxy	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.
RelationProxy	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.
UnpackProxy	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.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RelationProxy

public RelationProxy(SiraPriseServer host)

Parameters:

host - the host to which this expression is targeted for evaluation

Method Detail

aggregate

public AggregateProxy aggregate(java.util.Map<NameIdentifier,java.lang.String> expressions)

Description copied from interface: IRelation

Computes the aggregation of this relation, per the given aggregation specs. For more details about relational aggregation, see AGGREGATE.

Specified by:

aggregate in interface IRelation

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

public RelationProxy dividedyper(IRelation divisor,
                                 IRelation per)

Description copied from interface: IRelation

Computes the division of this relation by the given divisor, per the given 'per' relation. For more details about relational division, see DIVIDEBYPER.

Specified by:

dividedyper in interface IRelation

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

extend

public ExtendProxy extend(java.util.Map<NameIdentifier,java.lang.String> extendExpressions)

Description copied from interface: IRelation

Computes the extend of this relation, according to the specs provided in extendExpressions. For more details about grouping, see EXTEND.

Specified by:

extend in interface IRelation

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

getHost

public final SiraPriseServer getHost()

Gets the host

Returns:

the host

getHostExpressionEvaluationText

public abstract java.lang.String getHostExpressionEvaluationText()

Description copied from interface: IRelation

Gets The expression text for the expression to be evaluated by the host

Specified by:

getHostExpressionEvaluationText in interface IRelation

Returns:

The expression text for the expression to be sent to the host for evaluation

getRelationBuffer

public RelationBuffer getRelationBuffer()
                                 throws EvaluationException

Description copied from interface: IRelation

Gets the RelationBuffer holding the tuples collection.

Specified by:

getRelationBuffer in interface IRelation

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

public final GroupProxy group(java.util.Map<NameIdentifier,java.util.Set<NameIdentifier>> groupAttributes)

Description copied from interface: IRelation

Computes the grouping of this relation, according to the specs provided in groupAttributes. For more details about grouping, see GROUP.

Specified by:

group in interface IRelation

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

gtclose

public final GTCloseProxy gtclose(java.util.Map<NameIdentifier,NameIdentifier> matchby,
                                  java.util.Map<NameIdentifier,java.lang.String> expressions)

Description copied from interface: IRelation

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.

Specified by:

gtclose in interface IRelation

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

public final IntersectProxy intersect(IRelation intersectWith)

Description copied from interface: IRelation

Computes the intersection of this relation with the given one. For more details about relational intersection, see INTERSECT.

Specified by:

intersect in interface IRelation

Parameters:

intersectWith - the relation to intersect with this one

Returns:

the result of intersecting this relation with the given one

intersectUsing

public final RelationProxy intersectUsing(IRelation intersectWith,
                                          java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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.

Specified by:

intersectUsing in interface IRelation

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

isProxy

public final boolean isProxy()

Description copied from interface: IRelation

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 IRelation.getRelationBuffer() method.

Specified by:

isProxy in interface IRelation

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

public final JoinProxy join(IRelation joinWith)

Description copied from interface: IRelation

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.

Specified by:

join in interface IRelation

Parameters:

joinWith - the relation to join with this one

Returns:

the result of joining this relation with the given one

joinUsing

public final JoinUsingProxy joinUsing(IRelation joinWith,
                                      java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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.

Specified by:

joinUsing in interface IRelation

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

leftJoin

public final UnionProxy leftJoin(IRelation leftjoinwith,
                                 java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions)

Description copied from interface: IRelation

Computes the leftjoin of this relation with the given one. For more details about relational leftjoin, see LEFTJOIN.

Specified by:

leftJoin in interface IRelation

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

leftJoinUsing

public final RelationProxy leftJoinUsing(IRelation leftjoinwith,
                                         java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions,
                                         java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

Computes the leftjoin of this relation with the given one. For more details about relational leftjoin, see LEFTJOIN.

Specified by:

leftJoinUsing in interface IRelation

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

minus

public final MinusProxy minus(IRelation subtrahend)

Description copied from interface: IRelation

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.

Specified by:

minus in interface IRelation

Parameters:

subtrahend - the relation to subtract from this one

Returns:

the result of subtracting the subtrahend from this relation

minusFrom

public final MinusProxy minusFrom(IRelation minuend)

Description copied from interface: IRelation

Computes the difference between the given relation and this one. For more details about relational difference, see MINUS

Specified by:

minusFrom in interface IRelation

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

minusUsing

public final MinusUsingProxy minusUsing(IRelation subtrahend,
                                        java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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.

Specified by:

minusUsing in interface IRelation

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

minusUsingFrom

public final MinusUsingProxy minusUsingFrom(IRelation minuend,
                                            java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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

Specified by:

minusUsingFrom in interface IRelation

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

pack

public final PackProxy pack(NameIdentifier... packAttributes)
                     throws ValidationException

Description copied from interface: IRelation

Computes an pack of this relation. For more details about pack, see PACK.

Specified by:

pack in interface IRelation

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:

ValidationException - If an invalid list of PACK attributes was provided

project

public final ProjectProxy project(NameIdentifier... attributes)
                           throws ValidationException

Description copied from interface: IRelation

Computes the projection of this relation over the attributes provided. For more details about projection, see PROJECT.

Specified by:

project in interface IRelation

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:

ValidationException - If an invalid list of projection attribute names was provided

rename

public final RenameProxy rename(java.util.Map<NameIdentifier,NameIdentifier> renames)

Description copied from interface: IRelation

Computes the rename of this relation according to the provided rename specs. For more details about rename, see RENAME.

Specified by:

rename in interface IRelation

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

restrict

public final RestrictProxy restrict(java.lang.String restrictExpression)

Description copied from interface: IRelation

Computes the restriction of this relation to the set of tuples that satisfy the given boolean expression. For more details about restrict, see RESTRICT.

Specified by:

restrict in interface IRelation

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

semijoin

public final SemiJoinProxy semijoin(IRelation semiJoinWith)

Description copied from interface: IRelation

Computes the semijoin between this relation and the given one. For more details about semijoin, see SEMIJOIN.

Specified by:

semijoin in interface IRelation

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

semiJoinFor

public final SemiJoinProxy semiJoinFor(IRelation semiJoinLeftArg)

Description copied from interface: IRelation

Computes the semijoin between the given relation and this one. For more details about semiJoin, see SEMIJOIN

Specified by:

semiJoinFor in interface IRelation

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

semijoinUsing

public final SemiJoinUsingProxy semijoinUsing(IRelation semiJoinWith,
                                              java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

Computes the semijoin between this relation and the given one. For more details about semijoin, see SEMIJOIN.

Specified by:

semijoinUsing in interface IRelation

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

semijoinUsingFor

public SemiJoinUsingProxy semijoinUsingFor(IRelation semiJoinLeftArg,
                                           java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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

Specified by:

semijoinUsingFor in interface IRelation

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

semiminus

public final SemiMinusProxy semiminus(IRelation semiDiffWith)

Description copied from interface: IRelation

Computes the semidifference between this relation and the given one. For more details about semidifference, see SEMIMINUS.

Specified by:

semiminus in interface IRelation

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

semiminusFor

public final SemiMinusProxy semiminusFor(IRelation semiMinusLeftArg)

Description copied from interface: IRelation

Computes the semiminus between the given relation and this one. For more details about semiminus, see SEMIMINUS

Specified by:

semiminusFor in interface IRelation

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

semiminusUsing

public final SemiMinusUsingProxy semiminusUsing(IRelation semiDiffWith,
                                                java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

Computes the semidifference between this relation and the given one. For more details about semidifference, see SEMIMINUS.

Specified by:

semiminusUsing in interface IRelation

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

semiminusUsingFor

public final SemiMinusUsingProxy semiminusUsingFor(IRelation semiMinusLeftArg,
                                                   java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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

Specified by:

semiminusUsingFor in interface IRelation

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

summarizeby

public final SummarizebyProxy summarizeby(java.util.Set<NameIdentifier> byAttributes,
                                          java.util.Map<NameIdentifier,java.lang.String> expressions)

Description copied from interface: IRelation

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.

Specified by:

summarizeby in interface IRelation

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

tclose

public final TCloseProxy tclose(java.util.Map<NameIdentifier,NameIdentifier> matchby)

Description copied from interface: IRelation

Computes the transitive closure of the given relation using the attribute matching as specified by matchby. For more details about transitive closure, see TCLOSE.

Specified by:

tclose in interface IRelation

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

transform

public final TransformProxy transform(java.util.Map<NameIdentifier,java.lang.String> transformSpecs)

Description copied from interface: IRelation

Computes the specified transformation of this relation. For more details about transform, see TRANSFORM.

Specified by:

transform in interface IRelation

Parameters:

transformSpecs - The specification of how to transform the input relation.

Returns:

the result of transforming this relation according to the provided transformation specs

ungroup

public final UngroupProxy ungroup(NameIdentifier... ungroupAttributes)
                           throws ValidationException

Description copied from interface: IRelation

Computes the ungrouping of this relation using the specified ungroup attributes. For more details about transform, see UNGROUP.

Specified by:

ungroup in interface IRelation

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:

ValidationException - if an invalid list of ungroupAttributes was provided

union

public final UnionProxy union(IRelation unionWith)

Description copied from interface: IRelation

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

Specified by:

union in interface IRelation

Parameters:

unionWith - the relation to be unioned with this one

Returns:

the result from computing the union of this relation and the given one

unionUsing

public final RelationProxy unionUsing(IRelation unionWith,
                                      java.util.LinkedHashSet<NameIdentifier> usingAttributes)

Description copied from interface: IRelation

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

Specified by:

unionUsing in interface IRelation

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

unpack

public final UnpackProxy unpack(NameIdentifier... unpackAttributes)
                         throws ValidationException

Description copied from interface: IRelation

Computes an unpack of this relation. For more details about unpack, see UNPACK

Specified by:

unpack in interface IRelation

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:

ValidationException - If an invalid list of unpackAttributes was provided

xminus

public final IRelation xminus(IRelation symdiffWith)
                       throws EvaluationException

Description copied from interface: IRelation

Computes the symmetric difference between this relation and the given one. For more details about symmetric difference, see XMINUS

Specified by:

xminus in interface IRelation

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

public final IRelation xminusUsing(IRelation symdiffWith,
                                   java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                            throws EvaluationException

Description copied from interface: IRelation

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

Specified by:

xminusUsing in interface IRelation

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

contains

public final boolean contains(IRelation r)
                       throws EvaluationException

Description copied from interface: IRelation

Checks whether this relation contains all tuples of the given relation.

Specified by:

contains in interface IRelation

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

public final boolean contains(Tuple t)
                       throws EvaluationException

Description copied from interface: IRelation

Checks whether this relation contains the given tuple.

Specified by:

contains in interface IRelation

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

public final boolean containsUsing(IRelation r,
                                   java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                            throws EvaluationException

Description copied from interface: IRelation

Checks whether this relation contains all tuples of the given relation, with the given usingAttributes treated in 'USING' mode.

Specified by:

containsUsing in interface IRelation

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

public final boolean containsUsing(Tuple t,
                                   java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                            throws EvaluationException

Description copied from interface: IRelation

Checks whether this relation contains the given tuple, with the given usingAttributes treated in 'USING' mode.

Specified by:

containsUsing in interface IRelation

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