/**
   * 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);
  }
  /**
   * 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);
  }