Java Expressions類代碼示例

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    if (!(implementor instanceof JavaImplementor))
        throw new IllegalStateException("implementor is not JavaImplementor");
    JavaImplementor javaImplementor = (JavaImplementor) implementor;

    int ctxId = this.context.id;
    if (javaImplementor.getParentContext() != null) {
        ctxId = javaImplementor.getParentContext().id;
    }

    PhysType physType = PhysTypeImpl.of(javaImplementor.getTypeFactory(), this.rowType, pref.preferArray());

    String execFunction = genExecFunc();

    return javaImplementor.result(physType, Blocks.toBlock(Expressions.call(table.getExpression(OLAPTable.class), execFunction, javaImplementor.getRootExpression(), Expressions.constant(ctxId))));
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    Result result = null;
    if (this.hasSubQuery) {
        result = super.implement(implementor, pref);
    } else {
        PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), pref.preferArray());

        RelOptTable factTable = context.firstTableScan.getTable();
        result = implementor.result(physType, Blocks.toBlock(Expressions.call(factTable.getExpression(OLAPTable.class), "executeIndexQuery", implementor.getRootExpression(), Expressions.constant(context.id))));
    }

    return result;
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
private Result buildHiveResult(EnumerableRelImplementor enumImplementor, Prefer pref, OLAPContext context) {
    RelDataType hiveRowType = getRowType();

    context.olapRowType = hiveRowType;
    PhysType physType = PhysTypeImpl.of(enumImplementor.getTypeFactory(), hiveRowType, pref.preferArray());

    RelOptTable factTable = context.firstTableScan.getTable();
    Result result = enumImplementor.result(physType, Blocks.toBlock(Expressions.call(factTable.getExpression(OLAPTable.class), "executeHiveQuery", enumImplementor.getRootExpression())));
    return result;
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
/**
 * Projects each element of a sequence into a new form.
 */
public static <T, TResult> Queryable<TResult> select(Queryable<T> source,
    FunctionExpression<Function1<T, TResult>> selector) {
  return source.getProvider().createQuery(
      Expressions.call(source.getExpression(), "select", selector),
      functionResultType(selector));
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
@Override
public Expression getExpression() {
	return Expressions.convert_(Expressions.call(schema.getExpression(),
			"getTable", Expressions.constant(tableName),
			Expressions.constant(getElementType())), DataTable.class);

}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
/**
 * Bypasses elements in a sequence as long as a
 * specified condition is true and then returns the remaining
 * elements.
 */
public static <T> Queryable<T> skipWhile(Queryable<T> source,
    FunctionExpression<Predicate1<T>> predicate) {
  return skipWhileN(source, Expressions.lambda(
      Functions.<T, Integer>toPredicate2(predicate.getFunction())));
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
/**
 * Returns elements from a sequence as long as a
 * specified condition is true.
 */
public static <T> Queryable<T> takeWhile(Queryable<T> source,
    FunctionExpression<Predicate1<T>> predicate) {
  return takeWhileN(source, Expressions.lambda(
      Functions.<T, Integer>toPredicate2(predicate.getFunction())));
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
@Override
public Expression apply(String a0) {
  return Expressions.constant(a0);
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  
  final BlockBuilder list = new BlockBuilder();
  
  selectQuery = new CosmosRelNode.Plan();
  
  selectQuery.visitChild(getChild());
  
  final Expression table = list.append("table", selectQuery.table.getExpression());
  
  selectQuery.table.enqueue(selectQuery);
  
  final PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getReturnType(), pref.prefer(JavaRowFormat.CUSTOM));
  
  final List<String> fieldNameList = getRowType().getFieldNames();
  
  Expression accumuloResults = list.append(
      "enumerable",
      Expressions.call(table, "accumulate",
          Expressions.call(Arrays.class, "asList", Expressions.newArrayInit(String.class, Functions.apply(fieldNameList, TO_LITERAL)))));
  
  list.add(Expressions.return_(null, accumuloResults));
  
  return implementor.result(physType, list.toBlock());
  
}
 

import net.hydromatic.linq4j.expressions.Expressions; //導入依賴的package包/類
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
  
  final JavaTypeFactory typeFactory = implementor.getTypeFactory();
  final BlockBuilder builder = new BlockBuilder();
  final EnumerableRel child = (EnumerableRel) getChild();
  
  Plan aggregatePlan = new Plan();
  
  List<String> fieldName = child.getRowType().getFieldNames();
  
  for (int i = 0; i < getGroupCount(); i++) {
    if (getGroupSet().get(i)) {
      aggregatePlan.add("groupBy", new Field(fieldName.get(i)));
    }
  }
  
  accumuloAccessor.groupBy(aggregatePlan);
  
  final Result result = implementor.visitChild(this, 0, child, pref);
  
  Expression childExp = builder.append("child", result.block);
  
  final PhysType physType = PhysTypeImpl.of(typeFactory, getRowType(), pref.preferCustom());
  
  builder.add(Expressions.return_(null, childExp));
  
  return implementor.result(physType, builder.toBlock());
}