Examples with SubqueryAnalyzer io.crate.analyze.expressions.SubqueryAnalyzer used on opensource projects

Example 6 with SubqueryAnalyzer

use of io.crate.analyze.expressions.SubqueryAnalyzer in project crate by crate.

the class RelationAnalyzer method visitValues.

@Override
public AnalyzedRelation visitValues(Values values, StatementAnalysisContext context) {
    var expressionAnalyzer = new ExpressionAnalyzer(context.transactionContext(), nodeCtx, context.paramTyeHints(), FieldProvider.UNSUPPORTED, new SubqueryAnalyzer(this, context));
    var expressionAnalysisContext = new ExpressionAnalysisContext(context.sessionContext());
    // prevent normalization of the values array, otherwise the value literals are converted to an array literal
    // and a special per-value-literal casting logic won't be executed (e.g. FloatLiteral.cast())
    expressionAnalysisContext.allowEagerNormalize(false);
    java.util.function.Function<Expression, Symbol> expressionToSymbol = e -> expressionAnalyzer.convert(e, expressionAnalysisContext);
    // There is a first pass to convert expressions from row oriented format:
    // `[[1, a], [2, b]]` to columns `[[1, 2], [a, b]]`
    // 
    // At the same time we determine the column type with the highest precedence,
    // so that we don't fail with slight type miss-matches (long vs. int)
    List<ValuesList> rows = values.rows();
    assert rows.size() > 0 : "Parser grammar enforces at least 1 row";
    ValuesList firstRow = rows.get(0);
    int numColumns = firstRow.values().size();
    ArrayList<List<Symbol>> columns = new ArrayList<>();
    ArrayList<DataType<?>> targetTypes = new ArrayList<>(numColumns);
    var parentOutputColumns = context.parentOutputColumns();
    for (int c = 0; c < numColumns; c++) {
        ArrayList<Symbol> columnValues = new ArrayList<>();
        DataType<?> targetType;
        boolean usePrecedence = true;
        if (parentOutputColumns.size() > c) {
            targetType = parentOutputColumns.get(c).valueType();
            usePrecedence = false;
        } else {
            targetType = DataTypes.UNDEFINED;
        }
        for (int r = 0; r < rows.size(); r++) {
            List<Expression> row = rows.get(r).values();
            if (row.size() != numColumns) {
                throw new IllegalArgumentException("VALUES lists must all be the same length. " + "Found row with " + numColumns + " items and another with " + columns.size() + " items");
            }
            Symbol cell = expressionToSymbol.apply(row.get(c));
            columnValues.add(cell);
            var cellType = cell.valueType();
            if (// skip first cell, we don't have to check for self-conversion
            r > 0 && !cellType.isConvertableTo(targetType, false) && targetType.id() != DataTypes.UNDEFINED.id()) {
                throw new IllegalArgumentException("The types of the columns within VALUES lists must match. " + "Found `" + targetType + "` and `" + cellType + "` at position: " + c);
            }
            if (usePrecedence && cellType.precedes(targetType)) {
                targetType = cellType;
            } else if (targetType == DataTypes.UNDEFINED) {
                targetType = cellType;
            }
        }
        targetTypes.add(targetType);
        columns.add(columnValues);
    }
    var normalizer = EvaluatingNormalizer.functionOnlyNormalizer(nodeCtx, f -> f.isDeterministic());
    ArrayList<Symbol> arrays = new ArrayList<>(columns.size());
    for (int c = 0; c < numColumns; c++) {
        DataType<?> targetType = targetTypes.get(c);
        ArrayType<?> arrayType = new ArrayType<>(targetType);
        List<Symbol> columnValues = Lists2.map(columns.get(c), s -> normalizer.normalize(s.cast(targetType), context.transactionContext()));
        arrays.add(new Function(ArrayFunction.SIGNATURE, columnValues, arrayType));
    }
    FunctionImplementation implementation = nodeCtx.functions().getQualified(ValuesFunction.SIGNATURE, Symbols.typeView(arrays), RowType.EMPTY);
    Function function = new Function(implementation.signature(), arrays, RowType.EMPTY);
    TableFunctionImplementation<?> tableFunc = TableFunctionFactory.from(implementation);
    TableFunctionRelation relation = new TableFunctionRelation(tableFunc, function);
    context.startRelation();
    context.currentRelationContext().addSourceRelation(relation);
    context.endRelation();
    return relation;
}

Example 7 with SubqueryAnalyzer

use of io.crate.analyze.expressions.SubqueryAnalyzer in project crate by crate.

the class UpdateAnalyzer method analyze.

public AnalyzedUpdateStatement analyze(Update update, ParamTypeHints typeHints, CoordinatorTxnCtx txnCtx) {
    /* UPDATE t1 SET col1 = ?, col2 = ? WHERE id = ?`
         *               ^^^^^^^^^^^^^^^^^^       ^^^^^^
         *               assignments               whereClause
         *
         *               col1 = ?
         *               |      |
         *               |     source
         *             columnName/target
         */
    StatementAnalysisContext stmtCtx = new StatementAnalysisContext(typeHints, Operation.UPDATE, txnCtx);
    final RelationAnalysisContext relCtx = stmtCtx.startRelation();
    AnalyzedRelation relation = relationAnalyzer.analyze(update.relation(), stmtCtx);
    stmtCtx.endRelation();
    MaybeAliasedStatement maybeAliasedStatement = MaybeAliasedStatement.analyze(relation);
    relation = maybeAliasedStatement.nonAliasedRelation();
    if (!(relation instanceof AbstractTableRelation)) {
        throw new UnsupportedOperationException("UPDATE is only supported on base-tables");
    }
    AbstractTableRelation<?> table = (AbstractTableRelation<?>) relation;
    EvaluatingNormalizer normalizer = new EvaluatingNormalizer(nodeCtx, RowGranularity.CLUSTER, null, table);
    SubqueryAnalyzer subqueryAnalyzer = new SubqueryAnalyzer(relationAnalyzer, new StatementAnalysisContext(typeHints, Operation.READ, txnCtx));
    ExpressionAnalyzer sourceExprAnalyzer = new ExpressionAnalyzer(txnCtx, nodeCtx, typeHints, new FullQualifiedNameFieldProvider(relCtx.sources(), relCtx.parentSources(), txnCtx.sessionContext().searchPath().currentSchema()), subqueryAnalyzer);
    ExpressionAnalysisContext exprCtx = new ExpressionAnalysisContext(txnCtx.sessionContext());
    Map<Reference, Symbol> assignmentByTargetCol = getAssignments(update.assignments(), typeHints, txnCtx, table, normalizer, subqueryAnalyzer, sourceExprAnalyzer, exprCtx);
    Symbol query = Objects.requireNonNullElse(sourceExprAnalyzer.generateQuerySymbol(update.whereClause(), exprCtx), Literal.BOOLEAN_TRUE);
    query = maybeAliasedStatement.maybeMapFields(query);
    Symbol normalizedQuery = normalizer.normalize(query, txnCtx);
    SelectAnalysis selectAnalysis = SelectAnalyzer.analyzeSelectItems(update.returningClause(), relCtx.sources(), sourceExprAnalyzer, exprCtx);
    List<Symbol> outputSymbol = Lists2.map(selectAnalysis.outputSymbols(), x -> normalizer.normalize(x, txnCtx));
    return new AnalyzedUpdateStatement(table, assignmentByTargetCol, normalizedQuery, outputSymbol.isEmpty() ? null : outputSymbol);
}