public abstract Class DataExpression

Overrides org.eclipse.persistence.expressions.Expression.aliasForTable.

INTERNAL: Find the alias for a given table

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.asOf.

Doc from org.eclipse.persistence.expressions.Expression.asOf.

Sets all tables represented by this expression to be queried as of a past time.

Example:

 EclipseLink: employee.asOf(new AsOfClause(pastTime))
 Java: None
 SQL (Flashback): SELECT ... FROM EMPLOYEE AS OF TIMESTAMP (pastTime) t0 ...
 SQL (Generic): .. WHERE (t1.START <= pastTime) AND ((t1.END IS NULL) OR t1.END > pastTime)

Set an as of clause at the expression level to still query for current objects while expressing selection criteria like:

• query objects as of one time that met some condition at another time.
• query objects that changed a certain way over a certain interval (querying for change).

Simultaneously querying on two versions of the same object (one past one present) lets you express these advanced selection criteria.

Example: Querying on past attributes using parallel expressions.

  // Finds all employees who lived in Ottawa as of a past time.
  ExpressionBuilder employee = new ExpressionBuilder();
  ExpressionBuilder pastEmployee = new ExpressionBuilder(Employee.class);
  pastEmployee.asOf(pastTime);
  Expression pastAddress = pastEmployee.get("address"); // by default address will also be as of past time.
  Expression selectionCriteria = pastAddress.get("city").equal("Ottawa").and(
      employee.equal(pastEmployee));

The advantage of the parallel expression is that you can still read current objects, the as of clause will affect only the where clause / selection criteria.

You may be tempted to rewrite the above as employee.get("address").asOf(pastTime). That is allowed but see below for the finer points involved in this.

Example: Querying on object changes using parallel expressions.

  // Finds all employees who recently received a raise.  Note that current
  // objects are returned, so can be cached normally.
  ExpressionBuilder employee = new ExpressionBuilder();
  Expression pastEmployee = new ExpressionBuilder(Employee.class);
  pastEmployee.asOf(yesterday);
  Expression parallelJoin = employee.equal(pastEmployee);
  Expression selectionCriteria = parallelJoin.and(
      employee.get("salary").greaterThan(pastEmployee.get("salary")));

Example: Querying on object changes using custom query keys

  // First define the custom query key and add it to your descriptor.
  ExpressionBuilder builder = new ExpressionBuilder(Employee.class);
  Expression joinCriteria = builder.getField("EMPLOYEE.EMP_ID").equal(builder.getParameter("EMPLOYEE.EMP_ID"));
  OneToOneQueryKey selfReferential = new OneToOneQueryKey();
  selfReferential.setName("this");
  selfReferential.setJoinCriteria(joinCriteria);
  selfReferential.setReferenceClass(Employee.class);
  getSession().getDescriptor(Employee.class).addQueryKey(selfReferential);

  // Now build query as before.
  Expression employee = new ExpessionBuilder();
  Expression pastEmployee = employee.get("this").asOf(yesterday);
  Expression selectionCriteria = employee.get("salary").greaterThan(pastEmployee.get("salary"));

Note in general that any parallel expression can be rewritten using a custom query key. EclipseLink will even automatically interpret x.get("this") for you so you do not need to define the above query key first.

Full Reference:

If an object is mapped to multiple tables, then each table will be as of the same time. Two objects mapped to the same table can not have different as of times. Conversely only expressions which have associated tables can have an as of clause.

If an as of clause is not explicitly set an expression will use the clause of its base expression, and so on recursively until one is found or an ExpressionBuilder is reached. Some usage scenarios follow:

• employee.asOf(pastTime).anyOf("projects"): projects as of past time.
• expressionBuilder.asOf(pastTime): entire expression as of past time.
• employee.asOf(pastTime).anyOf("projects").asOf(null): projects as of current time.
• employee.anyOf("projects").asOf(pastTime): projects only as of past time.

Watch out for x.asOf(oneTime).get("y").asOf(anotherTime).

• emp.anyOf("phoneNumbers").asOf(yesterday) = emp.asOf(yesterday).anyOf("phoneNumbers") but:
• emp.get("address").asOf(yesterday) != emp.asOf(yesterday).get("address").

Parameters

clause:AsOfClause

A read only data object used to represent a past time.

Returns:Expression

this

Annotations

@Override

INTERNAL:

Overrides org.eclipse.persistence.expressions.Expression.equals.

INTERNAL: Return if the expression is equal to the other. This is used to allow dynamic expression's SQL to be cached.

Parameters

object:Object

Doc from java.lang.Object.equals.

the reference object with which to compare.

Returns:boolean

Doc from java.lang.Object.equals.

true if this object is the same as the obj argument; false otherwise.

Annotations

@Override

INTERNAL:

INTERNAL:

Overrides org.eclipse.persistence.expressions.Expression.getAlias.

ADVANCED: Return an expression representing a sub-select in the from clause.

Example:

 builder.getAlias(builder.subQuery(reportQuery)).get("type").equal("S");

Annotations

@Override

INTERNAL: Return the field appropriately aliased

Overrides org.eclipse.persistence.expressions.Expression.getAsOfClause.

Doc from org.eclipse.persistence.expressions.Expression.getAsOfClause.

Answers the past time the expression is explicitly as of.

Returns:AsOfClause

An immutable object representation of the past time. null if no clause set, AsOfClause.NO_CLAUSE if clause explicitly set to null.

Annotations

@Override

INTERNAL: Return the descriptor which contains this query key.

INTERNAL:

Overrides org.eclipse.persistence.expressions.Expression.getField.

Doc from org.eclipse.persistence.expressions.Expression.getField.

ADVANCED: Return an expression representing a field in a data-level query. This is used internally in EclipseLink, or to construct queries involving fields and/or tables that are not mapped.

Example:

 builder.getField("ADDR_ID").greaterThan(100);
 builder.getTable("PROJ_EMP").getField("TYPE").equal("S");

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.getField.

Doc from org.eclipse.persistence.expressions.Expression.getField.

ADVANCED: Return an expression representing a field in a data-level query. This is used internally in EclipseLink, or to construct queries involving fields and/or tables that are not mapped.

Example:

 builder.getField(aField).greaterThan(100);

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.getTable.

Doc from org.eclipse.persistence.expressions.Expression.getTable.

ADVANCED: Return an expression representing a table in a data-level query. This is used internally in EclipseLink, or to construct queries involving fields and/or tables that are not mapped.

Example:

 builder.getTable("PROJ_EMP").getField("TYPE").equal("S");

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.getTable.

Doc from org.eclipse.persistence.expressions.Expression.getTable.

ADVANCED: Return an expression representing a table in a data-level query. This is used internally in EclipseLink, or to construct queries involving fields and/or tables that are not mapped.

Example:

 builder.getTable(linkTable).getField("TYPE").equal("S");

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.getTableAliases.

INTERNAL: Return the aliases used. For CR#2456 must never lazily initialize as also used for Expression identity.

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.hasAsOfClause.

Doc from org.eclipse.persistence.expressions.Expression.hasAsOfClause.

ADVANCED: Answers true if this is to be queried as of a past time.

Returns:boolean

false from asOf(null); hasAsOfClause().

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.hasBeenAliased.

Doc from org.eclipse.persistence.expressions.Expression.hasBeenAliased.

INTERNAL: Answers if the database tables associated with this expression have been aliased. This insures the same tables are not aliased twice.

Annotations

@Override

INTERNAL: Did the normalizer already add additional joins to the where clause due to this query key representing a foreign reference mapping? This insures that join criteria (for any query key expression) is not added twice.

New meaning: DataExpressions are often iterated on multiple times during normalize, but Function/Relation expressions only once. Adding a has been normalized flag improves performance and is required in some applications, such as have temporal query criteria been added.

INTERNAL:

Overrides org.eclipse.persistence.expressions.Expression.isDataExpression.

Doc from org.eclipse.persistence.expressions.Expression.isDataExpression.

INTERNAL:

Annotations

@Override

Overrides org.eclipse.persistence.expressions.Expression.iterateOn.

INTERNAL: For iterating using an inner class

Annotations

@Override

INTERNAL:

INTERNAL:

Overrides org.eclipse.persistence.expressions.Expression.normalize.

INTERNAL: Normalize the expression into a printable structure. Any joins must be added to form a new root.

Annotations

@Override

Implements abstract org.eclipse.persistence.expressions.Expression.printSQL.

INTERNAL: Print SQL onto the stream, using the ExpressionPrinter for context

Annotations

@Override

INTERNAL: For CR#2456, Table identity involves having two tables sharing the same aliasing table.

Overrides org.eclipse.persistence.expressions.Expression.writeSubexpressionsTo.

Print the base for debuggin purposes.

Annotations

@Override