@Override public double estimateRowCount(RelMetadataQuery mq) { return super.estimateRowCount(mq) * 0.1; }
public JavaImplementor(EnumerableRelImplementor enumImplementor) { super(enumImplementor.getRexBuilder(), new LinkedHashMap<String, Object>()); }
@Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) { return super.computeSelfCost(planner, mq).multiplyBy(.05); }
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), pref.preferArray()); return implementor.result(physType, Blocks.toBlock( Expressions.call(table.getExpression(FlowFileTable.class), "project", Expressions.constant(fields)))); }
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { final BlockBuilder builder = new BlockBuilder(); Expression unionExp = null; for (Ord<RelNode> ord : Ord.zip(inputs)) { EnumerableRel input = (EnumerableRel) ord.e; final Result result = implementor.visitChild(this, ord.i, input, pref); Expression childExp = builder.append( "child" + ord.i, result.block); if (unionExp == null) { unionExp = childExp; } else { unionExp = createUnionExpression(unionExp, childExp, result.format == JavaRowFormat.ARRAY); } } builder.add(unionExp); final PhysType physType = PhysTypeImpl.of( implementor.getTypeFactory(), getRowType(), pref.prefer(JavaRowFormat.CUSTOM)); return implementor.result(physType, builder.toBlock()); } }
new RexToLixTranslator.InputGetterImpl( ImmutableList.of( Pair.<Expression, PhysType>of( Expressions.field(context, BuiltInMethod.CONTEXT_VALUES.field), PhysTypeImpl.of(javaTypeFactory, inputRowType, JavaRowFormat.ARRAY, false)))); final Function1<String, RexToLixTranslator.InputGetter> correlates = Expressions.field(context, BuiltInMethod.CONTEXT_ROOT.field); final List<Expression> list = RexToLixTranslator.translateProjects(program, javaTypeFactory, builder, null, root, inputGetter, correlates); for (int i = 0; i < list.size(); i++) {
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { if (getInput() instanceof OLAPFilterRel) { // merge project & filter OLAPFilterRel filter = (OLAPFilterRel) getInput(); RelNode inputOfFilter = inputs.get(0).getInput(0); RexProgram program = RexProgram.create(inputOfFilter.getRowType(), this.rewriteProjects, filter.getCondition(), this.rowType, getCluster().getRexBuilder()); return new EnumerableCalc(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), // inputOfFilter, program); } else { // keep project for table scan EnumerableRel input = sole(inputs); RexProgram program = RexProgram.create(input.getRowType(), this.rewriteProjects, null, this.rowType, getCluster().getRexBuilder()); return new EnumerableCalc(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), // input, program); } }
Expression translate(RexNode expr, Type storageType) { final RexImpTable.NullAs nullAs = RexImpTable.NullAs.of(isNullable(expr)); return translate(expr, nullAs, storageType); }
private void defineMethod( SqlOperator operator, String functionName, NullPolicy nullPolicy) { defineImplementor( operator, nullPolicy, new MethodNameImplementor(functionName), false); }
@Override public EnumerableRel.Result visitChild(EnumerableRel parent, int ordinal, EnumerableRel child, EnumerableRel.Prefer prefer) { if (calciteDebug) { OLAPContext context; if (child instanceof OLAPRel) context = ((OLAPRel) child).getContext(); else context = relContexts.get(child); System.out.println(context + " - " + child); } return super.visitChild(parent, ordinal, child, prefer); } }
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { return EnumerableValues.create(getCluster(), getRowType(), getTuples()); } }
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { try { return new EnumerableAggregate(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), // sole(inputs), indicator, this.groupSet, this.groupSets, rewriteAggCalls); } catch (InvalidRelException e) { throw new IllegalStateException("Can't create EnumerableAggregate!", e); } }
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { return new EnumerableSort(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE).replace(collation), // sole(inputs), collation, offset, fetch); }
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { // keep it for having clause RexBuilder rexBuilder = getCluster().getRexBuilder(); RelDataType inputRowType = getInput().getRowType(); RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder); programBuilder.addIdentity(); programBuilder.addCondition(this.condition); RexProgram program = programBuilder.getProgram(); return new EnumerableCalc(getCluster(), getCluster().traitSetOf(EnumerableConvention.INSTANCE), // sole(inputs), program); }
@Override public RelWriter explainTerms(RelWriter pw) { return super.explainTerms(pw).item("ctx", context == null ? "" : String.valueOf(context.id) + "@" + context.realization); } }
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { for (EnumerableRel input : inputs) { if (input instanceof OLAPRel) { ((OLAPRel) input).replaceTraitSet(EnumerableConvention.INSTANCE); } } return EnumerableWindowBridge.createEnumerableWindow(getCluster(), traitSet, inputs.get(0), constants, rowType, groups); }
@Override public EnumerableRel implementEnumerable(List<EnumerableRel> inputs) { EnumerableRel input = sole(inputs); if (input instanceof OLAPRel) { ((OLAPRel) input).replaceTraitSet(EnumerableConvention.INSTANCE); } return EnumerableLimit.create(input, localOffset, localFetch); }
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { context.setReturnTupleInfo(rowType, columnRowType); PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), pref.preferArray()); RelOptTable factTable = context.firstTableScan.getTable(); MethodCallExpression exprCall = Expressions.call(factTable.getExpression(OLAPTable.class), "executeOLAPQuery", implementor.getRootExpression(), Expressions.constant(context.id)); return implementor.result(physType, Blocks.toBlock(exprCall)); }
Expression translate(RexNode expr) { final RexImpTable.NullAs nullAs = RexImpTable.NullAs.of(isNullable(expr)); return translate(expr, nullAs); }
@Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) { context.setReturnTupleInfo(rowType, columnRowType); String execFunction = genExecFunc(); PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), JavaRowFormat.ARRAY); MethodCallExpression exprCall = Expressions.call(table.getExpression(OLAPTable.class), execFunction, implementor.getRootExpression(), Expressions.constant(context.id)); return implementor.result(physType, Blocks.toBlock(exprCall)); }