Examples with SqlNodeList org.apache.calcite.sql.SqlNodeList used on opensource projects

Example 16 with SqlNodeList

use of org.apache.calcite.sql.SqlNodeList in project calcite by apache.

the class SqlValidatorImpl method expandStar.

public SqlNodeList expandStar(SqlNodeList selectList, SqlSelect select, boolean includeSystemVars) {
    final List<SqlNode> list = new ArrayList<>();
    final List<Map.Entry<String, RelDataType>> types = new ArrayList<>();
    for (int i = 0; i < selectList.size(); i++) {
        final SqlNode selectItem = selectList.get(i);
        final RelDataType originalType = getValidatedNodeTypeIfKnown(selectItem);
        expandSelectItem(selectItem, select, Util.first(originalType, unknownType), list, catalogReader.nameMatcher().isCaseSensitive() ? new LinkedHashSet<String>() : new TreeSet<>(String.CASE_INSENSITIVE_ORDER), types, includeSystemVars);
    }
    getRawSelectScope(select).setExpandedSelectList(list);
    return new SqlNodeList(list, SqlParserPos.ZERO);
}

Example 17 with SqlNodeList

use of org.apache.calcite.sql.SqlNodeList in project calcite by apache.

the class SqlValidatorImpl method validateWindowClause.

protected void validateWindowClause(SqlSelect select) {
    final SqlNodeList windowList = select.getWindowList();
    @SuppressWarnings("unchecked") final List<SqlWindow> windows = (List) windowList.getList();
    if (windows.isEmpty()) {
        return;
    }
    final SelectScope windowScope = (SelectScope) getFromScope(select);
    assert windowScope != null;
    // 2. ensure they are unique within this scope
    for (SqlWindow window : windows) {
        SqlIdentifier declName = window.getDeclName();
        if (!declName.isSimple()) {
            throw newValidationError(declName, RESOURCE.windowNameMustBeSimple());
        }
        if (windowScope.existingWindowName(declName.toString())) {
            throw newValidationError(declName, RESOURCE.duplicateWindowName());
        } else {
            windowScope.addWindowName(declName.toString());
        }
    }
    // Check for pairs of windows which are equivalent.
    for (int i = 0; i < windows.size(); i++) {
        SqlNode window1 = windows.get(i);
        for (int j = i + 1; j < windows.size(); j++) {
            SqlNode window2 = windows.get(j);
            if (window1.equalsDeep(window2, Litmus.IGNORE)) {
                throw newValidationError(window2, RESOURCE.dupWindowSpec());
            }
        }
    }
    for (SqlWindow window : windows) {
        final SqlNodeList expandedOrderList = (SqlNodeList) expand(window.getOrderList(), windowScope);
        window.setOrderList(expandedOrderList);
        expandedOrderList.validate(this, windowScope);
        final SqlNodeList expandedPartitionList = (SqlNodeList) expand(window.getPartitionList(), windowScope);
        window.setPartitionList(expandedPartitionList);
        expandedPartitionList.validate(this, windowScope);
    }
    // Hand off to validate window spec components
    windowList.validate(this, windowScope);
}

Example 18 with SqlNodeList

use of org.apache.calcite.sql.SqlNodeList in project calcite by apache.

the class SqlValidatorImpl method inferUnknownTypes.

protected void inferUnknownTypes(RelDataType inferredType, SqlValidatorScope scope, SqlNode node) {
    final SqlValidatorScope newScope = scopes.get(node);
    if (newScope != null) {
        scope = newScope;
    }
    boolean isNullLiteral = SqlUtil.isNullLiteral(node, false);
    if ((node instanceof SqlDynamicParam) || isNullLiteral) {
        if (inferredType.equals(unknownType)) {
            if (isNullLiteral) {
                throw newValidationError(node, RESOURCE.nullIllegal());
            } else {
                throw newValidationError(node, RESOURCE.dynamicParamIllegal());
            }
        }
        // REVIEW:  should dynamic parameter types always be nullable?
        RelDataType newInferredType = typeFactory.createTypeWithNullability(inferredType, true);
        if (SqlTypeUtil.inCharFamily(inferredType)) {
            newInferredType = typeFactory.createTypeWithCharsetAndCollation(newInferredType, inferredType.getCharset(), inferredType.getCollation());
        }
        setValidatedNodeType(node, newInferredType);
    } else if (node instanceof SqlNodeList) {
        SqlNodeList nodeList = (SqlNodeList) node;
        if (inferredType.isStruct()) {
            if (inferredType.getFieldCount() != nodeList.size()) {
                // bust out, and the error will be detected higher up
                return;
            }
        }
        int i = 0;
        for (SqlNode child : nodeList) {
            RelDataType type;
            if (inferredType.isStruct()) {
                type = inferredType.getFieldList().get(i).getType();
                ++i;
            } else {
                type = inferredType;
            }
            inferUnknownTypes(type, scope, child);
        }
    } else if (node instanceof SqlCase) {
        final SqlCase caseCall = (SqlCase) node;
        final RelDataType whenType = caseCall.getValueOperand() == null ? booleanType : unknownType;
        for (SqlNode sqlNode : caseCall.getWhenOperands().getList()) {
            inferUnknownTypes(whenType, scope, sqlNode);
        }
        RelDataType returnType = deriveType(scope, node);
        for (SqlNode sqlNode : caseCall.getThenOperands().getList()) {
            inferUnknownTypes(returnType, scope, sqlNode);
        }
        if (!SqlUtil.isNullLiteral(caseCall.getElseOperand(), false)) {
            inferUnknownTypes(returnType, scope, caseCall.getElseOperand());
        } else {
            setValidatedNodeType(caseCall.getElseOperand(), returnType);
        }
    } else if (node instanceof SqlCall) {
        final SqlCall call = (SqlCall) node;
        final SqlOperandTypeInference operandTypeInference = call.getOperator().getOperandTypeInference();
        final SqlCallBinding callBinding = new SqlCallBinding(this, scope, call);
        final List<SqlNode> operands = callBinding.operands();
        final RelDataType[] operandTypes = new RelDataType[operands.size()];
        if (operandTypeInference == null) {
            // TODO:  eventually should assert(operandTypeInference != null)
            // instead; for now just eat it
            Arrays.fill(operandTypes, unknownType);
        } else {
            operandTypeInference.inferOperandTypes(callBinding, inferredType, operandTypes);
        }
        for (int i = 0; i < operands.size(); ++i) {
            inferUnknownTypes(operandTypes[i], scope, operands.get(i));
        }
    }
}

Example 19 with SqlNodeList

use of org.apache.calcite.sql.SqlNodeList in project calcite by apache.

the class SqlValidatorImpl method validateGroupItem.

private void validateGroupItem(SqlValidatorScope groupScope, AggregatingSelectScope aggregatingScope, SqlNode groupItem) {
    switch(groupItem.getKind()) {
        case GROUPING_SETS:
        case ROLLUP:
        case CUBE:
            validateGroupingSets(groupScope, aggregatingScope, (SqlCall) groupItem);
            break;
        default:
            if (groupItem instanceof SqlNodeList) {
                break;
            }
            final RelDataType type = deriveType(groupScope, groupItem);
            setValidatedNodeType(groupItem, type);
    }
}

Example 20 with SqlNodeList

use of org.apache.calcite.sql.SqlNodeList in project calcite by apache.

the class SqlToRelConverter method convertAgg.

/**
 * Converts the SELECT, GROUP BY and HAVING clauses of an aggregate query.
 *
 * <p>This method extracts SELECT, GROUP BY and HAVING clauses, and creates
 * an {@link AggConverter}, then delegates to {@link #createAggImpl}.
 * Derived class may override this method to change any of those clauses or
 * specify a different {@link AggConverter}.
 *
 * @param bb            Scope within which to resolve identifiers
 * @param select        Query
 * @param orderExprList Additional expressions needed to implement ORDER BY
 */
protected void convertAgg(Blackboard bb, SqlSelect select, List<SqlNode> orderExprList) {
    assert bb.root != null : "precondition: child != null";
    SqlNodeList groupList = select.getGroup();
    SqlNodeList selectList = select.getSelectList();
    SqlNode having = select.getHaving();
    final AggConverter aggConverter = new AggConverter(bb, select);
    createAggImpl(bb, aggConverter, selectList, groupList, having, orderExprList);
}