import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
private void checkSql(String sql, String model, Function1<ResultSet, Void> fn)
    throws SQLException {
  Connection connection = null;
  Statement statement = null;
  try {
    Properties info = new Properties();
    info.put("model", "target/test-classes/" + model + ".json");
    connection = DriverManager.getConnection("jdbc:optiq:", info);
    statement = connection.createStatement();
    final ResultSet resultSet =
        statement.executeQuery(
            sql);
    fn.apply(resultSet);
  } finally {
    close(connection, statement);
  }
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
private void checkSql(String sql, String model, Function1<ResultSet, Void> fn)
  throws SQLException {
  Connection connection = null;
  Statement statement = null;
  try {
    Properties info = new Properties();
    info.put("model", "target/test-classes/" + model + ".json");
    connection = DriverManager.getConnection("jdbc:optiq:", info);
    statement = connection.createStatement();
    final ResultSet resultSet =
        statement.executeQuery(
            sql);
    fn.apply(resultSet);
  } finally {
    close(connection, statement);
  }
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
private void checkSql(String model, String sql, final String expected)
  throws SQLException {
  checkSql(sql, model, new Function1<ResultSet, Void>() {
    public Void apply(ResultSet resultSet) {
      try {
        String actual = SQLTest.toString(resultSet);
        if (!expected.equals(actual)) {
              System.out.println("Assertion failure:");
              System.out.println("\tExpected: '" + expected + "'");
              System.out.println("\tActual: '" + actual + "'");
        }
        assertTrue(expected.equals(actual));
      } catch (SQLException e) {
        throw new RuntimeException(e);
      }
      return null;
    }
  });
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
public void accept(ExpressionWriter writer) {
  String modifiers = Modifier.toString(modifier);
  writer.append(modifiers);
  if (!modifiers.isEmpty()) {
    writer.append(' ');
  }
  writer
      .append(resultType)
      .append(' ')
      .append(name)
      .list("(", ", ", ")",
          Functions.adapt(parameters,
              new Function1<ParameterExpression, String>() {
                public String apply(ParameterExpression a0) {
                  return a0.declString();
                }
              }))
      .append(' ')
      .append(body);
  writer.newlineAndIndent();
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
@Test public void testCompile() throws NoSuchMethodException {
  // Creating a parameter for the expression tree.
  ParameterExpression param = Expressions.parameter(String.class);

  // Creating an expression for the method call and specifying its
  // parameter.
  MethodCallExpression methodCall =
      Expressions.call(
          Integer.class,
          "valueOf",
          Collections.<Expression>singletonList(param));

  // The following statement first creates an expression tree,
  // then compiles it, and then runs it.
  int x =
      Expressions.<Function1<String, Integer>>lambda(
          methodCall,
          new ParameterExpression[] { param })
          .getFunction()
          .apply("1234");
  assertEquals(1234, x);
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
public StratosphereSqlProjectionMapOperator(Function1<DataContext, Object[]> function,
		Set<StratosphereRexUtils.ProjectionFieldProperties> fields, String sourceCode) {
	this.function = function;
	this.fields = fields;
	for(StratosphereRexUtils.ProjectionFieldProperties f: fields) {
		if(f.trivialProjection) {
			continue;
		}
		isTrivial = false;
		break;
	}
	if(!isTrivial) {
		String newSrc = "public class "+RexExecutable.GENERATED_CLASS_NAME+" "
				+ "implements net.hydromatic.linq4j.function.Function1, java.io.Serializable { "+sourceCode+" }";
		try {
			map.put(RexExecutable.GENERATED_CLASS_NAME+".java", newSrc.getBytes("UTF-8"));
		} catch (UnsupportedEncodingException e) {
			throw new RuntimeException("Error while encoding the generated source", e);
		}
	}

}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
private void checkSql(String sql, String model, Function1<ResultSet, Void> fn)
  throws SQLException {
  Connection connection = null;
  Statement statement = null;
  try {
    Properties info = new Properties();
    info.put("model", "target/test-classes/" + model + ".json");
    connection = DriverManager.getConnection("jdbc:calcite:", info);
    statement = connection.createStatement();
    final ResultSet resultSet =
        statement.executeQuery(
            sql);
    fn.apply(resultSet);
  } finally {
    close(connection, statement);
  }
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
private Function1<ResultSet, Void> output() {
  return new Function1<ResultSet, Void>() {
    public Void apply(ResultSet resultSet) {
      try {
        output(resultSet, System.out);
      } catch (SQLException e) {
        throw new RuntimeException(e);
      }
      return null;
    }
  };
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/** Returns a function that checks the contents of a result set against an
 * expected string. */
private static Function1<ResultSet, Void> expect(final String... expected) {
  return new Function1<ResultSet, Void>() {
    public Void apply(ResultSet resultSet) {
      try {
        final List<String> lines = new ArrayList<String>();
        CsvTest.collect(lines, resultSet);
        Assert.assertEquals(Arrays.asList(expected), lines);
      } catch (SQLException e) {
        throw new RuntimeException(e);
      }
      return null;
    }
  };
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
private void readObject(java.io.ObjectInputStream stream)
		throws IOException, ClassNotFoundException {
	stream.defaultReadObject();
	if(!isTrivial) {
		// initialize generated code.
		ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader();
		ResourceFinder srcFinder = new MapResourceFinder(map);
		JavaSourceClassLoader janinoClassLoader = new JavaSourceClassLoader(currentClassLoader, srcFinder, "UTF-8");
		Thread.currentThread().setContextClassLoader(janinoClassLoader);
		Class<Function1> gen = (Class<Function1>) Class.forName(RexExecutable.GENERATED_CLASS_NAME, true, janinoClassLoader);
		function = InstantiationUtil.instantiate(gen, Function1.class);
	}
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
public void prepareEvaluation() {
	try {
		this.function =  (Function1<DataContext, Object[]>) ClassBodyEvaluator.createFastClassBodyEvaluator(
			new Scanner(null, new StringReader(source)),
			RexExecutable.GENERATED_CLASS_NAME,
			Utilities.class,
			new Class[]{Function1.class , Serializable.class},
			getClass().getClassLoader());
	} catch (Exception e) {
		throw new RuntimeException("Error while compiling the generated code");
	}
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/** Returns a lambda that converts a list to an enumerable. */
public static <E> Function1<List<E>, Enumerable<E>> listToEnumerable() {
    //noinspection unchecked
    return (Function1<List<E>, Enumerable<E>>) (Function1) LIST_AS_ENUMERABLE;
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Creates optimizer with no parent.
 */
private ClassDeclarationFinder(
    Function1<ClassDeclarationFinder, ClassDeclarationFinder> childFactory) {
  this.parent = null;
  this.childFactory = childFactory;
}
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Performs a subsequent ordering of the elements in a sequence in
 * ascending order according to a key.
 */
<TKey extends Comparable<TKey>> OrderedQueryable<T> thenBy(
    FunctionExpression<Function1<T, TKey>> keySelector);
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Performs a subsequent ordering of the elements in a sequence in
 * descending order according to a key.
 */
<TKey extends Comparable<TKey>> OrderedQueryable<T> thenByDescending(
    FunctionExpression<Function1<T, TKey>> keySelector);
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Performs a subsequent ordering of the elements in an
 * {@link OrderedEnumerable} according to a key, using a specified
 * comparator.
 *
 * <p>The functionality provided by this method is like that provided by
 * {@link #thenBy(net.hydromatic.linq4j.function.Function1, java.util.Comparator) thenBy}
 * or {@link #thenByDescending(net.hydromatic.linq4j.function.Function1, java.util.Comparator) thenByDescending},
 * depending on whether descending is true or false. They both perform a
 * subordinate ordering of an already sorted sequence of type
 * {@link OrderedEnumerable}.</p>
 */
<TKey> OrderedEnumerable<T> createOrderedEnumerable(
    Function1<T, TKey> keySelector, Comparator<TKey> comparator,
    boolean descending);
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Performs a subsequent ordering of the elements in a sequence in
 * ascending order according to a key.
 */
<TKey extends Comparable<TKey>> OrderedEnumerable<T> thenBy(
    Function1<T, TKey> keySelector);
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Performs a subsequent ordering of the elements in a sequence in
 * descending order according to a key.
 */
<TKey extends Comparable<TKey>> OrderedEnumerable<T> thenByDescending(
    Function1<T, TKey> keySelector);
 

import net.hydromatic.linq4j.function.Function1; //导入依赖的package包/类
/**
 * Creates visitor that uses given factory to create optimizers.
 *
 * @param childFactory factory that creates optimizers
 * @return optimizing visitor
 */
public static ClassDeclarationFinder create(
    Function1<ClassDeclarationFinder, ClassDeclarationFinder> childFactory) {
  return new ClassDeclarationFinder(childFactory);
}