/** * Create an Evaluator for the given query sources and projection * * @param <T> * @param metadata query metadata * @param sources sources of the query * @param projection projection of the query * @return evaluator */ public <T> Evaluator<T> create( QueryMetadata metadata, List<? extends Expression<?>> sources, Expression<T> projection) { final CollQuerySerializer serializer = new CollQuerySerializer(templates); serializer.append("return "); if (projection instanceof FactoryExpression<?>) { serializer.append("("); serializer.append(ClassUtils.getName(projection.getType())); serializer.append(")("); serializer.handle(projection); serializer.append(")"); } else { serializer.handle(projection); } serializer.append(";"); Map<Object, String> constantToLabel = serializer.getConstantToLabel(); Map<String, Object> constants = getConstants(metadata, constantToLabel); Class<?>[] types = new Class<?>[sources.size()]; String[] names = new String[sources.size()]; for (int i = 0; i < sources.size(); i++) { types[i] = sources.get(i).getType(); names[i] = sources.get(i).toString(); } // normalize types for (int i = 0; i < types.length; i++) { if (Primitives.isWrapperType(types[i])) { types[i] = Primitives.unwrap(types[i]); } } return factory.createEvaluator( serializer.toString(), projection.getType(), names, types, constants); }
/** * Create an Evaluator for the given source and filter * * @param <T> * @param source source of the query * @param filter filter of the query * @return evaluator */ @SuppressWarnings("unchecked") public <T> Evaluator<List<T>> createEvaluator( QueryMetadata metadata, Expression<? extends T> source, Predicate filter) { String typeName = ClassUtils.getName(source.getType()); CollQuerySerializer ser = new CollQuerySerializer(templates); ser.append( "java.util.List<" + typeName + "> rv = new java.util.ArrayList<" + typeName + ">();\n"); ser.append("for (" + typeName + " " + source + " : " + source + "_) {\n"); ser.append(" try {\n"); ser.append(" if (").handle(filter).append(") {\n"); ser.append(" rv.add(" + source + ");\n"); ser.append(" }\n"); ser.append(" } catch (NullPointerException npe) { }\n"); ser.append("}\n"); ser.append("return rv;"); Map<Object, String> constantToLabel = ser.getConstantToLabel(); Map<String, Object> constants = getConstants(metadata, constantToLabel); Type sourceType = new ClassType(TypeCategory.SIMPLE, source.getType()); ClassType sourceListType = new ClassType(TypeCategory.SIMPLE, Iterable.class, sourceType); return factory.createEvaluator( ser.toString(), sourceListType, new String[] {source + "_"}, new Type[] {sourceListType}, new Class[] {Iterable.class}, constants); }
/** * Create an Evaluator for the given sources and the given optional filter * * @param metadata query metadata * @param joins joins * @param filter where condition * @return evaluator */ @SuppressWarnings("unchecked") public Evaluator<List<Object[]>> createEvaluator( QueryMetadata metadata, List<JoinExpression> joins, @Nullable Predicate filter) { List<String> sourceNames = new ArrayList<String>(); List<Type> sourceTypes = new ArrayList<Type>(); List<Class<?>> sourceClasses = new ArrayList<Class<?>>(); StringBuilder vars = new StringBuilder(); CollQuerySerializer ser = new CollQuerySerializer(templates); ser.append("java.util.List<Object[]> rv = new java.util.ArrayList<Object[]>();\n"); List<String> anyJoinMatchers = new ArrayList<String>(); // creating context for (JoinExpression join : joins) { Expression<?> target = join.getTarget(); String typeName = com.mysema.codegen.support.ClassUtils.getName(target.getType()); if (vars.length() > 0) { vars.append(","); } switch (join.getType()) { case DEFAULT: ser.append("for (" + typeName + " " + target + " : " + target + "_) {\n"); vars.append(target); sourceNames.add(target + "_"); sourceTypes.add( new SimpleType(Types.ITERABLE, new ClassType(TypeCategory.SIMPLE, target.getType()))); sourceClasses.add(Iterable.class); break; case INNERJOIN: case LEFTJOIN: Operation<?> alias = (Operation<?>) join.getTarget(); boolean colAnyJoin = join.getCondition() != null && join.getCondition().toString().equals("any"); boolean leftJoin = join.getType() == JoinType.LEFTJOIN; String matcher = null; if (colAnyJoin) { matcher = alias.getArg(1).toString() + "_matched"; ser.append("boolean " + matcher + " = false;\n"); anyJoinMatchers.add(matcher); } ser.append("for (" + typeName + " " + alias.getArg(1) + " : "); if (leftJoin) { ser.append(CollQueryFunctions.class.getName() + ".leftJoin("); } if (colAnyJoin) { Context context = new Context(); Expression<?> replacement = alias.getArg(0).accept(collectionAnyVisitor, context); ser.handle(replacement); } else { ser.handle(alias.getArg(0)); } if (alias.getArg(0).getType().equals(Map.class)) { ser.append(".values()"); } if (leftJoin) { ser.append(")"); } ser.append(") {\n"); if (matcher != null) { ser.append("if (!" + matcher + ") {\n"); } vars.append(alias.getArg(1)); break; default: throw new IllegalArgumentException("Illegal join expression " + join); } } // filter if (filter != null) { ser.append("try {\n"); ser.append("if ("); ser.handle(filter).append(") {\n"); for (String matcher : anyJoinMatchers) { ser.append(" " + matcher + " = true;\n"); } ser.append(" rv.add(new Object[]{" + vars + "});\n"); ser.append("}\n"); ser.append("} catch (NullPointerException npe) { }\n"); } else { ser.append("rv.add(new Object[]{" + vars + "});\n"); } // closing context int amount = joins.size() + anyJoinMatchers.size(); for (int i = 0; i < amount; i++) { ser.append("}\n"); } ser.append("return rv;"); Map<Object, String> constantToLabel = ser.getConstantToLabel(); Map<String, Object> constants = getConstants(metadata, constantToLabel); ClassType projectionType = new ClassType(TypeCategory.LIST, List.class, Types.OBJECTS); return factory.createEvaluator( ser.toString(), projectionType, sourceNames.toArray(new String[sourceNames.size()]), sourceTypes.toArray(new Type[sourceTypes.size()]), sourceClasses.toArray(new Class[sourceClasses.size()]), constants); }