be.SIRAPRISE.typeimplementations

Class Relation

java.lang.Object

be.SIRAPRISE.client.TupleContainer

be.SIRAPRISE.typeimplementations.Relation

All Implemented Interfaces:

IRelation, java.lang.Iterable<Tuple>

public class Relation
extends TupleContainer
implements IRelation

Author:

erwin

Constructor Summary

Constructors

Constructor and Description
Relation(Heading heading, RelationBuffer relationBuffer) Creates the AbstractRelation

Method Summary

Modifier and Type	Method and Description
Relation	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 if this container 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.
boolean	equals(java.lang.Object obj)
Relation	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.
Relation	group(java.util.Map<NameIdentifier,java.util.Set<NameIdentifier>> groupAttributes) Computes the grouping of this relation, according to the specs provided in groupAttributes.
Relation	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.
int	hashCode()
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	isProperSubSetOf(Relation relation) Checks if this container contains all of the tuples in the given one
boolean	isProperSuperSetOf(Relation relation) Checks if this container contains all of the tuples in the given one
boolean	isProxy() Checks whether this object is a proxy for a relation.
boolean	isSubSetOf(Relation relation) Checks if this container is a subset of the given one
boolean	isSuperSetOf(Relation relation) Checks if this container contains all of the tuples in the given one
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.
Relation	project(NameIdentifier... attributes) Computes the projection of this relation over the attributes provided.
Relation	rename(java.util.Map<NameIdentifier,NameIdentifier> renames) Computes the rename of this relation according to the provided rename specs.
Relation	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.
Relation	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.
Relation	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.
Relation	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.

Methods inherited from class be.SIRAPRISE.client.TupleContainer

getHeading, getTupleCollectionBuffer, iterator, printBodyEscapedWithBodyHeaderWithTypeNames, printBodyEscapedWithoutBodyHeaderWithoutTypeNames, printBodyEscapedWithoutBodyHeaderWithTypeNames, printBodyWithoutBodyHeaderWithoutTypeNames, printBodyWithoutBodyHeaderWithTypeNames, printBodyXMLWithBodyHeader, printBodyXMLWithoutBodyHeader, printValueEscapedWithoutTypeNames, printValueEscapedWithTypeNames, printValueWithoutTypeNames, printValueWithTypeNames, printValueXML, size, toString

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable

forEach, spliterator

Constructor Detail

Relation

public Relation(Heading heading,
                RelationBuffer relationBuffer)

Creates the AbstractRelation

Parameters:

heading - -

relationBuffer - -

Method Detail

aggregate

public Relation 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

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)

Checks if this container contains the given tuple

Specified by:

contains in interface IRelation

Parameters:

t - the tuple to be checked for membership in this relation

Returns:

true if this container contains the given tuple

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

dividedyper

public IRelation dividedyper(IRelation divisor,
                             IRelation per)
                      throws ValidationException,
                             EvaluationException

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

Throws:

ValidationException - If the given combination of relations do not constitute a valid relational division operation

EvaluationException - If immediate evaluation was attempted and that evaluation failed for any reason

equals

public final boolean equals(java.lang.Object obj)

Overrides:

equals in class java.lang.Object

extend

public Relation 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

getHostExpressionEvaluationText

public 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 evaluated by the host

getRelationBuffer

public RelationBuffer getRelationBuffer()

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

group

public Relation group(java.util.Map<NameIdentifier,java.util.Set<NameIdentifier>> groupAttributes)
               throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

gtclose

public Relation 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

hashCode

public final int hashCode()

Overrides:

hashCode in class java.lang.Object

intersect

public IRelation intersect(IRelation intersectWith)
                    throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

intersectUsing

public IRelation intersectUsing(IRelation intersectWith,
                                java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                         throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

isProperSubSetOf

public final boolean isProperSubSetOf(Relation relation)

Checks if this container contains all of the tuples in the given one

Parameters:

relation - the tuplecontainer to compare this one with

Returns:

true if this container contains all of the tuples in the given one, false otherwise

isProperSuperSetOf

public final boolean isProperSuperSetOf(Relation relation)

Checks if this container contains all of the tuples in the given one

Parameters:

relation - the tuplecontainer to compare this one with

Returns:

true if this container contains all of the tuples in the given one, false otherwise

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

isSubSetOf

public final boolean isSubSetOf(Relation relation)

Checks if this container is a subset of the given one

Parameters:

relation - the tuplecontainer to compare this one with

Returns:

true if this container is a subset of the given one, false otherwise

isSuperSetOf

public final boolean isSuperSetOf(Relation relation)

Checks if this container contains all of the tuples in the given one

Parameters:

relation - the tuplecontainer to compare this one with

Returns:

true if this container contains all of the tuples in the given one, false otherwise

join

public IRelation join(IRelation joinWith)
               throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

joinUsing

public IRelation joinUsing(IRelation joinWith,
                           java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                    throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

leftJoin

public IRelation leftJoin(IRelation leftjoinwith,
                          java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions)
                   throws EvaluationException,
                          ValidationException

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

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

public IRelation leftJoinUsing(IRelation leftjoinwith,
                               java.util.Map<NameIdentifier,java.lang.String> missingAttributeValueExpressions,
                               java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                        throws EvaluationException,
                               ValidationException

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

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

public IRelation minus(IRelation subtrahend)
                throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

minusFrom

public IRelation minusFrom(IRelation minuend)
                    throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

minusUsing

public IRelation minusUsing(IRelation subtrahend,
                            java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                     throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

minusUsingFrom

public IRelation minusUsingFrom(IRelation minuend,
                                java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                         throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

pack

public IRelation pack(NameIdentifier... packAttributes)
               throws EvaluationException

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:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

project

public Relation project(NameIdentifier... attributes)
                 throws EvaluationException

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:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

rename

public Relation rename(java.util.Map<NameIdentifier,NameIdentifier> renames)
                throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

restrict

public Relation 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 IRelation semijoin(IRelation semiJoinWith)
                   throws EvaluationException,
                          ValidationException

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

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

public IRelation semiJoinFor(IRelation semiJoinLeftArg)
                      throws EvaluationException,
                             ValidationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one

semijoinUsing

public IRelation semijoinUsing(IRelation semiJoinWith,
                               java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                        throws EvaluationException,
                               ValidationException

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

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

public IRelation semijoinUsingFor(IRelation semiJoinLeftArg,
                                  java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                           throws EvaluationException,
                                  ValidationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one

semiminus

public IRelation semiminus(IRelation semiDiffWith)
                    throws EvaluationException,
                           ValidationException

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

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

public IRelation semiminusFor(IRelation semiMinusLeftArg)
                       throws EvaluationException,
                              ValidationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one

semiminusUsing

public IRelation semiminusUsing(IRelation semiDiffWith,
                                java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                         throws EvaluationException,
                                ValidationException

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

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

public IRelation semiminusUsingFor(IRelation semiMinusLeftArg,
                                   java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                            throws EvaluationException,
                                   ValidationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

ValidationException - If the given semiJoinLeftArg relation is not join-compatible with this one

summarizeby

public Relation 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 Relation tclose(java.util.Map<NameIdentifier,NameIdentifier> matchby)
                throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

transform

public IRelation 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 Relation ungroup(NameIdentifier... ungroupAttributes)
                 throws EvaluationException

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:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

union

public IRelation union(IRelation unionWith)
                throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

unionUsing

public IRelation unionUsing(IRelation unionWith,
                            java.util.LinkedHashSet<NameIdentifier> usingAttributes)
                     throws EvaluationException

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

Throws:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

unpack

public IRelation unpack(NameIdentifier... unpackAttributes)
                 throws EvaluationException

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:

EvaluationException - If immediate evaluation was performed and that evaluation raised an exception

xminus

public 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 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