import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
@Override
public RelNode convert(RelNode rel) {

	if (rel instanceof AggregateRel) {
		final AggregateRel agg = (AggregateRel) rel;
		final RelTraitSet traitSet = agg.getTraitSet().replace(
				EnumerableConvention.INSTANCE);
		try {
			return new GroupBy(rel.getCluster(), traitSet, convert(
					agg.getChild(), traitSet), agg.getGroupSet(),
					agg.getAggCallList(), accumuloAccessor);
		} catch (InvalidRelException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	} else
		return new EnumerableRelation(rel.getCluster(), rel.getTraitSet()
				.replace(getOutConvention()), rel);
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
@Override
public RelNode convert(RelNode rel) {
  final SortRel sort = (SortRel) rel;

  // do not handle other rules
  if (sort.offset == null && sort.fetch == null) {

    return sort;
  }

  final RelTraitSet traits = sort.getTraitSet().plus(EnumerableConvention.INSTANCE);

  RelNode input = sort.getChild();
  if (!sort.getCollation().getFieldCollations().isEmpty()) {
    input = sort.copy(sort.getTraitSet().replace(RelCollationImpl.EMPTY), input, RelCollationImpl.EMPTY, null, null);
  }

  final RelNode convertedInput = convert(input, input.getTraitSet().plus(EnumerableConvention.INSTANCE));

  return new EnumerableSort(sort.getCluster(), traits, convertedInput, sort.fetch, sort.offset, accumuloAccessor);
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public RelNode toRel(
        RelOptTable.ToRelContext context,
        RelOptTable relOptTable) {
    return new JavaRules.EnumerableTableAccessRel(
            context.getCluster(),
            context.getCluster().traitSetOf(EnumerableConvention.INSTANCE),
            relOptTable,
            getElementType());
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public RelNode toRel(
    RelOptTable.ToRelContext context,
    RelOptTable relOptTable) {
  return new JavaRules.EnumerableTableAccessRel(
      context.getCluster(),
      context.getCluster().traitSetOf(EnumerableConvention.INSTANCE),
      relOptTable,
      (Class) getElementType());
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    // keep it for having clause
    RexBuilder rexBuilder = getCluster().getRexBuilder();
    RelDataType inputRowType = getChild().getRowType();
    RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder);
    programBuilder.addIdentity();
    programBuilder.addCondition(this.condition);
    RexProgram program = programBuilder.getProgram();

    EnumerableCalcRel enumCalcRel = new EnumerableCalcRel(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), getChild(), this.rowType, program, ImmutableList.<RelCollation> of());

    return enumCalcRel.implement(implementor, pref);
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    OLAPRel childRel = (OLAPRel) getChild();
    childRel.replaceTraitSet(EnumerableConvention.INSTANCE);

    EnumerableLimitRel enumLimit = new EnumerableLimitRel(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), getChild(), localOffset, localFetch);
    Result res = enumLimit.implement(implementor, pref);

    childRel.replaceTraitSet(CONVENTION);

    return res;
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {

    EnumerableAggregateRel enumAggRel;
    try {
        enumAggRel = new EnumerableAggregateRel(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), getChild(), this.groupSet, rewriteAggCalls);
    } catch (InvalidRelException e) {
        throw new IllegalStateException("Can't create EnumerableAggregateRel!", e);
    }

    return enumAggRel.implement(implementor, pref);
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public GroupByRule(DataTable<?> resultTable) {
	// when see an aggregate who has a child operand
	// super(resultTable,some(AggregateRel.class, Convention.NONE,
	// any(RelNode.class)));
	super(AggregateRel.class, Convention.NONE,
			EnumerableConvention.INSTANCE, "EnumerableAggregateRulsdfse");
	this.accumuloAccessor = resultTable;
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public RelNode toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
    return new JavaRules.EnumerableTableAccessRel(context.getCluster(),
        context.getCluster().traitSetOf(EnumerableConvention.INSTANCE),
        relOptTable, (Class) getElementType());
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public OLAPToEnumerableConverterRule() {
    super(RelNode.class, OLAPRel.CONVENTION, EnumerableConvention.INSTANCE, "OLAPToEnumerableConverterRule");
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public FieldPacker(TableScanner scanner) {
  super(CalcRel.class, Convention.NONE, EnumerableConvention.INSTANCE, "FieldPacker");
  this.scanner = scanner;
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
public RelNode convert(RelNode rel) {

    final CalcRel calc = (CalcRel) rel;

    final RexProgram program = calc.getProgram();

    RelDataType rowType = program.getOutputRowType();

    scanner.setFields(rowType.getFieldNames());

    if (RexMultisetUtil.containsMultiset(program) || program.containsAggs()) {
      return null;
    }

    return new FieldPackerRelation(rel.getCluster(), rel.getTraitSet().replace(EnumerableConvention.INSTANCE), convert(calc.getChild(), calc.getChild()
        .getTraitSet().replace(EnumerableConvention.INSTANCE)), program, ProjectRelBase.Flags.Boxed);
  }
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
@Override
public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    OLAPRel childRel = (OLAPRel) getChild();
    childRel.replaceTraitSet(EnumerableConvention.INSTANCE);

    EnumerableSortRel enumSort = new EnumerableSortRel(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE, collation), getChild(), collation, offset, fetch);

    Result res = enumSort.implement(implementor, pref);

    childRel.replaceTraitSet(OLAPRel.CONVENTION);

    return res;
}
 

import net.hydromatic.optiq.rules.java.EnumerableConvention; //导入依赖的package包/类
private EnumerableExpression() {
  super(RelNode.class, CosmosRelNode.CONVENTION, EnumerableConvention.INSTANCE, "EnumerableRule");
  
}