RelNode leftRel = inputRels[0]; RelNode rightRel = inputRels[1]; RexBuilder rexBuilder = leftRel.getCluster().getRexBuilder(); RexNode outJoinCond = null; int origLeftInputSize = leftRel.getRowType().getFieldCount(); int origRightInputSize = rightRel.getRowType().getFieldCount(); final RelDataTypeField field = leftRel.getRowType().getFieldList().get(i); newLeftFields.add(rexBuilder.makeInputRef(field.getType(), i)); newLeftFieldNames.add(field.getName()); final RelDataTypeField field = rightRel.getRowType().getFieldList().get(i); newRightFields.add(rexBuilder.makeInputRef(field.getType(), i)); newRightFieldNames.add(field.getName()); SqlValidatorUtil.uniquify(newLeftFieldNames)); rightRel = factory.createProject(rightRel, newRightFields, SqlValidatorUtil.uniquify(newRightFieldNames));
List<RexNode> inputRefs = Lists.transform(inputRel.getRowType().getFieldList(), input -> new RexInputRef(input.getIndex(), input.getType())); List<String> outputFieldNames = new ArrayList<>(inputRel.getRowType().getFieldNames()); RexCall convertedOriginalValuesExpr = (RexCall) new RexNodeConverter(this.cluster, inputRel.getRowType(), inputPosMap, 0, false).convert(valuesExpr); RelDataType valuesRowType = ((ArraySqlType) convertedOriginalValuesExpr.getType()).getComponentType(); rexBuilder.makeCall(convertedOriginalValuesExpr.op, newStructExprs); RelDataType retType = SqlValidatorUtil.deriveJoinRowType(inputRel.getRowType(), valuesRowType, JoinRelType.INNER, dtFactory, null, ImmutableList.of()); SqlOperator calciteOp = SqlFunctionConverter.getCalciteOperator( inlineFunctionName, inlineFunctionInfo.getGenericUDTF(), ImmutableList.copyOf(inputRefsTypes), retType); ImmutableList.of(inputRel), rexBuilder.makeCall(calciteOp, convertedFinalValuesExpr), null, retType, null); columnAliases.size() != valuesRowType.getFieldCount()) {
public void validateWithItem(SqlWithItem withItem) { if (withItem.columnList != null) { final RelDataType rowType = getValidatedNodeType(withItem.query); final int fieldCount = rowType.getFieldCount(); if (withItem.columnList.size() != fieldCount) { throw newValidationError(withItem.columnList, RESOURCE.columnCountMismatch()); } SqlValidatorUtil.checkIdentifierListForDuplicates( withItem.columnList.getList(), validationErrorFunction); } else { // Luckily, field names have not been make unique yet. final List<String> fieldNames = getValidatedNodeType(withItem.query).getFieldNames(); final int i = Util.firstDuplicate(fieldNames); if (i >= 0) { throw newValidationError(withItem.query, RESOURCE.duplicateColumnAndNoColumnList(fieldNames.get(i))); } } }
/** * Adds an expression to a select list, ensuring that its alias does not * clash with any existing expressions on the list. */ protected void addToSelectList( List<SqlNode> list, Set<String> aliases, List<Map.Entry<String, RelDataType>> fieldList, SqlNode exp, SqlValidatorScope scope, final boolean includeSystemVars) { String alias = SqlValidatorUtil.getAlias(exp, -1); String uniqueAlias = SqlValidatorUtil.uniquify( alias, aliases, SqlValidatorUtil.EXPR_SUGGESTER); if (!alias.equals(uniqueAlias)) { exp = SqlValidatorUtil.addAlias(exp, uniqueAlias); } fieldList.add(Pair.of(uniqueAlias, deriveType(scope, exp))); list.add(exp); }
SqlValidatorUtil.checkIdentifierListForDuplicates( identifierList, validator.getValidationErrorFunction()); final ImmutableList.Builder<RelDataTypeField> builder = ImmutableList.builder(); builder.addAll(this.extendedFields); builder.addAll( SqlValidatorUtil.getExtendedColumns(validator.getTypeFactory(), getTable(), extendList)); final List<RelDataTypeField> extendedFields = builder.build(); final SqlValidatorTable validatorTable = relOptTable.unwrap(SqlValidatorTable.class); return new TableNamespace(validator, validatorTable, ImmutableList.of());
@Override protected RelDataType deriveRowType() { switch (joinType) { case LEFT: case INNER: return SqlValidatorUtil.deriveJoinRowType(left.getRowType(), right.getRowType(), joinType.toJoinType(), getCluster().getTypeFactory(), null, ImmutableList.of()); case ANTI: case SEMI: return left.getRowType(); default: throw new IllegalStateException("Unknown join type " + joinType); } }
new SqlValidatorScope.ResolvedImpl(); final SqlNameMatcher nameMatcher = catalogReader.nameMatcher(); scope.resolve(ImmutableList.of(name), nameMatcher, false, resolved); if (resolved.count() == 1) { ns = resolved.only().namespace; for (RelDataTypeField field : rowType.getFieldList()) { hintList.add( new SqlMonikerImpl( field.getName(), SqlMonikerType.COLUMN)); SqlValidatorUtil.getEnclosingSelectScope(scope); if ((selectScope != null) && (selectScope.getChildren().size() == 1)) { RelDataType rowType = selectScope.getChildren().get(0).getRowType(); for (RelDataTypeField field : rowType.getFieldList()) { hintList.add( new SqlMonikerImpl( field.getName(), SqlMonikerType.COLUMN));
preExprs = ImmutableList.of(Pair.of(zero, (String) null)); int converted = 0; final int groupCount = aggregate.getGroupSet().cardinality(); for (RelDataTypeField field : aggregate.getRowType().getFieldList()) { final int i = field.getIndex(); final RexNode rex; if (i < groupCount && r.isNullable(i)) { rexBuilder.makeCast( typeFactory.createTypeWithNullability( field.getType(), true), rexBuilder.constantNull()), rexBuilder.makeInputRef(aggregate, i)); rex = rexBuilder.makeInputRef(aggregate, i); projects2.add(Pair.of(rex, field.getName())); SqlValidatorUtil.getEnclosingSelectScope(bb.scope); assert selectScope != null; final SqlValidatorNamespace selectNamespace = validator.getNamespace(selectScope.getNode()); final List<String> names = selectNamespace.getRowType().getFieldNames(); int sysFieldCount = selectList.size() - names.size(); for (SqlNode expr : selectList) {
preExprs = ImmutableList.of(Pair.of(zero, (String) null)); SqlValidatorUtil.getEnclosingSelectScope(bb.scope); assert selectScope != null; final SqlValidatorNamespace selectNamespace = validator.getNamespace(selectScope.getNode()); final List<String> names = selectNamespace.getRowType().getFieldNames(); int sysFieldCount = selectList.size() - names.size(); for (SqlNode expr : selectList) {
final TableNamespace tableNamespace = namespace.unwrap(TableNamespace.class); return getRelOptTable(tableNamespace, catalogReader, datasetName, usedDataset, tableNamespace.extendedFields); } else if (namespace.isWrapperFor(SqlValidatorImpl.DmlNamespace.class)) { final RelDataTypeFactory typeFactory = catalogReader.getTypeFactory(); final List<RelDataTypeField> extendedFields = dmlNamespace.extendList == null ? ImmutableList.of() : getExtendedColumns(typeFactory, validatorTable, dmlNamespace.extendList); return getRelOptTable( tableNamespace, catalogReader, datasetName, usedDataset, extendedFields);
for (int i = 0; i < nodes.size(); i++) { Node node = nodes.get(i); if (i == 0) { assert node.parent == null; } else { assert nodes.subList(0, i).contains(node.parent); ImmutableList.copyOf( SqlValidatorUtil.uniquify( Lists.transform(columns, input -> input.alias), true)); if (rowCountEstimate == null) {
private RelNode convertUpdate(SqlUpdate call) { final SqlValidatorScope scope = validator.getWhereScope(call.getSourceSelect()); Blackboard bb = createBlackboard(scope, null, false); Builder<RexNode> rexNodeSourceExpressionListBuilder = ImmutableList.builder(); for (SqlNode n : call.getSourceExpressionList()) { RexNode rn = bb.convertExpression(n); rexNodeSourceExpressionListBuilder.add(rn); } RelOptTable targetTable = getTargetTable(call); // convert update column list from SqlIdentifier to String final List<String> targetColumnNameList = new ArrayList<>(); final RelDataType targetRowType = targetTable.getRowType(); for (SqlNode node : call.getTargetColumnList()) { SqlIdentifier id = (SqlIdentifier) node; RelDataTypeField field = SqlValidatorUtil.getTargetField( targetRowType, typeFactory, id, catalogReader, targetTable); assert field != null : "column " + id.toString() + " not found"; targetColumnNameList.add(field.getName()); } RelNode sourceRel = convertSelect(call.getSourceSelect(), false); return LogicalTableModify.create(targetTable, catalogReader, sourceRel, LogicalTableModify.Operation.UPDATE, targetColumnNameList, rexNodeSourceExpressionListBuilder.build(), false); }
/** Returns the set of field names in the join condition specified by USING * or implicitly by NATURAL, de-duplicated and in order. */ private List<String> usingNames(SqlJoin join) { switch (join.getConditionType()) { case USING: final ImmutableList.Builder<String> list = ImmutableList.builder(); final Set<String> names = catalogReader.nameMatcher().createSet(); for (SqlNode node : (SqlNodeList) join.getCondition()) { final String name = ((SqlIdentifier) node).getSimple(); if (names.add(name)) { list.add(name); } } return list.build(); case NONE: if (join.isNatural()) { final RelDataType t0 = getValidatedNodeType(join.getLeft()); final RelDataType t1 = getValidatedNodeType(join.getRight()); return SqlValidatorUtil.deriveNaturalJoinColumnList( catalogReader.nameMatcher(), t0, t1); } } return null; }
final RelDataType targetRowType = typeFactory.createStructType( tableRowType.getFieldList() .subList(0, sourceRef.getType().getFieldCount())); targetColumnNames.addAll(targetRowType.getFieldNames()); } else { targetColumnNames.addAll(tableRowType.getFieldNames()); SqlIdentifier id = (SqlIdentifier) targetColumnList.get(i); RelDataTypeField field = SqlValidatorUtil.getTargetField( tableRowType, typeFactory, id, catalogReader, targetTable); assert field != null : "column " + id.toString() + " not found"; targetColumnNames.add(field.getName());
return baseRowType; List<RelDataTypeField> targetFields = baseRowType.getFieldList(); final List<Map.Entry<String, RelDataType>> fields = new ArrayList<>(); if (append) { fields.add( Pair.of(SqlUtil.deriveAliasFromOrdinal(fields.size()), targetField.getType())); SqlIdentifier id = (SqlIdentifier) node; RelDataTypeField targetField = SqlValidatorUtil.getTargetField( baseRowType, typeFactory, id, catalogReader, relOptTable); if (targetField == null) { throw newValidationError(id, RESOURCE.unknownTargetColumn(id.toString())); if (!assignedFields.add(targetField.getIndex())) { throw newValidationError(id, RESOURCE.duplicateTargetColumn(targetField.getName()));
SqlIdentifier id = (SqlIdentifier) targetColumn; RelDataTypeField field = SqlValidatorUtil.getTargetField( targetRowType, typeFactory, id, catalogReader, targetTable); assert field != null : "column " + id.toString() + " not found"; targetColumnNameList.add(field.getName()); ((LogicalProject) insertRel.getInput(0)).getProjects(); if (insertRel.getInput(0).getInput(0) instanceof LogicalProject) { level2InsertExprs = ((LogicalProject) insertRel.getInput(0).getInput(0)) LogicalJoin join = (LogicalJoin) mergeSourceRel.getInput(0); int nSourceFields = join.getLeft().getRowType().getFieldCount(); final List<RexNode> projects = new ArrayList<>(); for (int level1Idx = 0; level1Idx < nLevel1Exprs; level1Idx++) {
final List<RelDataTypeField> relOutput = rel.getRowType().getFieldList(); Pair.of( decorrelateExpr(oldProjects.get(newPos)), relOutput.get(newPos).getName())); mapOldToNewOutputs.put(newPos, newPos); projects.add( RexInputRef.of2(entry.getValue(), frame.r.getRowType().getFieldList())); corDefOutputs.put(entry.getKey(), newPos); newPos++; SqlValidatorUtil.uniquify(Pair.right(projects)));
SqlValidatorUtil.deriveJoinRowType( project.getInput().getRowType(), rightChild.getRowType(), JoinRelType.INNER, typeFactory, bottomProgramBuilder.addProject(pair.left, pair.right); int nLeftFields = project.getInput().getRowType().getFieldCount(); List<RelDataTypeField> rightFields = rightChild.getRowType().getFieldList(); int nRightFields = rightFields.size(); for (int i = 0; i < nRightFields; i++) { RexNode inputRef = rexBuilder.makeInputRef( field.getType(), i + nLeftFields); bottomProgramBuilder.addProject(inputRef, field.getName()); SqlValidatorUtil.deriveJoinRowType( project.getRowType(), rightChild.getRowType(),
if (!SqlTypeUtil.isComparable(leftColType, rightColType)) { throw newValidationError(id, RESOURCE.naturalOrUsingColumnNotCompatible(id.getSimple(), leftColType.toString(), rightColType.toString())); final SqlNameMatcher nameMatcher = catalogReader.nameMatcher(); List<String> naturalColumnNames = SqlValidatorUtil.deriveNaturalJoinColumnList(nameMatcher, leftRowType, rightRowType); nameMatcher.field(leftRowType, name).getType(); final RelDataType rightColType = nameMatcher.field(rightRowType, name).getType(); if (!SqlTypeUtil.isComparable(leftColType, rightColType)) { throw newValidationError(join, RESOURCE.naturalOrUsingColumnNotCompatible(name, leftColType.toString(), rightColType.toString()));
public void addSelect(List<SqlNode> selectList, SqlNode node, RelDataType rowType) { String name = rowType.getFieldNames().get(selectList.size()); String alias = SqlValidatorUtil.getAlias(node, -1); if (alias == null || !alias.equals(name)) { node = SqlStdOperatorTable.AS.createCall( POS, node, new SqlIdentifier(name, POS)); } selectList.add(node); }