/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openjpa.kernel.exps;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import org.apache.commons.lang.ObjectUtils;
import org.apache.openjpa.kernel.Extent;
import org.apache.openjpa.kernel.StoreContext;
import org.apache.openjpa.lib.util.Localizer;
import org.apache.openjpa.meta.ClassMetaData;
import org.apache.openjpa.util.ImplHelper;
import org.apache.openjpa.util.UnsupportedException;
import org.apache.openjpa.util.UserException;
/**
* Expression factory implementation that can be used to execute queries
* in memory.
*
* @author Abe White
* @nojavadoc
*/
public class InMemoryExpressionFactory
implements ExpressionFactory {
private static final Value NULL = new Null();
private static final Object UNIQUE = new Object();
// list of unbound variables in this query
private List<UnboundVariable> _unbounds = null;
/**
* Tests whether the given candidate matches the given type and this
* expression.
*/
public boolean matches(QueryExpressions exps, ClassMetaData type,
boolean subs, Object candidate, StoreContext ctx, Object[] params) {
// ignore candidates of the wrong type
if (candidate == null)
return false;
if (!subs && candidate.getClass() != type.getDescribedType())
return false;
if (subs && !type.getDescribedType().isAssignableFrom
(candidate.getClass()))
return false;
// evaluate the expression for all possible combinations of values
// of the unbound variables; the candidate matches if any combination
// matches
return matches((Exp) exps.filter, candidate, ctx, params, 0);
}
/**
* Recursive method to evaluate the expression for all possible
* combinations of unbound variables. This method simulates a sequence
* of embedded procedural loops over the extents of all variables in the
* unbounds list.
*/
protected boolean matches(Exp exp, Object candidate, StoreContext ctx,
Object[] params, int i) {
// base case: all variables have been aliased; evaluate for current
// values
if (_unbounds == null || i == _unbounds.size())
return exp.evaluate(candidate, candidate, ctx, params);
// grab the extent for this variable
UnboundVariable var = _unbounds.get(i);
Iterator<Object> itr = ctx.extentIterator(var.getType(), true, null, false);
try {
// if the extent was empty, then alias the variable to null
if (!itr.hasNext()) {
var.setValue(null);
return matches(exp, candidate, ctx, params, i + 1);
}
// try every value, short-circuiting on match
while (itr.hasNext()) {
// set the variable to each extent value and recurse
var.setValue(itr.next());
if (matches(exp, candidate, ctx, params, i + 1))
return true;
}
// no match
return false;
} finally {
ImplHelper.close(itr);
}
}
/**
* Group the list of matches into a list of lists.
*/
public List group(QueryExpressions exps, List matches,
StoreContext ctx, Object[] params) {
if (matches == null || matches.isEmpty() || exps.grouping.length == 0)
return matches;
// to form groups we first order on the grouping criteria
matches = order(exps, exps.grouping, false, matches, ctx, params);
// now we combine all results whose values for each grouping clause
// are the same, relying on the fact that these values will already be
// together due to the sorting
Object[] prevs = new Object[exps.grouping.length];
Arrays.fill(prevs, UNIQUE);
Object[] curs = new Object[exps.grouping.length];
List grouped = new ArrayList();
List group = null;
Object pc;
boolean eq;
for (Iterator itr = matches.iterator(); itr.hasNext();) {
pc = itr.next();
eq = true;
for (int i = 0; i < exps.grouping.length; i++) {
curs[i] = ((Val) exps.grouping[i]).evaluate(pc, pc, ctx,
params);
eq = eq && ObjectUtils.equals(prevs[i], curs[i]);
}
// if this object's grouping values differ from the prev,
// start a new group
if (!eq) {
if (group != null)
grouped.add(group);
group = new ArrayList();
}
group.add(pc);
System.arraycopy(curs, 0, prevs, 0, curs.length);
}
// add the last group formed
if (group != null)
grouped.add(group);
return grouped;
}
/**
* Return true if the given group matches the having expression.
*/
public boolean matches(QueryExpressions exps, Collection group,
StoreContext ctx, Object[] params) {
if (group == null || group.isEmpty())
return false;
if (exps.having == null)
return true;
// evaluate the expression for all possible combinations of values
// of the unbound variables; the group matches if any combination
// matches
return matches((Exp) exps.having, group, ctx, params, 0);
}
/**
* Recursive method to evaluate the expression for all possible
* combinations of unbound variables. This method simulates a sequence
* of embedded procedural loops over the extents of all variables in the
* unbounds list.
*/
private boolean matches(Exp exp, Collection group, StoreContext ctx,
Object[] params, int i) {
// base case: all variables have been aliased; evaluate for current
// values
if (_unbounds == null || i == _unbounds.size())
return exp.evaluate(group, ctx, params);
// grab the extent for this variable
UnboundVariable var = _unbounds.get(i);
Extent extent = ctx.getBroker().newExtent(var.getType(), true);
Iterator itr = extent.iterator();
try {
// if the extent was empty, then alias the variable to null
if (!itr.hasNext()) {
var.setValue(null);
return matches(exp, group, ctx, params, i + 1);
}
// try every value, short-circuiting on match
while (itr.hasNext()) {
// set the variable to each extent value and recurse
var.setValue(itr.next());
if (matches(exp, group, ctx, params, i + 1))
return true;
}
// no match
return false;
} finally {
ImplHelper.close(itr);
}
}
/**
* Create the projections for the given results.
*/
public List project(QueryExpressions exps, List matches,
StoreContext ctx, Object[] params) {
if (exps.projections.length == 0)
return matches;
// if an ungrouped aggregate, evaluate the whole matches list
if (exps.grouping.length == 0 && exps.isAggregate()) {
Object[] projection = project(matches, exps, true, ctx, params);
return Arrays.asList(new Object[]{ projection });
}
// evaluate each candidate
List projected = new ArrayList(matches.size());
for (Iterator itr = matches.iterator(); itr.hasNext();)
projected.add(project(itr.next(), exps, exps.grouping.length > 0,
ctx, params));
return projected;
}
/**
* Generate a projection on the given candidate.
*/
private Object[] project(Object candidate, QueryExpressions exps,
boolean agg, StoreContext ctx, Object[] params) {
Object[] projection = new Object[exps.projections.length
+ exps.ordering.length];
// calcualte result values
Object result = null;
for (int i = 0; i < exps.projections.length; i++) {
if (agg)
result = ((Val) exps.projections[i]).evaluate((Collection)
candidate, null, ctx, params);
else
result = ((Val) exps.projections[i]).evaluate(candidate,
candidate, ctx, params);
projection[i] = result;
}
// tack on ordering values
boolean repeat;
for (int i = 0; i < exps.ordering.length; i++) {
// already selected as a result?
repeat = false;
for (int j = 0; !repeat && j < exps.projections.length; j++) {
if (exps.orderingClauses[i].equals(exps.projectionClauses[j])) {
result = projection[j];
repeat = true;
}
}
// not selected as result; calculate value
if (!repeat) {
if (agg)
result = ((Val) exps.ordering[i]).evaluate((Collection)
candidate, null, ctx, params);
else
result = ((Val) exps.ordering[i]).evaluate(candidate,
candidate, ctx, params);
}
projection[i + exps.projections.length] = result;
}
return projection;
}
/**
* Order the given list of matches on the given value.
*/
public List order(QueryExpressions exps, List matches,
StoreContext ctx, Object[] params) {
return order(exps, exps.ordering, true, matches, ctx, params);
}
/**
* Order the given list of matches on the given value.
*
* @param projected whether projections have been applied to the matches yet
*/
private List order(QueryExpressions exps, Value[] orderValues,
boolean projected, List matches, StoreContext ctx, Object[] params) {
if (matches == null || matches.isEmpty()
|| orderValues == null || orderValues.length == 0)
return matches;
int results = (projected) ? exps.projections.length : 0;
boolean[] asc = (projected) ? exps.ascending : null;
int idx;
for (int i = orderValues.length - 1; i >= 0; i--) {
// if this is a projection, then in project() we must have selected
// the ordering value already after the projection values
idx = (results > 0) ? results + i : -1;
Collections.sort(matches,
new OrderValueComparator((Val) orderValues[i],
asc == null || asc[i], idx, ctx, params));
}
return matches;
}
/**
* Filter the given list of matches, removing duplicate entries.
*/
public List distinct(QueryExpressions exps, boolean fromExtent,
List matches) {
if (matches == null || matches.isEmpty())
return matches;
// no need to do distinct if not instructed to, or if these are
// candidate objects from an extent
int len = exps.projections.length;
if ((exps.distinct & exps.DISTINCT_TRUE) == 0
|| (fromExtent && len == 0))
return matches;
Set seen = new HashSet(matches.size());
List distinct = null;
Object cur;
Object key;
for (ListIterator li = matches.listIterator(); li.hasNext();) {
cur = li.next();
key = (len > 0 && cur != null) ? new ArrayKey((Object[]) cur) : cur;
if (seen.add(key)) {
// key hasn't been seen before; if we've created a distinct
// list, keep adding to it
if (distinct != null)
distinct.add(cur);
} else if (distinct == null) {
// we need to copy the matches list because the distinct list
// will be different (we've come across a non-unique key); add
// all the elements we've skipped over so far
distinct = new ArrayList(matches.size());
distinct.addAll(matches.subList(0, li.previousIndex()));
}
}
return (distinct == null) ? matches : distinct;
}
public Expression emptyExpression() {
return new Exp();
}
public Expression asExpression(Value v) {
return new ValExpression((Val) v);
}
public Expression equal(Value v1, Value v2) {
return new EqualExpression((Val) v1, (Val) v2);
}
public Expression notEqual(Value v1, Value v2) {
return new NotEqualExpression((Val) v1, (Val) v2);
}
public Expression lessThan(Value v1, Value v2) {
return new LessThanExpression((Val) v1, (Val) v2);
}
public Expression greaterThan(Value v1, Value v2) {
return new GreaterThanExpression((Val) v1, (Val) v2);
}
public Expression lessThanEqual(Value v1, Value v2) {
return new LessThanEqualExpression((Val) v1, (Val) v2);
}
public Expression greaterThanEqual(Value v1, Value v2) {
return new GreaterThanEqualExpression((Val) v1, (Val) v2);
}
public Expression isEmpty(Value v1) {
return new IsEmptyExpression((Val) v1);
}
public Expression isNotEmpty(Value v1) {
return not(isEmpty(v1));
}
public Expression contains(Value v1, Value v2) {
return new ContainsExpression((Val) v1, (Val) v2);
}
public Expression containsKey(Value v1, Value v2) {
return new ContainsKeyExpression((Val) v1, (Val) v2);
}
public Expression containsValue(Value v1, Value v2) {
return new ContainsValueExpression((Val) v1, (Val) v2);
}
public Value getMapValue(Value map, Value arg) {
return new GetMapValue((Val) map, (Val) arg);
}
public Expression isInstance(Value v1, Class c) {
return new InstanceofExpression((Val) v1, c);
}
public Expression and(Expression exp1, Expression exp2) {
if (exp1 instanceof BindVariableExpression)
return new BindVariableAndExpression((BindVariableExpression) exp1,
(Exp) exp2);
return new AndExpression((Exp) exp1, (Exp) exp2);
}
public Expression or(Expression exp1, Expression exp2) {
return new OrExpression((Exp) exp1, (Exp) exp2);
}
public Expression not(Expression exp) {
return new NotExpression((Exp) exp);
}
public Expression bindVariable(Value var, Value val) {
return new BindVariableExpression((BoundVariable) var, (Val) val);
}
public Expression bindKeyVariable(Value var, Value val) {
return new BindKeyVariableExpression((BoundVariable) var, (Val) val);
}
public Expression bindValueVariable(Value var, Value val) {
return new BindValueVariableExpression((BoundVariable) var, (Val) val);
}
public Expression endsWith(Value v1, Value v2) {
return new EndsWithExpression((Val) v1, (Val) v2);
}
public Expression matches(Value v1, Value v2,
String single, String multi, String esc) {
return new MatchesExpression((Val) v1, (Val) v2, single, multi, esc,
true);
}
public Expression notMatches(Value v1, Value v2,
String single, String multi, String esc) {
return new MatchesExpression((Val) v1, (Val) v2, single, multi, esc,
false);
}
public Expression startsWith(Value v1, Value v2) {
return new StartsWithExpression((Val) v1, (Val) v2);
}
public Subquery newSubquery(ClassMetaData candidate, boolean subs,
String alias) {
return new SubQ(alias);
}
public Path newPath() {
return new CandidatePath();
}
public Path newPath(Value val) {
return new ValuePath((Val) val);
}
public Literal newLiteral(Object val, int parseType) {
return new Lit(val, parseType);
}
public Literal newTypeLiteral(Object val, int parseType) {
return new TypeLit(val, parseType);
}
public Value getThis() {
return new This();
}
public Value getNull() {
return NULL;
}
public <T extends Date> Value getCurrentDate(Class<T> dateType) {
return new CurrentDate(dateType);
}
public <T extends Date> Value getCurrentTime(Class<T> dateType) {
return new CurrentDate(dateType);
}
public <T extends Date> Value getCurrentTimestamp(Class<T> dateType) {
return new CurrentDate(dateType);
}
public Parameter newParameter(Object name, Class type) {
return new Param(name, type);
}
public Parameter newCollectionValuedParameter(Object name, Class type) {
return new CollectionParam(name, type);
}
public Value newExtension(FilterListener listener, Value target,
Value arg) {
return new Extension(listener, (Val) target, (Val) arg);
}
public Value newAggregate(AggregateListener listener, Value arg) {
return new Aggregate(listener, (Val) arg);
}
public Arguments newArgumentList(Value val1, Value val2) {
return new Args(val1, val2);
}
public Arguments newArgumentList(Value... values) {
return new Args(values);
}
public Value newUnboundVariable(String name, Class type) {
UnboundVariable var = new UnboundVariable(type);
if (_unbounds == null)
_unbounds = new ArrayList<UnboundVariable>(3);
_unbounds.add(var);
return var;
}
public Value newBoundVariable(String name, Class type) {
return new BoundVariable(type);
}
public Value cast(Value val, Class cls) {
if (val instanceof CandidatePath)
((CandidatePath) val).castTo(cls);
else if (val instanceof BoundVariable)
((BoundVariable) val).castTo(cls);
else
val = new Cast((Val) val, cls);
return val;
}
public Value add(Value val1, Value val2) {
return new Add((Val) val1, (Val) val2);
}
public Value subtract(Value val1, Value val2) {
return new Subtract((Val) val1, (Val) val2);
}
public Value multiply(Value val1, Value val2) {
return new Multiply((Val) val1, (Val) val2);
}
public Value divide(Value val1, Value val2) {
return new Divide((Val) val1, (Val) val2);
}
public Value mod(Value val1, Value val2) {
return new Mod((Val) val1, (Val) val2);
}
public Value abs(Value val) {
return new Abs((Val) val);
}
public Value indexOf(Value val1, Value val2) {
return new IndexOf((Val) val1, (Val) val2);
}
public Value concat(Value val1, Value val2) {
return new Concat((Val) val1, (Val) val2);
}
public Value stringLength(Value str) {
return new StringLength((Val) str);
}
public Value trim(Value str, Value trimChar, Boolean where) {
return new Trim((Val) str, (Val) trimChar, where);
}
public Value sqrt(Value val) {
return new Sqrt((Val) val);
}
public Value substring(Value val1, Value val2) {
return new Substring((Val) val1, (Val) val2);
}
public Value toUpperCase(Value val) {
return new ToUpperCase((Val) val);
}
public Value toLowerCase(Value val) {
return new ToLowerCase((Val) val);
}
public Value avg(Value val) {
return new Avg((Val) val);
}
public Value count(Value val) {
return new Count((Val) val);
}
public Value distinct(Value val) {
return new Distinct((Val) val);
}
public Value max(Value val) {
return new Max((Val) val);
}
public Value min(Value val) {
return new Min((Val) val);
}
public Value sum(Value val) {
return new Sum((Val) val);
}
public Value any(Value val) {
return new Any((Val) val);
}
public Value all(Value val) {
return new All((Val) val);
}
public Value size(Value val) {
return new Size((Val) val);
}
public Value index(Value val) {
return new Index((Val) val);
}
public Value type(Value val) {
return new Type((Val) val);
}
public Value mapEntry(Value key, Value val) {
throw new UnsupportedException("not implemented yet");
}
public Value mapKey(Value key, Value val) {
throw new UnsupportedException("not implemented yet");
}
public Value getKey(Value val) {
throw new UnsupportedException("not implemented yet");
}
public Value getObjectId(Value val) {
return new GetObjectId((Val) val);
}
/**
* Key that implements hashCode and equals methods for object arrays.
*/
private static class ArrayKey {
private final Object[] _arr;
public ArrayKey(Object[] arr) {
_arr = arr;
}
public int hashCode() {
int rs = 17;
for (int i = 0; i < _arr.length; i++)
rs = 37 * rs + ((_arr[i] == null) ? 0 : _arr[i].hashCode());
return rs;
}
public boolean equals(Object other) {
if (other == this)
return true;
if (other == null)
return false;
Object[] arr = ((ArrayKey) other)._arr;
if (_arr.length != arr.length)
return false;
for (int i = 0; i < _arr.length; i++)
if (!ObjectUtils.equals(_arr[i], arr[i]))
return false;
return true;
}
}
/**
* Comparator that uses the result of eval'ing a Value to sort on. Null
* values are placed last if sorting in ascending order, first if
* descending.
*/
private static class OrderValueComparator
implements Comparator {
private final StoreContext _ctx;
private final Val _val;
private final boolean _asc;
private final int _idx;
private final Object[] _params;
private OrderValueComparator(Val val, boolean asc, int idx,
StoreContext ctx, Object[] params) {
_ctx = ctx;
_val = val;
_asc = asc;
_idx = idx;
_params = params;
}
public int compare(Object o1, Object o2) {
if (_idx != -1) {
o1 = ((Object[]) o1)[_idx];
o2 = ((Object[]) o2)[_idx];
} else {
o1 = _val.evaluate(o1, o1, _ctx, _params);
o2 = _val.evaluate(o2, o2, _ctx, _params);
}
if (o1 == null && o2 == null)
return 0;
if (o1 == null)
return (_asc) ? 1 : -1;
if (o2 == null)
return (_asc) ? -1 : 1;
if (o1 instanceof Boolean && o2 instanceof Boolean) {
int i1 = ((Boolean) o1).booleanValue() ? 1 : 0;
int i2 = ((Boolean) o2).booleanValue() ? 1 : 0;
return i1 - i2;
}
try {
if (_asc)
return ((Comparable) o1).compareTo(o2);
return ((Comparable) o2).compareTo(o1);
} catch (ClassCastException cce) {
Localizer loc = Localizer.forPackage
(InMemoryExpressionFactory.class);
throw new UserException(loc.get("not-comp", o1, o2));
}
}
}
public Value generalCaseExpression(Expression[] exp, Value val) {
Exp[] exps = new Exp[exp.length];
for (int i = 0; i < exp.length; i++)
exps[i] = (Exp) exp[i];
return new GeneralCase(exps, (Val) val);
}
public Value simpleCaseExpression(Value caseOperand, Expression[] exp,
Value val) {
Exp[] exps = new Exp[exp.length];
for (int i = 0; i < exp.length; i++)
exps[i] = (Exp) exp[i];
return new SimpleCase((Val) caseOperand, exps, (Val) val);
}
public Expression whenCondition(Expression exp, Value val) {
return new WhenCondition((Exp) exp, (Val) val);
}
public Expression whenScalar(Value val1, Value val2) {
return new WhenScalar((Val) val1, (Val) val2);
}
public Value coalesceExpression(Value[] val) {
Val[] vals = new Val[val.length];
for (int i = 0; i < val.length; i++)
vals[i] = (Val) val[i];
return new Coalesce(vals);
}
public Value nullIfExpression(Value val1, Value val2) {
return new NullIf((Val) val1, (Val) val2);
}
public Value newFunction(String functionName, Class<?> resultType, Value... args) {
throw new AbstractMethodError();
}
public boolean isVerticalType(Value val) {
return false;
}
}