be.SIRAPRISE.typeimplementations

Interface OPERATORNAMES

public interface OPERATORNAMES

The OPERATORNAMES interface defines the names of all system-defined relational operators used in SIRA_PRISE, and the names of the system-defined interval operators used in SIRA_PRISE. The names of the system-provided scalar operators will have to be incorporated here too, but that is a work in progress. Until that work is finished, the following appendix to the former "managing the database" website page is included here and will have to make do.

The formally correct list of system-provided operators is in the "known implementing classes" overview of the OperatorImplementation_V0105 interface.

Some of the relational operators defined and documented here are subject to SIRA_PRISE's "using quirk". This quirk is explained here, the impacted operators are documented with a reference to this paragraph. The quirk is that if the arguments of a relational operator involve interval-typed attributes, then that operator will expose not exactly the behaviour as documented/specified in these documents, but rather the behaviour of a corresponding "USING" version of that operator. The reason this quirk exists is the combination of all of the following :

• Earlier versions of SIRA_PRISE did support interval types, but did not expose any explicitly separate "USING versions" of the relational operators.
• But the most desirable behaviour of these operators when interval-typed attributes were involved, is the one of its "USING version".
• So the specced behaviour of these relational operators was simply :
  • If no interval-typed attributes involved, behaviour as usual and as still specced here and now. E.g. JOIN(R1,R2) would be indeed just that.
  • If interval-typed attributes involved, behaviour as per some corresponding "USING version" of the operator. E.g. JOIN(R1,R2) would in fact be JOINUSING(R1,R2,intrv_attr_list), where intrv_attr_list named a certain set of inteval-typed attributes of the arguments.
• SIRA_PRISE now does expose explicitly separate USING versions of these operators, but for reasons of backward compatibility, the former behaviour has been kept.

So the quirky situation is as follows (illustrated for the case of INTERSECT) :

• If you write INTERSECT(R1,R2) then you will actually get the behaviour of INTERSECTUSING(R1,R2,(default_intrv_attr_list)), where default_intrv_attr_list is the lexicographically ordered list of all interval-typed attributes in the heading,
• If you want the 'true' INTERSECT(R1,R2) (not readily achievable in previous versions) then you'll have to write INTERSECTUSING(R1,R2,()).

Below is an informal overview of the system-provided scalar operators.

Informal Overview of system-provided scalar operators

Operator name and argument types	Comments
EQ(...,...)	Provided for all types
GT(...,...) LT(...,...) GE(...,...) LE(...,...)	Provided for types INT, LONG, FLOAT, DECIMAL, DATE and TIMEOFDAY.
XOR(boolean,boolean)
AND(boolean,boolean)
OR(boolean,boolean)
NOT(boolean)
ABS(...)	Returns the absolute value of its argument. Provided for the types INT, LONG, FLOAT.
MAX(...,...)	Returns the greater of its two arguments. Provided for the types INT, LONG, FLOAT, DATE and TIMEOFDAY.
MIN(...,...)	Returns the lower of its two arguments. Provided for the types INT, LONG, FLOAT, DATE and TIMEOFDAY.
PLUS(...,...)	Returns the sum of its two arguments. Provided for the types INT, LONG, FLOAT, DECIMAL and TIMEOFDAY.
SUB(...,...)	Returns the difference of its two arguments. Provided for the types INT, LONG, FLOAT and TIMEOFDAY.
MULT(...,...)	Returns the product of its two arguments. Provided for the types INT, LONG, and FLOAT.
DIV(...,...)	Returns the result of the division of the first argument by the second. Provided for the types INT, LONG, and FLOAT.
ROUND(float,float)	Out of the set of whole multiples of the second argument, returns the value that is closest to the first argument.
EXP(float,float)	Returns the result of the first argument raised to the power of the second.
EXP(float)	Returns the result of e raised to the power of the argument.
LN(float)	Returns the natural logarithm of the argument.
SQRT(float)	Returns the square root of the argument.
CEIL(...,...)	Returns the smallest number that is an exact multiple of the second argument and greater than or equal to the first. Provided for types INT and LONG.
FLOOR(...,...)	Returns the largest number that is an exact multiple of the second argument and smaller than or equal to the first. Provided for types INT and LONG.
MOD(...,...)	Returns the number c such that if c = mod(a,b), then a = (a / b) + c. Provided for types INT and LONG.
COS(angle)	Returns the cosine of the argument
COSEC(angle)	Returns the cosecant of the argument
COTAN(angle)	Returns the cotangent of the argument
SEC(angle)	Returns the secant of the argument
SIN(angle)	Returns the sine of the argument
TAN(angle)	Returns the tangent of the argument
ACOS(float)	Returns the arc cosine of the argument
ACOSEC(float)	Returns the arc cosecant of the argument
ACOTAN(float)	Returns the arc cotangent of the argument
ASEC(float)	Returns the arc secant of the argument
ASIN(float)	Returns the arc sine of the argument
ATAN(float)	Returns the arc tangent of the argument
LENGTH(longinterval)
LENGTH(intinterval)
LENGTH(string)	Returns the number of tokens that appear in the string argument.
CONCAT(string, string)	Returns the result of concatenating the two string arguments.
UPPERCASE(string)	Returns the result of converting the string argument to uppercase. Note that this can be dependent on locale of the machine where the server is running.
LOWERCASE(string)	Returns the result of converting the string argument to lowercase. Note that this can be dependent on locale of the machine where the server is running.
SUBSTR(string, start)	Returns the string that consists of the same series of tokens that appear in the string argument starting at the position designated by the integer argument start. The first position is position 1 (i.e. positions are not offsets). If the start value is less than 1, then the entire string argument is returned. If the start value is larger than the given string's actual length, then the empty string is returned.
SUBSTR(string, start, end)	Returns the string that consists of the same series of tokens that appear in the string argument starting at the position designated by the integer argument 'start', and before the position designated by the integer argument 'end' (i.e. the token at position 'end' is not included in the result). The first position is position 1 (i.e. positions are not offsets). If the 'start' value is outside the range [1-actual length of the string], then it is adjusted to fall within that range. After that, if the 'end' argument is outside the range [start-actual length of the string], then it is also adjusted to fall within that range. If, after adjustment, 'end' is equal to 'start', then the empty string is returned.
MATCHES(string, regex)	Returns true if the first argument "matches" the second, false otherwise. The second argument must be a valid Java Regular Expression.
BEGINSWITH(..., ...)	Returns true if the first argument "begins with" the second, false otherwise. Provided for types STRING and NAME.
ENDSWITH(..., ...)	Returns true if the first argument "ends with" the second, false otherwise. Provided for types STRING and NAME.
DATESHIFT(date,years,months,days)	Years, months and days are all integer arguments. Only one is allowed to be nonzero. Returns the date that is obtained by adding that nonzero value to the given date.
FIRST...()	Returns the lowest value of the type whose name follows 'FIRST' in the operator name. Provided for types INT, LONG and DATE.
LAST...()	Returns the lowest value of the type whose name follows 'FIRST' in the operator name. Provided for types INT, LONG and DATE.
NEXT...(...)	Returns the value that is next-higher to the given argument. Provided for types INT, LONG and DATE.
PRIOR...(...)	Returns the value that is next-lower to the given argument. Provided for types INT, LONG and DATE.
The interval family of operators	These operators are discussed in the section on the interval operators

SIRA_PRISE supports the inclusion in a type definition of 'possible representations' (possreps for short). Each type obviously must have at least one such possrep, for otherwise the values of the type simply would not be externally representible. That possrep is the type's "default" possrep.

All possreps can have 'possrep components'. For each component of a possrep, SIRA_PRISE automatically defines a THE_ operator whose argument is a value of the possrep's type, and whose return value is the value for that particular component in that particular possrep's representation of the argument.

E.g. a date value can be represented as a single 10-character string, or it can be represented using three integer values denoting the day, month and year respectively. The latter gives rise to a possrep with three components named DAY, MONTH and YEAR respectively, and to the automatic availability of three operators THE_DAY, THE_MONTH and THE_YEAR respectively (the argument to each of these operators is a value of type DATE, of course). Values of type date can then be selected using either one of DATE(yyyy-mm-dd), DATE(ISO(yyyy-mm-dd)), or DATE(DAY(dd)MONTH(mm)YEAR(yyyy)).

The possreps (and thus, which THE_ operators are available) for the system-provided types are included in the type documentation.

Please observe that the component names of a possrep must be unique across all the possreps of the same type (otherwise there would have to be multiple distinct THE_ operators that share the same name and have the same argument type, making their signature completely equal, and thus rendering the operators indistinguishible from the engine's perspective). So it is therefore not possible to define, say, a possrep MDY for type DATE that also has a component named DAY, MONTH or YEAR.

Also observe that type STRING does not seem to have a possrep. If it had one, it should also have a component, and that component would (in practice) have to be of type STRING as well, breaking the rule that no type can have a component that is of the very same type. The absence of a possrep for type STRING obviously does not prohibit writing value selectors for the type. The absence of a possrep for type STRING only reflects the fact that STRING is the actual root type of the system, as far as "representation of values" is concerned.

Author:

Erwin Smout

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.String	AFTER "AFTER" is the Allen AFTER operator for intervals.
static NameIdentifier	AFTER_I
static java.lang.String	AGGREGATE "AGGREGATE" is the generic aggregation operator as supported by SIRA_PRISE.
static java.lang.String	BEFORE "BEFORE" is the Allen BEFORE operator for intervals.
static NameIdentifier	BEFORE_I
static java.lang.String	BEGINS "BEGINS" is the Allen BEGINS operator for intervals.
static NameIdentifier	BEGINS_I
static java.lang.String	CHOOSE
static NameIdentifier	CHOOSE_I
static java.lang.String	CONTAINS "CONTAINS" is the Allen CONTAINS operator for intervals.
static NameIdentifier	CONTAINS_I
static java.lang.String	CONTAINSPOINT "CONTAINSPOINT" is the CONTAINSPOINT operator for intervals.
static NameIdentifier	CONTAINSPOINT_I
static java.lang.String	CONTAINSR
static NameIdentifier	CONTAINSR_I
static java.lang.String	CONTAINSRUSING
static NameIdentifier	CONTAINSRUSING_I
static java.lang.String	CONTAINST
static NameIdentifier	CONTAINST_I
static java.lang.String	CONTAINSTUSING
static NameIdentifier	CONTAINSTUSING_I
static java.lang.String	DELETES
static java.lang.String	DELETESBAC
static java.lang.String	DELETESSAC
static java.lang.String	DIVIDEBYPER
static java.lang.String	ENDPOINTOF "ENDPOINTOF" is the operator for getting the ENDPOINT of an interval.
static NameIdentifier	ENDPOINTOF_I
static java.lang.String	ENDS "ENDS" is the Allen ENDS operator for intervals.
static NameIdentifier	ENDS_I
static java.lang.String	EQ
static NameIdentifier	EQ_I
static java.lang.String	EXTEND "EXTEND" is the EXTEND operator of the relational algebra defined in TTM.
static java.lang.String	FIRST
static java.lang.String	GAPBETWEEN "GAPBETWEEN" is the GAPBETWEEN operator for intervals.
static NameIdentifier	GAPBETWEEN_I
static java.lang.String	GE
static NameIdentifier	GE_I
static java.lang.String	GROUP "GROUP" is the GROUPing operator as supported by SIRA_PRISE.
static java.lang.String	GT
static NameIdentifier	GT_I
static java.lang.String	GTCLOSE "GTCLOSE" is the generalized transitive closure operator as supported by SIRA_PRISE.
static java.lang.String	IINTERSECT "IINTERSECT" is the INTERSECT operator for intervals.
static NameIdentifier	IINTERSECT_I
static java.lang.String	IMINUS "IMINUS" is the MINUS operator for intervals.
static NameIdentifier	IMINUS_I
static java.lang.String	INSERTS
static java.lang.String	INSERTSBAC
static java.lang.String	INSERTSSAC
static java.lang.String	INTERSECT "INTERSECT" is the intersection operator of the relational algebra.
static java.lang.String	INTERSECTUSING
static java.lang.String	ISEMPTYINTERVAL "ISEMPTYINTERVAL" is the operator for testing emptiness of an interval.
static NameIdentifier	ISEMPTYINTERVAL_I
static java.lang.String	ISINFINITEINTERVAL Deprecated. - replace invocations of this operator with the (negation of) the new ISUPPERBOUNDED() operator
static NameIdentifier	ISINFINITEINTERVAL_I Deprecated. - replace invocations of this operator with the (negation of) the new ISUPPERBOUNDED() operator
static java.lang.String	ISLOWERBOUNDED
static NameIdentifier	ISLOWERBOUNDED_I
static java.lang.String	ISUPPERBOUNDED
static NameIdentifier	ISUPPERBOUNDED_I
static java.lang.String	IUNION "IUNION" is the UNION operator for intervals.
static NameIdentifier	IUNION_I
static java.lang.String	JOIN "JOIN" is the natural-join operator of the relational algebra.
static java.lang.String	JOINUSING
static java.lang.String	LAST
static java.lang.String	LE
static NameIdentifier	LE_I
static java.lang.String	LEFTJOIN "LEFTJOIN" is a "left join" of the relational algebra supported by SIRA_PRISE.
static java.lang.String	LEFTJOINUSING
static java.lang.String	LENGTH
static NameIdentifier	LENGTH_I
static java.lang.String	LT
static NameIdentifier	LT_I
static java.lang.String	MAX
static NameIdentifier	MAX_I
static java.lang.String	MEETS "MEETS" is the operator for the Allen MEETS interval operator.
static NameIdentifier	MEETS_I
static java.lang.String	MERGES "MERGES" is the operator for the Allen MERGESTS interval operator.
static NameIdentifier	MERGES_I
static java.lang.String	MIN
static NameIdentifier	MIN_I
static java.lang.String	MINUS "MINUS" is the difference operator of the relational algebra.
static java.lang.String	MINUSUSING
static java.lang.String	NEXT
static java.lang.String	OVERLAPS "OVERLAPS" is the operator for the Allen OVERLAPS interval operator.
static NameIdentifier	OVERLAPS_I
static java.lang.String	PACK "PACK" is the PACK operator of the relational algebra defined in TDATRM/TaRT and my paper.
static java.lang.String	PRIOR
static java.lang.String	PROJECT "PROJECT" is the projection operator of the relational algebra defined in TTM.
static java.lang.String	RENAME "RENAME" is the RENAME operator of the relational algebra defined in TTM.
static java.lang.String	RESTRICT "RESTRICT" is the restriction operator of the relational algebra defined in TTM.
static java.lang.String	SEMIJOIN "SEMIJOIN" is the MATCHING operator of the relational algebra defined in TTM.
static java.lang.String	SEMIJOINUSING
static java.lang.String	SEMIMINUS "SEMIMINUS" is the NOT MATCHING operator of the relational algebra defined in TTM.
static java.lang.String	SEMIMINUSUSING
static java.lang.String	SPAN "SPAN" is the SPAN interval operator.
static NameIdentifier	SPAN_I
static java.lang.String	SPLITBY "SPLITBY" is the SPLITBY interval operator.
static NameIdentifier	SPLITBY_I
static java.lang.String	SPLITS "SPLITS" is the operator for the SPLITS interval operator.
static NameIdentifier	SPLITS_I
static java.lang.String	STARTPOINTOF "STARTPOINTOF" is the operator for the STARTPOINTOF interval operator.
static NameIdentifier	STARTPOINTOF_I
static java.lang.String	SUMMARIZEBY "SUMMARIZEBY" is the generic summarization operator as supported by SIRA_PRISE.
static java.lang.String	TCLOSE "TCLOSE" is the transitive closure operator as supported by SIRA_PRISE.
static java.lang.String	TRANSACTION Deprecated. deprecated
static java.lang.String	TRANSFORM "TRANSFORM" combines the functionality of the EXTEND, PROJECT and RENAME operators into one.
static java.lang.String	UNGROUP "UNGROUP" is the UNGROUPing operator as supported by SIRA_PRISE.
static java.lang.String	UNION "UNION" is the union operator of the relational algebra.
static java.lang.String	UNIONUSING
static java.lang.String	UNPACK
static java.lang.String	WITHIN "WITHIN" is an interval operator that is equivalent to, in Allen terms, STARTS or DURING or FINISHES or EQUAL.
static NameIdentifier	WITHIN_I
static java.lang.String	XMINUS "XMINUS" is the symmetric difference operator of the relational algebra.
static java.lang.String	XMINUSUSING

Field Detail

AFTER

static final java.lang.String AFTER

"AFTER" is the Allen AFTER operator for intervals. For a detailed definition, see IntervalAfterOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

AFTER_I

static final NameIdentifier AFTER_I

AGGREGATE

static final java.lang.String AGGREGATE

"AGGREGATE" is the generic aggregation operator as supported by SIRA_PRISE. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let AG1(opnm1(expr1)),AG2(opnm2(expr2)),...,AGn(opnmn(exprn)) be an aggregation spec list (note that this list may not be empty). In there :
  • Each of AG1,AG2,...,AGn is a valid attribute name,
  • Each of opnm1,opnm2,...,opnmn is the invocation name of an aggregation operator, that is, an operator that is both commutative and associative. Note that it is not sufficient to be just associative. String concatenation is an example of an operator that is associative, but not commutative. Therefore string concatenation cannot be considered a valid aggregation operator.
  • Each of expr1,expr2,...,exprn is a valid read-only expression (meaning it has a declared type and returns a value of that type) of the type of the aggregation operator. The only allowable variables in this expression are attribute references to the relation that is being aggregated.
• Any of A1,A2,...,Ai may be referenced in any of expr1,expr2,...,exprn, but note that there may be zero such references, i.e. any of the expressions may constant with respect to the tuples in RA.
• The result of AGGREGATE(RA,( AG1(opnm1(expr1)),AG2(opnm2(expr2)),...,AGn(opnmn(exprn)) )) is a relation with attributes AG1,AG2,...,AGn. The types of these attributes are the declared types of the opnm1,opnm2,...,opnmn (and expr1,expr2,...,exprn) operator/expression the attribute corresponds to.
• That result will hold a single tuple tag that will hold the aggregation of RA for the specified expressions :
  • For each tuple tax in RA and for each aggregation expression expry, evaluating that expression yields a value-to-be-aggregated vxy. This gives series of values v11,v21,...vx1 for the expr1 expression, a series of values v12,v22,...vx2 for the expr2 expression, etc etc.
  • The attribute value for AG1 in the result is the value of the expression (v11 opnm1 V21 opnm1 ... opnm1 vx1).
  • The attribute value for AG2 in the result is the value of the expression (v12 opnm2 V22 opnm2 ... opnm2 vx2).
  • etc etc etc ...
  • The attribute value for AGn in the result is the value of the expression (v1n opnmn V2n opnmn ... opnmn vxn).

The following rules for "AGGREGATE" derive from this definition :

• Obviously, there may be no duplicates in the list of attribute names AG1,AG2,...,AGn.

See Also:

Constant Field Values

BEFORE

static final java.lang.String BEFORE

"BEFORE" is the Allen BEFORE operator for intervals. For a detailed definition, see IntervalBeforeOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

BEFORE_I

static final NameIdentifier BEFORE_I

BEGINS

static final java.lang.String BEGINS

"BEGINS" is the Allen BEGINS operator for intervals. For a detailed definition, see IntervalBeginsOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

BEGINS_I

static final NameIdentifier BEGINS_I

CHOOSE

static final java.lang.String CHOOSE

See Also:

Constant Field Values

CHOOSE_I

static final NameIdentifier CHOOSE_I

CONTAINS

static final java.lang.String CONTAINS

"CONTAINS" is the Allen CONTAINS operator for intervals. For a detailed definition, see IntervalContainsOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

CONTAINS_I

static final NameIdentifier CONTAINS_I

CONTAINSPOINT

static final java.lang.String CONTAINSPOINT

"CONTAINSPOINT" is the CONTAINSPOINT operator for intervals. For a detailed definition, see IntervalContainsPointOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

CONTAINSPOINT_I

static final NameIdentifier CONTAINSPOINT_I

CONTAINSR

static final java.lang.String CONTAINSR

See Also:

Constant Field Values

CONTAINSR_I

static final NameIdentifier CONTAINSR_I

CONTAINSRUSING

static final java.lang.String CONTAINSRUSING

See Also:

Constant Field Values

CONTAINSRUSING_I

static final NameIdentifier CONTAINSRUSING_I

CONTAINST

static final java.lang.String CONTAINST

See Also:

Constant Field Values

CONTAINST_I

static final NameIdentifier CONTAINST_I

CONTAINSTUSING

static final java.lang.String CONTAINSTUSING

See Also:

Constant Field Values

CONTAINSTUSING_I

static final NameIdentifier CONTAINSTUSING_I

DELETES

static final java.lang.String DELETES

See Also:

Constant Field Values

DELETESBAC

static final java.lang.String DELETESBAC

See Also:

Constant Field Values

DELETESSAC

static final java.lang.String DELETESSAC

See Also:

Constant Field Values

DIVIDEBYPER

static final java.lang.String DIVIDEBYPER

See Also:

Constant Field Values

ENDPOINTOF

static final java.lang.String ENDPOINTOF

"ENDPOINTOF" is the operator for getting the ENDPOINT of an interval. For a detailed definition, see IntervalEndPointOfOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

ENDPOINTOF_I

static final NameIdentifier ENDPOINTOF_I

ENDS

static final java.lang.String ENDS

"ENDS" is the Allen ENDS operator for intervals. For a detailed definition, see IntervalEndsOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

ENDS_I

static final NameIdentifier ENDS_I

EQ

static final java.lang.String EQ

See Also:

Constant Field Values

EQ_I

static final NameIdentifier EQ_I

EXTEND

static final java.lang.String EXTEND

"EXTEND" is the EXTEND operator of the relational algebra defined in TTM. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let E1(expr1),E2(expr2),...,En(exprn) be an extend list (note that this list may be empty). Each of E1,E2,...,En is a valid attribute name and each of expr1,expr2,...,exprn is a valid read-only expression (meaning it has a declared type and returns a value of that type).
• Any of A1,A2,...,Ai may be referenced in any of expr1,expr2,...,exprn, but note that there may be zero such references, i.e. any of the expressions may constant with respect to the tuples in RA.
• The result of EXTEND(RA,(E1(expr1),E2(expr2),...,En(exprn))) is a relation with attributes A1,A2,...,Ai,E1,E2,...,En. The types of the 'E' attributes are the declared types of the expr1,expr2,...,exprn expression the attribute corresponds to.
• That result will hold a tuple te for each and every tuple ta of RA such that :
  • The values for all of the 'A' attributes in te are copied from ta.
  • The values for all of the 'E' attributes in te are the result of evaluating the corresponding expr1,expr2,...,exprn, with references to attributes of RA that appear in those expressions, evaluating to the concerned attribute value in ta.

See Also:

Constant Field Values

FIRST

static final java.lang.String FIRST

See Also:

Constant Field Values

GAPBETWEEN

static final java.lang.String GAPBETWEEN

"GAPBETWEEN" is the GAPBETWEEN operator for intervals. For a detailed definition, see IntervalGapBetweenOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

GAPBETWEEN_I

static final NameIdentifier GAPBETWEEN_I

GE

static final java.lang.String GE

See Also:

Constant Field Values

GE_I

static final NameIdentifier GE_I

GROUP

static final java.lang.String GROUP

"GROUP" is the GROUPing operator as supported by SIRA_PRISE. The operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let GA be a grouping spec of the form RVA1(G11,G12,...,G1k)RVA2(G21,G22,...,G2l)...RVAj(Gj,Gj2,...,Gjn), in which RVA1,RVA2,...,RVAj are attribute names and all of G11...Gjn are attribute names of RA.
• Let RTA be the set of attributes of RA that are not mentioned in the set G11...Gjn. This set may be empty (in that case, the result of GROUP will be a singleton with only the RVA1,RVA2,...,RVAj values).
• The result of GROUP( RA , (RVA1(G11,G12,...,G1k)RVA2(G21,G22,...,G2l)...RVAj(Gj,Gj2,...,Gjn)) ) is a relation with the all the attributes in RTA, plus the attributes RVA1,RVA2,...,RVAj, such that :
  • For each tuple ta in RA, there will be a corresponding tuple tr in the result that has all the RTA values (if any) equal to the the values from the tuple of RA.
  • This tuple tr will have relation-valued attributes rva1,rva2,...,rvaj. Each of these will include a tuple that is the tuple projection of ta onto the concerned RVA's attribute list ( G11...G1K , G21...G2L, ... ).
  • There will be exactly one tuple in the result for each combination of RTA values that appears in RA. If RTA is empty, it means there shall be only one tuple in the result.

The following rules for "GROUP" derive from this definition :

• All of the 'G' attribute names must name an attribute of RA.
• All of the 'RVA' attribute names must name an attribute that is not in RTA (they may name an attribute that is in RA, but then that attribute name must be one of the 'G' attributes too).

See Also:

Constant Field Values

GT

static final java.lang.String GT

See Also:

Constant Field Values

GT_I

static final NameIdentifier GT_I

GTCLOSE

static final java.lang.String GTCLOSE

"GTCLOSE" is the generalized transitive closure operator as supported by SIRA_PRISE. The same remark applies as with TCLOSE about the degree of the relations it applies to.

The SIRA_PRISE version is defined as follows :

• Let RA be a relation with attributes PA1,PA2,...,PAi,CA1,CA2,...,CAi,D1,D2,...,Dn
• The PA1,PA2,...,PAi attributes are the "parent" attributes, the attributes that constitute the identifier of a "parent" node in the parent-to-child relationship represented by this relation.
• The CA1,CA2,...,CAi attributes are the "child" attributes, the attributes that constitute the identifier of a "child" node in the parent-to-child relationship represented by this relation.
• The D1,D2,...,Dn attributes are the "data" attributes, values that denote properties associated with the parent-child relationship represented in the relation. Note that there can be zero such, in which case GTCLOSE degenerates to TCLOSE
• Note that there must be exactly as many "child" attributes as there are "parent" attributes, and that there must be at least one.
• The result of GTCLOSE(RA,(PA1,CA1,PA2,CA2,...,PAi,CAi),(D1(expr1)D2(expr2)...Dn(exprn))) is a relation with the same attributes as RA - PA1,PA2,...,PAi,CA1,CA2,...,CAi,,D1,D2,...,Dn such that :
  • All the tuples that appear in RA will appear in this result, and
  • If the result contains two tuples t1 and t2 with attribute values (pa11,pa21,...,pan1,ca11,ca21,...,can1,d11,d21,...,dn1) and (pa12,pa22,...,PAn2,ca12,ca22,...,can2,d12,d22,...,dn2), respectively, such that ca11=pa12 AND ca21=pa22 AND ... AND can1=pan2, then the result shall also include a tuple t3 with attribute values the "parent" attribute values from t1, "child" attribute values from t2 (pa11,pa21,...,pan1,ca12,ca22,...,can2) and "data" attributes computed by evaluating the corresponding expressions expr1,expr2,...exprn. Stated informally, if there are two tuples in the result such that the child identified by the first is the same as the parent identified by the latter, then there shall also be a tuple in the result that reflects the "grandparent-grandchild" relationship between the "parent" in the first tuple and the "child" in the second, with data values computed, most likely, from the two tuples that give rise to its inclusion.

The following rules for "GTCLOSE" derive from this definition :

• All of the 'PA' attribute names as well as all of the 'CA' attributes mentioned in the tclose attribute matching list must name an attribute of RA.
• All attributes of RA must be mentioned, either exactly once in the closure attributes matching list (either as a parent attribute or else as a child attribute), or else exactly once as a data attribute.
• For each matching pair PAn,CAn, the types of the two attributes involved must have a common supertype (the equality operator between them must be resolvable).

See Also:

Constant Field Values

IINTERSECT

static final java.lang.String IINTERSECT

"IINTERSECT" is the INTERSECT operator for intervals. For a detailed definition, see IntervalIntersectOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

IINTERSECT_I

static final NameIdentifier IINTERSECT_I

IMINUS

static final java.lang.String IMINUS

"IMINUS" is the MINUS operator for intervals. For a detailed definition, see IntervalMinusOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

IMINUS_I

static final NameIdentifier IMINUS_I

INSERTS

static final java.lang.String INSERTS

See Also:

Constant Field Values

INSERTSBAC

static final java.lang.String INSERTSBAC

See Also:

Constant Field Values

INSERTSSAC

static final java.lang.String INSERTSSAC

See Also:

Constant Field Values

INTERSECT

static final java.lang.String INTERSECT

"INTERSECT" is the intersection operator of the relational algebra. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let RB be a relation with the very same attributes A1,A2,...,Ai
• For each A1,A2,...,Ai, the types of the attributes in both relation must be such that a common supertype for both exists. (In fact, it would even be more useful if the requirements were further tightened, to requiring the existence of a common subtype between the types, but SIRA_PRISE doesn't go that far.)
• The result of "INTERSECT"(RA,RB) is a relation with attributes A1,A2,...,Ai, whose types are the common supertypes found for the types of those attributes in the arguments.
• That result will hold a tuple with attribute values a1,a2,...,ai if and only if :
  • That tuple appears in RA,
  • AND that tuple appears in RB

The following rules for "INTERSECT" derive from this definition :

• Let TA1A,TA2A,...TAiA be the types of A1,A2,...,Ai in RA and TA1B,TA2B,...TAiB be the types of A1,A2,...,Ai in RB. Then for all pairs (TA1A,TA1B),(TA2A,TA2B),...,(TAiA,TAiB) it must hold that a common supertype exists for the two types in the pair.

"INTERSECT" is associative, so n-adic intersections are possible.

Also observe that this operator is a special case of JOIN, namely that special case where there are neither 'a' attributes nor 'b' attributes, i.e. all attributes are common.

Please note that "INTERSECT" exposes the USING quirk

See Also:

Constant Field Values

INTERSECTUSING

static final java.lang.String INTERSECTUSING

See Also:

Constant Field Values

ISEMPTYINTERVAL

static final java.lang.String ISEMPTYINTERVAL

"ISEMPTYINTERVAL" is the operator for testing emptiness of an interval. For a detailed definition, see IntervalIsEmptyOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

ISEMPTYINTERVAL_I

static final NameIdentifier ISEMPTYINTERVAL_I

ISINFINITEINTERVAL

@Deprecated
static final java.lang.String ISINFINITEINTERVAL

Deprecated. - replace invocations of this operator with the (negation of) the new ISUPPERBOUNDED() operator

"ISINFINITEINTERVAL" is the operator for testing emptiness of an interval. For a detailed definition, see IntervalIsEmptyOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

ISINFINITEINTERVAL_I

@Deprecated
static final NameIdentifier ISINFINITEINTERVAL_I

Deprecated. - replace invocations of this operator with the (negation of) the new ISUPPERBOUNDED() operator

ISLOWERBOUNDED

static final java.lang.String ISLOWERBOUNDED

See Also:

Constant Field Values

ISLOWERBOUNDED_I

static final NameIdentifier ISLOWERBOUNDED_I

ISUPPERBOUNDED

static final java.lang.String ISUPPERBOUNDED

See Also:

Constant Field Values

ISUPPERBOUNDED_I

static final NameIdentifier ISUPPERBOUNDED_I

IUNION

static final java.lang.String IUNION

"IUNION" is the UNION operator for intervals. For a detailed definition, see IntervalUnionOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

IUNION_I

static final NameIdentifier IUNION_I

JOIN

static final java.lang.String JOIN

"JOIN" is the natural-join operator of the relational algebra. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj
• Let RB be a relation with attributes C1,C2,...,Cj,B1,B2,...,Bk
• A1,A2,...,Ai are the attributes exclusive to RA, but there may be zero such
• B1,B2,...,Bk are the attributes exclusive to RB, but there may be zero such
• C1,C2,...,Cj are the attributes common to both RA and RB, but there may be zero such
• The result of JOIN(RA,RB) is a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj,B1,B2,...,Bk
• That result will hold a tuple with attribute values a1,a2,...,ai,c1,c2,...,cj,b1,b2,...,bk if and only if :
  • A tuple with attribute values a1,a2,...,ai,c1,c2,...,cj appears in RA
  • A tuple with attribute values c1,c2,...,cj,b1,b2,...,bk appears in RB

The following rules for "JOIN" derive from this definition :

• Let AC1,AC2,...ACj be the types of C1,C2,...,Cj in RA and BC1,BC2,...BCj be the types of C1,C2,...,Cj in RB. Then for all pairs (AC1,BC1),(AC2,BC2),...,(ACj,BCj) it must hold that a common supertype exists for the two types in the pair.

"JOIN" is associative, so n-adic joins are possible.

Please note that "JOIN" exposes the USING quirk

See Also:

Constant Field Values

JOINUSING

static final java.lang.String JOINUSING

See Also:

Constant Field Values

LAST

static final java.lang.String LAST

See Also:

Constant Field Values

LE

static final java.lang.String LE

See Also:

Constant Field Values

LE_I

static final NameIdentifier LE_I

LEFTJOIN

static final java.lang.String LEFTJOIN

"LEFTJOIN" is a "left join" of the relational algebra supported by SIRA_PRISE. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj
• Let RB be a relation with attributes C1,C2,...,Cj,B1,B2,...,Bk
• A1,A2,...,Ai are the attributes exclusive to RA, but there may be zero such
• B1,B2,...,Bk are the attributes exclusive to RB, but there may be zero such
• C1,C2,...,Cj are the attributes common to both RA and RB, but there may be zero such
• The result of LEFTJOIN(RA,RB,(expressions)) is a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj,B1,B2,...,Bk
• That result will hold a tuple with attribute values a1,a2,...,ai,c1,c2,...,cj,,b1,b2,...,bk if and only if :
  • A tuple with attribute values a1,a2,...,ai,c1,c2,...,cj appears in RA
  • Either of the following is true
    • A tuple with attribute values c1,c2,...,cj,b1,b2,...,bk appears in RB
    • No tuple appears in RB with attribute values c1,c2,...,cj (and any arbitrary value for b1,b2,...,bk), and the values b1,b2,...,bk are the result of evaluaing the expressions for the b attributes specified in the third argument.

Note that "LEFTJOIN"(RA,RB,expressions) is equivalent to the following :

• UNION(JOIN(RA,RB),EXTEND(SEMIMINUS(RA,RB),(expressions)))

The following rules for "LEFTJOIN" derive from this definition :

• Let AC1,AC2,...ACj be the types of C1,C2,...,Cj in RA and BC1,BC2,...BCj be the types of C1,C2,...,Cj in RB. Then for all pairs (AC1,BC1),(AC2,BC2),...,(ACj,BCj) it must hold that a common supertype exists for the two types in the pair.
• The set of expressions must specify an expression for each of the attributes B1,B2,...,Bk, and none other.
• Let EB1,EB2,...EBk be the return types for the expressions corresponding to the attributes B1,B2,...,Bk, and let BB1,BB2,...BBk be the types of B1,B2,...,Bk in RB. Then for all pairs (EB1,BB1),(EB2,BB2),...,(EBj,BBj) it must hold that a common supertype exists for the two types in the pair.

Please note that "LEFTJOIN" exposes the USING quirk

See Also:

Constant Field Values

LEFTJOINUSING

static final java.lang.String LEFTJOINUSING

See Also:

Constant Field Values

LENGTH

static final java.lang.String LENGTH

See Also:

Constant Field Values

LENGTH_I

static final NameIdentifier LENGTH_I

LT

static final java.lang.String LT

See Also:

Constant Field Values

LT_I

static final NameIdentifier LT_I

MAX

static final java.lang.String MAX

See Also:

Constant Field Values

MAX_I

static final NameIdentifier MAX_I

MEETS

static final java.lang.String MEETS

"MEETS" is the operator for the Allen MEETS interval operator. For a detailed definition, see IntervalMeetsOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

MEETS_I

static final NameIdentifier MEETS_I

MERGES

static final java.lang.String MERGES

"MERGES" is the operator for the Allen MERGESTS interval operator. For a detailed definition, see IntervalMergesOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

MERGES_I

static final NameIdentifier MERGES_I

MIN

static final java.lang.String MIN

See Also:

Constant Field Values

MIN_I

static final NameIdentifier MIN_I

MINUS

static final java.lang.String MINUS

"MINUS" is the difference operator of the relational algebra. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let RB be a relation with the very same attributes A1,A2,...,Ai
• For each A1,A2,...,Ai, the types of the attributes in both relation must be such that a common supertype for both exists.
• The result of "MINUS"(RA,RB) is a relation with attributes A1,A2,...,Ai, whose types are the same as in RA.
• That result will hold a tuple with attribute values a1,a2,...,ai if and only if :
  • That tuple appears in RA,
  • AND that tuple DOES NOT appear in RB

The following rules for "MINUS" apply :

• Let TA1A,TA2A,...TAiA be the types of A1,A2,...,Ai in RA and TA1B,TA2B,...TAiB be the types of A1,A2,...,Ai in RB. Then for all pairs (TA1A,TA1B),(TA2A,TA2B),...,(TAiA,TAiB) it must hold that a common supertype exists for the two types in the pair.

Please note that "MINUS" exposes the USING quirk

See Also:

Constant Field Values

MINUSUSING

static final java.lang.String MINUSUSING

See Also:

Constant Field Values

NEXT

static final java.lang.String NEXT

See Also:

Constant Field Values

OVERLAPS

static final java.lang.String OVERLAPS

"OVERLAPS" is the operator for the Allen OVERLAPS interval operator. For a detailed definition, see IntervalOverlapsOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

OVERLAPS_I

static final NameIdentifier OVERLAPS_I

PACK

static final java.lang.String PACK

"PACK" is the PACK operator of the relational algebra defined in TDATRM/TaRT and my paper. This operator is defined as follows :

• The operator takes a single relation value as input.
• The operator also requires an ordered list of attributes of that relation, all these attributes must be interval-typed.
• The result of the operator is the relation that is equivalent to the input relation and that satisfies (ITA1, ITA2, ..., ITAn) PNF. (Where "equivalent to the input relation" means "has exactly the same {ITA1, ITA2, ..., ITAn} equivalence classes as the input, and all of the corresponding {ITA1, ITA2, ..., ITAn} equivalence classes in input and result cover the exact same set of points.)

The following rules for "PACK" derive from this definition :

• All of the attribute names mentioned in the pack list must name an attribute of RA that is interval-typed.
• No attribute can be mentioned twice in the list

See Also:

Constant Field Values

PRIOR

static final java.lang.String PRIOR

See Also:

Constant Field Values

PROJECT

static final java.lang.String PROJECT

"PROJECT" is the projection operator of the relational algebra defined in TTM. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,O1,O2,...,Oj
• A1,A2,...,Ai are attributes being projected away, but note that there may be zero such.
• O1,O2,...,Oj are attributes the relation is being projected onto, but note that there may be zero such.
• The result of PROJECT(RA,(O1,O2,...,Oj)) is a relation with attributes O1,O2,...,Oj
• That result will hold a tuple with attribute values o1,o2,...,oj if and only if :
  • A tuple with attribute values o1,o2,...,oj for the 'O' attributes, and any attribute value for the 'A' attributes, appears in RA.

The following rules for "PROJECT" derive from this definition :

• All of the 'O' attribute names mentioned in the projection list must name an attribute of RA
• No 'O' attribute can be mentioned twice in the list

Note that due to automatic PACKing of the result, if an intervaltyped attribute is among the the 'O' attributes, a specific flavour of the USING quirk may show.

See Also:

Constant Field Values

RENAME

static final java.lang.String RENAME

"RENAME" is the RENAME operator of the relational algebra defined in TTM. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,O1,O2,...,Oj
• A1,A2,...,Ai are attributes not being renamed, but note that there may be zero such.
• O1,O2,...,Oj are attributes being renamed, but note that there may be zero such.
• Let O1,N1,O2,N2,...,Oj,Nj be a rename list (= a list of "old,new" attribute name pairs)
• The result of RENAME(RA,(O1,N1,O2,N2,...,Oj,Nj)) is a relation with attributes A1,A2,...,Ai,N1,N2,...,Nj
• That result will hold a tuple with attribute values a1,a2,...,ai,n1,n2,...,nj if and only if :
  • A tuple with attribute values a1,a2,...,ai,o1,o2,...,oj appears in RA such that o1=n1 AND o2=n2 AND ... AND oj=nj

The following rules for "RENAME" derive from this definition :

• All of the 'O' attribute names mentioned in the rename list must name an attribute of RA
• No 'O' attribute can be mentioned twice in the list
• No name for an 'N' attribute in the list can appear twice
• None of the 'A' attributes can appear in the set of 'N' attribute names

See Also:

Constant Field Values

RESTRICT

static final java.lang.String RESTRICT

"RESTRICT" is the restriction operator of the relational algebra defined in TTM. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let expr be a boolean expression (meaning it denotes a predicate). This expression may be of any arbitrary complexity.
• Any of A1,A2,...,Ai may be referenced in expr, but note that there may be zero such references, i.e. the expression is constant with respect to the tuples in RA.
• The result of RESTRICT(RA,(expr)) is a relation with attributes A1,A2,...,Ai
• That result will hold a tuple if and only if :
  • That tuple appears in RA.
  • The evaluation of expr yields the boolean value "true" for that tuple.

Note that while the "original" definition of restriction limited the expression to contain no other references than references to attributes of RA, SIRA_PRISE imposes no such restriction. That is, references to database relvars etc. are allowed, and will be evaluated if necessary and as appropriate for each tuple in RA.

See Also:

Constant Field Values

SEMIJOIN

static final java.lang.String SEMIJOIN

"SEMIJOIN" is the MATCHING operator of the relational algebra defined in TTM. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj
• Let RB be a relation with attributes C1,C2,...,Cj,B1,B2,...,Bk
• A1,A2,...,Ai are the attributes exclusive to RA, but there may be zero such
• B1,B2,...,Bk are the attributes exclusive to RB, but there may be zero such
• C1,C2,...,Cj are the attributes common to both RA and RB, but there may be zero such
• The result of SEMIJOIN(RA,RB) is a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj
• That result will hold a tuple with attribute values a1,a2,...,ai,c1,c2,...,cj if and only if :
  • A tuple with attribute values a1,a2,...,ai,c1,c2,...,cj appears in RA
  • At least one tuple appears in RB with attribute values c1,c2,...,cj and any arbitrary value for b1,b2,...,bk

Note that "SEMIJOIN"(RA,RB) is always equivalent to the following two expressions :

• JOIN(RA,PROJECT(RB,(C1,C2,...,Cj)))
• PROJECT(JOIN(RA,RB),(A1,A2,...,Ai,C1,C2,...,Cj))

The following rules for "SEMIJOIN" derive from this definition :

• Let AC1,AC2,...ACj be the types of C1,C2,...,Cj in RA and BC1,BC2,...BCj be the types of C1,C2,...,Cj in RB. Then for all pairs (AC1,BC1),(AC2,BC2),...,(ACj,BCj) it must hold that a common supertype exists for the two types in the pair.

Please note that "SEMIJOIN" exposes the USING quirk

See Also:

Constant Field Values

SEMIJOINUSING

static final java.lang.String SEMIJOINUSING

See Also:

Constant Field Values

SEMIMINUS

static final java.lang.String SEMIMINUS

"SEMIMINUS" is the NOT MATCHING operator of the relational algebra defined in TTM. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj
• Let RB be a relation with attributes C1,C2,...,Cj,B1,B2,...,Bk
• A1,A2,...,Ai are the attributes exclusive to RA, but there may be zero such
• B1,B2,...,Bk are the attributes exclusive to RB, but there may be zero such
• C1,C2,...,Cj are the attributes common to both RA and RB, but there may be zero such
• The result of SEMIMINUS(RA,RB) is a relation with attributes A1,A2,...,Ai,C1,C2,...,Cj
• That result will hold a tuple with attribute values a1,a2,...,ai,c1,c2,...,cj if and only if :
  • A tuple with attribute values a1,a2,...,ai,c1,c2,...,cj appears in RA
  • No tuple at all appears in RB with attribute values c1,c2,...,cj and any arbitrary values for b1,b2,...,bk

Note that SEMIMINUS(RA,RB) is always equivalent to the following expression :

• MINUS(RA,SEMIJOIN(RA,RB))
• and of course those in which the SEMIJOIN in the former item, has been replaced with any of its equivalent longhands

The following rules for "SEMIMINUS" derive from this definition :

• Let AC1,AC2,...ACj be the types of C1,C2,...,Cj in RA and BC1,BC2,...BCj be the types of C1,C2,...,Cj in RB. Then for all pairs (AC1,BC1),(AC2,BC2),...,(ACj,BCj) it must hold that a common supertype exists for the two types in the pair.

Please note that "SEMIMINUS" exposes the USING quirk

See Also:

Constant Field Values

SEMIMINUSUSING

static final java.lang.String SEMIMINUSUSING

See Also:

Constant Field Values

SPAN

static final java.lang.String SPAN

"SPAN" is the SPAN interval operator. For a detailed definition, see IntervalSpanOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

SPAN_I

static final NameIdentifier SPAN_I

SPLITBY

static final java.lang.String SPLITBY

"SPLITBY" is the SPLITBY interval operator. For a detailed definition, see IntervalSplitByOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

SPLITBY_I

static final NameIdentifier SPLITBY_I

SPLITS

static final java.lang.String SPLITS

"SPLITS" is the operator for the SPLITS interval operator. For a detailed definition, see IntervalSplitsOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

SPLITS_I

static final NameIdentifier SPLITS_I

STARTPOINTOF

static final java.lang.String STARTPOINTOF

"STARTPOINTOF" is the operator for the STARTPOINTOF interval operator. For a detailed definition, see IntervalStartPointOfOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

STARTPOINTOF_I

static final NameIdentifier STARTPOINTOF_I

SUMMARIZEBY

static final java.lang.String SUMMARIZEBY

"SUMMARIZEBY" is the generic summarization operator as supported by SIRA_PRISE. Summarization is more complex than AGGREGATE, in that it allows to compute aggregations for groups of tuples within a relation, whereas AGGREGATE always aggregates whole relations. This operator is defined as follows :

• SUMMARIZEBY takes as inputs a relation R, a summarizeby spec S, which is a list of attributes that make up the grouping key, and an aggregation spec A which is identical in nature to that from AGGREGATE
• SUMMARIZEBY(R,S,(A)) is then defined to be equivalent to : UNGROUP ( PROJECT ( EXTEND ( GROUP (R,AGGRBASE(<all attributes not in S>)) , (AGGR(AGGREGATE(AGGRBASE,(A))))) , (<all attributes in S>,AGGR)) , (AGGR))
• A step by step explanation will clarify how this works :
  • First, the input relation is GROUPed such that all the attributes in S are kept, and the remaining attributes are moved inside an RVA named AGGRBASE (this name isn't hardcoded in the system, it's just for explanation purposes. SIRA_PRISE will search a name that's available.).
  • Then, the result of that is EXTENDed with another RVA named AGGR, which is itself the result of applying the aggregations specified in A to the relation-valued attribute AGGRBASE.
  • Then, the AGGRBASE attribute is projected away again. We no longer need it since we now have the aggregated values the user is interested in.
  • Then, then result in UNGROUPed over the AGGR RVA. Remember that, being the result of an AGGREGATE invcotion, this RVA is guaranteed to be singleton.
  • The result of that is the desired aggregated values, "flattened out" in a relation that has the "BY" attribute values alongside their aggregation results.

The following rules for "SUMMARIZEBY" derive from this definition :

• Obviously, there may be no duplicates in the list of attribute names in A that specify the names for the attributes holding the aggregation results.

See Also:

Constant Field Values

TCLOSE

static final java.lang.String TCLOSE

"TCLOSE" is the transitive closure operator as supported by SIRA_PRISE. It deviates slightly from the transitive closure operation defined in TTM, in that :

• The TTM version only allows binary input relations (i.e. of degree 2), whereas the SIRA_PRISE version allows for higher-degree relations.
• Consequently, the SIRA_PRISE version needs an additional argument for specifying how the tuple matching is to be performed (which attributes are compared to which), which the TTM version can omit since there is only one option.

The SIRA_PRISE version is defined as follows :

• Let RA be a relation with attributes PA1,PA2,...,PAi,CA1,CA2,...,CAi
• The PA1,PA2,...,PAi attributes are the "parent" attributes, the attributes that constitute the identifier of a "parent" node in the parent-to-child relationship represented by this relation.
• The CA1,CA2,...,CAi attributes are the "child" attributes, the attributes that constitute the identifier of a "child" node in the parent-to-child relationship represented by this relation.
• Note that there must be exactly as many "child" attributes as there are "parent" attributes, and that there must be at least one.
• The result of TCLOSE(RA,(PA1,CA1,PA2,CA2,...,PAi,CAi)) is a relation with the same attributes as RA - PA1,PA2,...,PAi,CA1,CA2,...,CAi, such that :
  • All the tuples that appear in RA will appear in this result, and
  • If the result contains two tuples t1 and t2 with attribute values (pa11,pa21,...,pan1,ca11,ca21,...,can1) and (pa12,pa22,...,PAn2,ca12,ca22,...,can2), respectively, such that ca11=pa12 AND ca21=pa22 AND ... AND can1=pan2, then the result shall also include a tuple t3 with attribute values the "parent" attribute values from t1 and the "child" attribure values from t2 (pa11,pa21,...,pan1,ca12,ca22,...,can2). Stated informally, if there are two tuples in the result such that the child identified by the first is the same as the parent identified by the latter, then there shall also be a tuple in the result that reflects the "grandparent-grandchild" relationship between the "parent" in the first tuple and the "child" in the second.

The following rules for "TCLOSE" derive from this definition :

• All of the 'PA' attribute names as well as all of the 'CA' attributes mentioned in the tclose attribute matching list must name an attribute of RA.
• All attributes of RA must be mentioned exactly once in the closure attributes matching list, either as a parent attribute or else as a child attribute.
• For each matching pair PAn,CAn, the types of the two attributes involved must have a common supertype (the equality operator between them must be resolvable).

See Also:

Constant Field Values

TRANSACTION

@Deprecated
static final java.lang.String TRANSACTION

Deprecated. deprecated

See Also:

Constant Field Values

TRANSFORM

static final java.lang.String TRANSFORM

"TRANSFORM" combines the functionality of the EXTEND, PROJECT and RENAME operators into one. This operator is defined as follows :

• TRANSFORM takes as inputs a relation R, and a list of TransformDef specifications.
• Each TransformDef specification is of one of the following two forms :
  1. A simple attribute name, which must be an attribute name of the input relation R.
  2. A specification of an attribute name plus an expression to evaluate (identical in form to the way an EXTEND list is specified). In this case the attribute name must not appear in R.
• The result of the TRANSFORM is the result of performing the following two steps :
  1. First, EXTEND R with values for all attributes specified in the TransformDef specifications in form (2),
  2. Then PROJECT that result onto all the attributes specified in the TransformDef specifications.

The following rules for "TRANSFORM" derive from this definition :

• Attribute names in the TransformDef specification list that are not accompanied by an expression, must be attributes of R.
• Attribute names in the TransformDef specification list that are accompanied by an expression, must not be attributes of R.

See Also:

Constant Field Values

UNGROUP

static final java.lang.String UNGROUP

"UNGROUP" is the UNGROUPing operator as supported by SIRA_PRISE. The operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai,RVA. The RVA is a relation-typed attribute with attributes B1,B2,...,Bj.
• The result of UNGROUP( RA , (RVA) ) is a relation with the attributes A1,A2,...,Ai,B1,B2,...,Bj, such that :
  • For each tuple ta in RA, and for each tuple tb in the relation-valued attribute RVA in ta, there will be a corresponding tuple tr in the result.
  • This tuple tr will a1,a2,...ai attribute values drawn from ta, and b1,b2,...,bj values drawn from tb.

Observe how the definition implies that if the RVA value in ta is the empty relation, there will be no tuple tr in the result, corresponding to ta.

The following rules for "UNGROUP" derive from this definition :

• There may be no overlap in RA between the attribute names A1,A2,...,Ai and the attribute names B1,B2,...,Bj.

See Also:

Constant Field Values

UNION

static final java.lang.String UNION

"UNION" is the union operator of the relational algebra. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let RB be a relation with the very same attributes A1,A2,...,Ai
• For each A1,A2,...,Ai, the types of the attributes in both relation must be such that a common supertype for both exists.
• The result of UNION(RA,RB) is a relation with attributes A1,A2,...,Ai, whose types are the common supertypes found for the types of those attributes in the arguments.
• That result will hold a tuple with attribute values a1,a2,...,ai if and only if :
  • That tuple appears in RA,
  • OR that tuple appears in RB

"UNION" is associative, so n-adic unions are possible.

The following rules for "UNION" apply :

• Let TA1A,TA2A,...TAiA be the types of A1,A2,...,Ai in RA and TA1B,TA2B,...TAiB be the types of A1,A2,...,Ai in RB. Then for all pairs (TA1A,TA1B),(TA2A,TA2B),...,(TAiA,TAiB) it must hold that a common supertype exists for the two types in the pair.

Please note that "UNION" exposes the USING quirk

See Also:

Constant Field Values

UNIONUSING

static final java.lang.String UNIONUSING

See Also:

Constant Field Values

UNPACK

static final java.lang.String UNPACK

See Also:

Constant Field Values

WITHIN

static final java.lang.String WITHIN

"WITHIN" is an interval operator that is equivalent to, in Allen terms, STARTS or DURING or FINISHES or EQUAL. For a detailed definition, see IntervalWithinOperatorImplementation.executeOperator(java.util.LinkedList)

See Also:

Constant Field Values

WITHIN_I

static final NameIdentifier WITHIN_I

XMINUS

static final java.lang.String XMINUS

"XMINUS" is the symmetric difference operator of the relational algebra. This operator is defined as follows :

• Let RA be a relation with attributes A1,A2,...,Ai
• Let RB be a relation with the very same attributes A1,A2,...,Ai
• For each A1,A2,...,Ai, the types of the attributes in both relation must be such that a common supertype for both exists.
• The result of XMINUS(RA,RB) is a relation with attributes A1,A2,...,Ai, whose types are the common supertypes found for the types of those attributes in the arguments.
• That result will hold a tuple with attribute values a1,a2,...,ai if and only if :
  • That tuple appears in RA, AND that tuple DOES NOT appear in RB,
  • OR that tuple appears in RB AND it does not appear in RA

"XMINUS" is associative, so n-adic symmetric difference is possible.

Also note that XMINUS(RA,RB) is semantically equivalent to UNION(MINUS(RA,RB),MINUS(RB,RA)), or alternatively, to MINUS(UNION(RA,RB),INTERSECT(RA,RB)),and can thus be considered a syntactic shorthand for this longer expression.
Consequently, the following rules for "XMINUS" apply :

• Let TA1A,TA2A,...TAiA be the types of A1,A2,...,Ai in RA and TA1B,TA2B,...TAiB be the types of A1,A2,...,Ai in RB. Then for all pairs (TA1A,TA1B),(TA2A,TA2B),...,(TAiA,TAiB) it must hold that a common supertype exists for the two types in the pair.

Please note that "XMINUS" exposes the USING quirk

See Also:

Constant Field Values

XMINUSUSING

static final java.lang.String XMINUSUSING

See Also:

Constant Field Values