Search in sources :

Example 51 with BlockBuilder

use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.linq4j.tree.BlockBuilder in project calcite by apache.

the class CassandraToEnumerableConverter method implement.

public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    // Generates a call to "query" with the appropriate fields and predicates
    final BlockBuilder list = new BlockBuilder();
    final CassandraRel.Implementor cassandraImplementor = new CassandraRel.Implementor();
    cassandraImplementor.visitChild(0, getInput());
    final RelDataType rowType = getRowType();
    final PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), rowType, pref.prefer(JavaRowFormat.ARRAY));
    final Expression fields = list.append("fields", constantArrayList(Pair.zip(CassandraRules.cassandraFieldNames(rowType), new AbstractList<Class>() {

        @Override
        public Class get(int index) {
            return physType.fieldClass(index);
        }

        @Override
        public int size() {
            return rowType.getFieldCount();
        }
    }), Pair.class));
    List<Map.Entry<String, String>> selectList = new ArrayList<Map.Entry<String, String>>();
    for (Map.Entry<String, String> entry : Pair.zip(cassandraImplementor.selectFields.keySet(), cassandraImplementor.selectFields.values())) {
        selectList.add(entry);
    }
    final Expression selectFields = list.append("selectFields", constantArrayList(selectList, Pair.class));
    final Expression table = list.append("table", cassandraImplementor.table.getExpression(CassandraTable.CassandraQueryable.class));
    final Expression predicates = list.append("predicates", constantArrayList(cassandraImplementor.whereClause, String.class));
    final Expression order = list.append("order", constantArrayList(cassandraImplementor.order, String.class));
    final Expression offset = list.append("offset", Expressions.constant(cassandraImplementor.offset));
    final Expression fetch = list.append("fetch", Expressions.constant(cassandraImplementor.fetch));
    Expression enumerable = list.append("enumerable", Expressions.call(table, CassandraMethod.CASSANDRA_QUERYABLE_QUERY.method, fields, selectFields, predicates, order, offset, fetch));
    if (CalcitePrepareImpl.DEBUG) {
        System.out.println("Cassandra: " + predicates);
    }
    Hook.QUERY_PLAN.run(predicates);
    list.add(Expressions.return_(null, enumerable));
    return implementor.result(physType, list.toBlock());
}
Also used : EnumerableRelImplementor(org.apache.calcite.adapter.enumerable.EnumerableRelImplementor) ArrayList(java.util.ArrayList) RelDataType(org.apache.calcite.rel.type.RelDataType) PhysType(org.apache.calcite.adapter.enumerable.PhysType) Expression(org.apache.calcite.linq4j.tree.Expression) MethodCallExpression(org.apache.calcite.linq4j.tree.MethodCallExpression) Map(java.util.Map) BlockBuilder(org.apache.calcite.linq4j.tree.BlockBuilder) Pair(org.apache.calcite.util.Pair)

Example 52 with BlockBuilder

use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.linq4j.tree.BlockBuilder in project calcite by apache.

the class ElasticsearchToEnumerableConverter method implement.

@Override
public Result implement(EnumerableRelImplementor implementor, Prefer prefer) {
    final BlockBuilder list = new BlockBuilder();
    final ElasticsearchRel.Implementor elasticsearchImplementor = new ElasticsearchRel.Implementor();
    elasticsearchImplementor.visitChild(0, getInput());
    final RelDataType rowType = getRowType();
    final PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), rowType, prefer.prefer(JavaRowFormat.ARRAY));
    final Expression fields = list.append("fields", constantArrayList(Pair.zip(ElasticsearchRules.elasticsearchFieldNames(rowType), new AbstractList<Class>() {

        @Override
        public Class get(int index) {
            return physType.fieldClass(index);
        }

        @Override
        public int size() {
            return rowType.getFieldCount();
        }
    }), Pair.class));
    final Expression table = list.append("table", elasticsearchImplementor.table.getExpression(AbstractElasticsearchTable.ElasticsearchQueryable.class));
    List<String> opList = elasticsearchImplementor.list;
    final Expression ops = list.append("ops", constantArrayList(opList, String.class));
    Expression enumerable = list.append("enumerable", Expressions.call(table, ElasticsearchMethod.ELASTICSEARCH_QUERYABLE_FIND.method, ops, fields));
    if (CalcitePrepareImpl.DEBUG) {
        System.out.println("Elasticsearch: " + opList);
    }
    Hook.QUERY_PLAN.run(opList);
    list.add(Expressions.return_(null, enumerable));
    return implementor.result(physType, list.toBlock());
}
Also used : EnumerableRelImplementor(org.apache.calcite.adapter.enumerable.EnumerableRelImplementor) RelDataType(org.apache.calcite.rel.type.RelDataType) PhysType(org.apache.calcite.adapter.enumerable.PhysType) Expression(org.apache.calcite.linq4j.tree.Expression) MethodCallExpression(org.apache.calcite.linq4j.tree.MethodCallExpression) BlockBuilder(org.apache.calcite.linq4j.tree.BlockBuilder) Pair(org.apache.calcite.util.Pair)

Example 53 with BlockBuilder

use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.linq4j.tree.BlockBuilder in project calcite by apache.

the class StrictAggImplementor method implementAdd.

public final void implementAdd(AggContext info, final AggAddContext add) {
    final List<RexNode> args = add.rexArguments();
    final RexToLixTranslator translator = add.rowTranslator();
    final List<Expression> conditions = new ArrayList<>();
    conditions.addAll(translator.translateList(args, RexImpTable.NullAs.IS_NOT_NULL));
    if (add.rexFilterArgument() != null) {
        conditions.add(translator.translate(add.rexFilterArgument(), RexImpTable.NullAs.FALSE));
    }
    Expression condition = Expressions.foldAnd(conditions);
    if (Expressions.constant(false).equals(condition)) {
        return;
    }
    boolean argsNotNull = Expressions.constant(true).equals(condition);
    final BlockBuilder thenBlock = argsNotNull ? add.currentBlock() : new BlockBuilder(true, add.currentBlock());
    if (trackNullsPerRow) {
        List<Expression> acc = add.accumulator();
        thenBlock.add(Expressions.statement(Expressions.assign(acc.get(acc.size() - 1), Expressions.constant(true))));
    }
    if (argsNotNull) {
        implementNotNullAdd(info, add);
        return;
    }
    final Map<RexNode, Boolean> nullables = new HashMap<>();
    for (RexNode arg : args) {
        if (translator.isNullable(arg)) {
            nullables.put(arg, false);
        }
    }
    add.nestBlock(thenBlock, nullables);
    implementNotNullAdd(info, add);
    add.exitBlock();
    add.currentBlock().add(Expressions.ifThen(condition, thenBlock.toBlock()));
}
Also used : Expression(org.apache.calcite.linq4j.tree.Expression) ParameterExpression(org.apache.calcite.linq4j.tree.ParameterExpression) HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) RexNode(org.apache.calcite.rex.RexNode) BlockBuilder(org.apache.calcite.linq4j.tree.BlockBuilder)

Example 54 with BlockBuilder

use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.linq4j.tree.BlockBuilder in project calcite by apache.

the class StrictAggImplementor method implementNotNullReset.

protected void implementNotNullReset(AggContext info, AggResetContext reset) {
    BlockBuilder block = reset.currentBlock();
    List<Expression> accumulator = reset.accumulator();
    for (int i = 0; i < getStateSize(); i++) {
        Expression exp = accumulator.get(i);
        block.add(Expressions.statement(Expressions.assign(exp, RexImpTable.getDefaultValue(exp.getType()))));
    }
}
Also used : Expression(org.apache.calcite.linq4j.tree.Expression) ParameterExpression(org.apache.calcite.linq4j.tree.ParameterExpression) BlockBuilder(org.apache.calcite.linq4j.tree.BlockBuilder)

Example 55 with BlockBuilder

use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.linq4j.tree.BlockBuilder in project calcite by apache.

the class EnumerableWindow method implement.

public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
    final JavaTypeFactory typeFactory = implementor.getTypeFactory();
    final EnumerableRel child = (EnumerableRel) getInput();
    final BlockBuilder builder = new BlockBuilder();
    final Result result = implementor.visitChild(this, 0, child, pref);
    Expression source_ = builder.append("source", result.block);
    final List<Expression> translatedConstants = new ArrayList<Expression>(constants.size());
    for (RexLiteral constant : constants) {
        translatedConstants.add(RexToLixTranslator.translateLiteral(constant, constant.getType(), typeFactory, RexImpTable.NullAs.NULL));
    }
    PhysType inputPhysType = result.physType;
    final int w = implementor.windowCount++;
    ParameterExpression prevStart = Expressions.parameter(int.class, builder.newName("prevStart" + w));
    ParameterExpression prevEnd = Expressions.parameter(int.class, builder.newName("prevEnd" + w));
    builder.add(Expressions.declare(0, prevStart, null));
    builder.add(Expressions.declare(0, prevEnd, null));
    for (int windowIdx = 0; windowIdx < groups.size(); windowIdx++) {
        Group group = groups.get(windowIdx);
        // Comparator:
        // final Comparator<JdbcTest.Employee> comparator =
        // new Comparator<JdbcTest.Employee>() {
        // public int compare(JdbcTest.Employee o1,
        // JdbcTest.Employee o2) {
        // return Integer.compare(o1.empid, o2.empid);
        // }
        // };
        final Expression comparator_ = builder.append("comparator", inputPhysType.generateComparator(group.collation()));
        Pair<Expression, Expression> partitionIterator = getPartitionIterator(builder, source_, inputPhysType, group, comparator_);
        final Expression collectionExpr = partitionIterator.left;
        final Expression iterator_ = partitionIterator.right;
        List<AggImpState> aggs = new ArrayList<AggImpState>();
        List<AggregateCall> aggregateCalls = group.getAggregateCalls(this);
        for (int aggIdx = 0; aggIdx < aggregateCalls.size(); aggIdx++) {
            AggregateCall call = aggregateCalls.get(aggIdx);
            aggs.add(new AggImpState(aggIdx, call, true));
        }
        // The output from this stage is the input plus the aggregate functions.
        final RelDataTypeFactory.Builder typeBuilder = typeFactory.builder();
        typeBuilder.addAll(inputPhysType.getRowType().getFieldList());
        for (AggImpState agg : aggs) {
            typeBuilder.add(agg.call.name, agg.call.type);
        }
        RelDataType outputRowType = typeBuilder.build();
        final PhysType outputPhysType = PhysTypeImpl.of(typeFactory, outputRowType, pref.prefer(result.format));
        final Expression list_ = builder.append("list", Expressions.new_(ArrayList.class, Expressions.call(collectionExpr, BuiltInMethod.COLLECTION_SIZE.method)), false);
        Pair<Expression, Expression> collationKey = getRowCollationKey(builder, inputPhysType, group, windowIdx);
        Expression keySelector = collationKey.left;
        Expression keyComparator = collationKey.right;
        final BlockBuilder builder3 = new BlockBuilder();
        final Expression rows_ = builder3.append("rows", Expressions.convert_(Expressions.call(iterator_, BuiltInMethod.ITERATOR_NEXT.method), Object[].class), false);
        builder3.add(Expressions.statement(Expressions.assign(prevStart, Expressions.constant(-1))));
        builder3.add(Expressions.statement(Expressions.assign(prevEnd, Expressions.constant(Integer.MAX_VALUE))));
        final BlockBuilder builder4 = new BlockBuilder();
        final ParameterExpression i_ = Expressions.parameter(int.class, builder4.newName("i"));
        final Expression row_ = builder4.append("row", RexToLixTranslator.convert(Expressions.arrayIndex(rows_, i_), inputPhysType.getJavaRowType()));
        final RexToLixTranslator.InputGetter inputGetter = new WindowRelInputGetter(row_, inputPhysType, result.physType.getRowType().getFieldCount(), translatedConstants);
        final RexToLixTranslator translator = RexToLixTranslator.forAggregation(typeFactory, builder4, inputGetter);
        final List<Expression> outputRow = new ArrayList<Expression>();
        int fieldCountWithAggResults = inputPhysType.getRowType().getFieldCount();
        for (int i = 0; i < fieldCountWithAggResults; i++) {
            outputRow.add(inputPhysType.fieldReference(row_, i, outputPhysType.getJavaFieldType(i)));
        }
        declareAndResetState(typeFactory, builder, result, windowIdx, aggs, outputPhysType, outputRow);
        // There are assumptions that minX==0. If ever change this, look for
        // frameRowCount, bounds checking, etc
        final Expression minX = Expressions.constant(0);
        final Expression partitionRowCount = builder3.append("partRows", Expressions.field(rows_, "length"));
        final Expression maxX = builder3.append("maxX", Expressions.subtract(partitionRowCount, Expressions.constant(1)));
        final Expression startUnchecked = builder4.append("start", translateBound(translator, i_, row_, minX, maxX, rows_, group, true, inputPhysType, comparator_, keySelector, keyComparator));
        final Expression endUnchecked = builder4.append("end", translateBound(translator, i_, row_, minX, maxX, rows_, group, false, inputPhysType, comparator_, keySelector, keyComparator));
        final Expression startX;
        final Expression endX;
        final Expression hasRows;
        if (group.isAlwaysNonEmpty()) {
            startX = startUnchecked;
            endX = endUnchecked;
            hasRows = Expressions.constant(true);
        } else {
            Expression startTmp = group.lowerBound.isUnbounded() || startUnchecked == i_ ? startUnchecked : builder4.append("startTmp", Expressions.call(null, BuiltInMethod.MATH_MAX.method, startUnchecked, minX));
            Expression endTmp = group.upperBound.isUnbounded() || endUnchecked == i_ ? endUnchecked : builder4.append("endTmp", Expressions.call(null, BuiltInMethod.MATH_MIN.method, endUnchecked, maxX));
            ParameterExpression startPe = Expressions.parameter(0, int.class, builder4.newName("startChecked"));
            ParameterExpression endPe = Expressions.parameter(0, int.class, builder4.newName("endChecked"));
            builder4.add(Expressions.declare(Modifier.FINAL, startPe, null));
            builder4.add(Expressions.declare(Modifier.FINAL, endPe, null));
            hasRows = builder4.append("hasRows", Expressions.lessThanOrEqual(startTmp, endTmp));
            builder4.add(Expressions.ifThenElse(hasRows, Expressions.block(Expressions.statement(Expressions.assign(startPe, startTmp)), Expressions.statement(Expressions.assign(endPe, endTmp))), Expressions.block(Expressions.statement(Expressions.assign(startPe, Expressions.constant(-1))), Expressions.statement(Expressions.assign(endPe, Expressions.constant(-1))))));
            startX = startPe;
            endX = endPe;
        }
        final BlockBuilder builder5 = new BlockBuilder(true, builder4);
        BinaryExpression rowCountWhenNonEmpty = Expressions.add(startX == minX ? endX : Expressions.subtract(endX, startX), Expressions.constant(1));
        final Expression frameRowCount;
        if (hasRows.equals(Expressions.constant(true))) {
            frameRowCount = builder4.append("totalRows", rowCountWhenNonEmpty);
        } else {
            frameRowCount = builder4.append("totalRows", Expressions.condition(hasRows, rowCountWhenNonEmpty, Expressions.constant(0)));
        }
        ParameterExpression actualStart = Expressions.parameter(0, int.class, builder5.newName("actualStart"));
        final BlockBuilder builder6 = new BlockBuilder(true, builder5);
        builder6.add(Expressions.statement(Expressions.assign(actualStart, startX)));
        for (final AggImpState agg : aggs) {
            agg.implementor.implementReset(agg.context, new WinAggResetContextImpl(builder6, agg.state, i_, startX, endX, hasRows, partitionRowCount, frameRowCount));
        }
        Expression lowerBoundCanChange = group.lowerBound.isUnbounded() && group.lowerBound.isPreceding() ? Expressions.constant(false) : Expressions.notEqual(startX, prevStart);
        Expression needRecomputeWindow = Expressions.orElse(lowerBoundCanChange, Expressions.lessThan(endX, prevEnd));
        BlockStatement resetWindowState = builder6.toBlock();
        if (resetWindowState.statements.size() == 1) {
            builder5.add(Expressions.declare(0, actualStart, Expressions.condition(needRecomputeWindow, startX, Expressions.add(prevEnd, Expressions.constant(1)))));
        } else {
            builder5.add(Expressions.declare(0, actualStart, null));
            builder5.add(Expressions.ifThenElse(needRecomputeWindow, resetWindowState, Expressions.statement(Expressions.assign(actualStart, Expressions.add(prevEnd, Expressions.constant(1))))));
        }
        if (lowerBoundCanChange instanceof BinaryExpression) {
            builder5.add(Expressions.statement(Expressions.assign(prevStart, startX)));
        }
        builder5.add(Expressions.statement(Expressions.assign(prevEnd, endX)));
        final BlockBuilder builder7 = new BlockBuilder(true, builder5);
        final DeclarationStatement jDecl = Expressions.declare(0, "j", actualStart);
        final PhysType inputPhysTypeFinal = inputPhysType;
        final Function<BlockBuilder, WinAggFrameResultContext> resultContextBuilder = getBlockBuilderWinAggFrameResultContextFunction(typeFactory, result, translatedConstants, comparator_, rows_, i_, startX, endX, minX, maxX, hasRows, frameRowCount, partitionRowCount, jDecl, inputPhysTypeFinal);
        final Function<AggImpState, List<RexNode>> rexArguments = new Function<AggImpState, List<RexNode>>() {

            public List<RexNode> apply(AggImpState agg) {
                List<Integer> argList = agg.call.getArgList();
                List<RelDataType> inputTypes = EnumUtils.fieldRowTypes(result.physType.getRowType(), constants, argList);
                List<RexNode> args = new ArrayList<RexNode>(inputTypes.size());
                for (int i = 0; i < argList.size(); i++) {
                    Integer idx = argList.get(i);
                    args.add(new RexInputRef(idx, inputTypes.get(i)));
                }
                return args;
            }
        };
        implementAdd(aggs, builder7, resultContextBuilder, rexArguments, jDecl);
        BlockStatement forBlock = builder7.toBlock();
        if (!forBlock.statements.isEmpty()) {
            // For instance, row_number does not use for loop to compute the value
            Statement forAggLoop = Expressions.for_(Arrays.asList(jDecl), Expressions.lessThanOrEqual(jDecl.parameter, endX), Expressions.preIncrementAssign(jDecl.parameter), forBlock);
            if (!hasRows.equals(Expressions.constant(true))) {
                forAggLoop = Expressions.ifThen(hasRows, forAggLoop);
            }
            builder5.add(forAggLoop);
        }
        if (implementResult(aggs, builder5, resultContextBuilder, rexArguments, true)) {
            builder4.add(Expressions.ifThen(Expressions.orElse(lowerBoundCanChange, Expressions.notEqual(endX, prevEnd)), builder5.toBlock()));
        }
        implementResult(aggs, builder4, resultContextBuilder, rexArguments, false);
        builder4.add(Expressions.statement(Expressions.call(list_, BuiltInMethod.COLLECTION_ADD.method, outputPhysType.record(outputRow))));
        builder3.add(Expressions.for_(Expressions.declare(0, i_, Expressions.constant(0)), Expressions.lessThan(i_, Expressions.field(rows_, "length")), Expressions.preIncrementAssign(i_), builder4.toBlock()));
        builder.add(Expressions.while_(Expressions.call(iterator_, BuiltInMethod.ITERATOR_HAS_NEXT.method), builder3.toBlock()));
        builder.add(Expressions.statement(Expressions.call(collectionExpr, BuiltInMethod.MAP_CLEAR.method)));
        // We're not assigning to "source". For each group, create a new
        // final variable called "source" or "sourceN".
        source_ = builder.append("source", Expressions.call(BuiltInMethod.AS_ENUMERABLE.method, list_));
        inputPhysType = outputPhysType;
    }
    // return Linq4j.asEnumerable(list);
    builder.add(Expressions.return_(null, source_));
    return implementor.result(inputPhysType, builder.toBlock());
}
Also used : WinAggResetContextImpl(org.apache.calcite.adapter.enumerable.impl.WinAggResetContextImpl) RexLiteral(org.apache.calcite.rex.RexLiteral) ArrayList(java.util.ArrayList) RelDataType(org.apache.calcite.rel.type.RelDataType) BlockStatement(org.apache.calcite.linq4j.tree.BlockStatement) Function(com.google.common.base.Function) SqlAggFunction(org.apache.calcite.sql.SqlAggFunction) BinaryExpression(org.apache.calcite.linq4j.tree.BinaryExpression) JavaTypeFactory(org.apache.calcite.adapter.java.JavaTypeFactory) RelDataTypeFactory(org.apache.calcite.rel.type.RelDataTypeFactory) ArrayList(java.util.ArrayList) ImmutableList(com.google.common.collect.ImmutableList) List(java.util.List) BlockBuilder(org.apache.calcite.linq4j.tree.BlockBuilder) DeclarationStatement(org.apache.calcite.linq4j.tree.DeclarationStatement) Statement(org.apache.calcite.linq4j.tree.Statement) DeclarationStatement(org.apache.calcite.linq4j.tree.DeclarationStatement) BlockStatement(org.apache.calcite.linq4j.tree.BlockStatement) AggregateCall(org.apache.calcite.rel.core.AggregateCall) BinaryExpression(org.apache.calcite.linq4j.tree.BinaryExpression) Expression(org.apache.calcite.linq4j.tree.Expression) ParameterExpression(org.apache.calcite.linq4j.tree.ParameterExpression) ParameterExpression(org.apache.calcite.linq4j.tree.ParameterExpression) RexInputRef(org.apache.calcite.rex.RexInputRef) RexNode(org.apache.calcite.rex.RexNode)

Aggregations

BlockBuilder (org.apache.calcite.linq4j.tree.BlockBuilder)67 Expression (org.apache.calcite.linq4j.tree.Expression)56 ParameterExpression (org.apache.calcite.linq4j.tree.ParameterExpression)40 RelDataType (org.apache.calcite.rel.type.RelDataType)15 PhysType (org.apache.calcite.adapter.enumerable.PhysType)14 ArrayList (java.util.ArrayList)12 MethodCallExpression (org.apache.calcite.linq4j.tree.MethodCallExpression)12 Test (org.junit.Test)10 BlockStatement (org.apache.calcite.linq4j.tree.BlockStatement)9 Type (java.lang.reflect.Type)8 JavaTypeFactory (org.apache.calcite.adapter.java.JavaTypeFactory)8 MemberDeclaration (org.apache.calcite.linq4j.tree.MemberDeclaration)7 RexToLixTranslator (org.apache.calcite.adapter.enumerable.RexToLixTranslator)6 NewExpression (org.apache.calcite.linq4j.tree.NewExpression)6 JavaTypeFactoryImpl (org.apache.calcite.jdbc.JavaTypeFactoryImpl)5 BinaryExpression (org.apache.calcite.linq4j.tree.BinaryExpression)5 FunctionExpression (org.apache.calcite.linq4j.tree.FunctionExpression)5 RexNode (org.apache.calcite.rex.RexNode)5 EnumerableRelImplementor (org.apache.calcite.adapter.enumerable.EnumerableRelImplementor)4 Function1 (org.apache.calcite.linq4j.function.Function1)4