Refine search
@Override public RelDataType deriveRowType() { final List<RelDataTypeField> fieldList = table.getRowType().getFieldList(); final RelDataTypeFactory.FieldInfoBuilder builder = getCluster().getTypeFactory().builder(); for (int field : fields) { builder.add(fieldList.get(field)); } return builder.build(); }
@Override public void implementRewrite(RewriteImplementor implementor) { Map<String, RelDataType> rewriteFields = this.context.rewriteFields; for (Map.Entry<String, RelDataType> rewriteField : rewriteFields.entrySet()) { String fieldName = rewriteField.getKey(); RelDataTypeField field = rowType.getField(fieldName, true, false); if (field != null) { RelDataType fieldType = field.getType(); rewriteField.setValue(fieldType); } } // add dynamic field to the table scan if join not exist if (!this.context.hasJoin && !this.context.dynamicFields.isEmpty()) { Map<TblColRef, RelDataType> dynFields = this.context.dynamicFields; List<TblColRef> newCols = Lists.newArrayList(this.columnRowType.getAllColumns()); List<RelDataTypeField> newFieldList = Lists.newArrayList(this.rowType.getFieldList()); int paramIndex = this.rowType.getFieldList().size(); for (TblColRef fieldCol : dynFields.keySet()) { newCols.add(fieldCol); RelDataType fieldType = dynFields.get(fieldCol); RelDataTypeField newField = new RelDataTypeFieldImpl(fieldCol.getName(), paramIndex++, fieldType); newFieldList.add(newField); } // rebuild row type RelDataTypeFactory.FieldInfoBuilder fieldInfo = getCluster().getTypeFactory().builder(); fieldInfo.addAll(newFieldList); this.rowType = getCluster().getTypeFactory().createStructType(fieldInfo); this.columnRowType = new ColumnRowType(newCols); } }
return false; if (getRowType().getFieldCount() != getSystemFieldList().size() + left.getRowType().getFieldCount() + (this instanceof SemiJoin ? 0 : right.getRowType().getFieldCount())) { return litmus.fail("field count mismatch"); getCluster().getTypeFactory().builder() .addAll(getSystemFieldList()) .addAll(getLeft().getRowType().getFieldList()) .addAll(getRight().getRowType().getFieldList()) .build(), context, litmus); condition.accept(checker);
public void onMatch(RelOptRuleCall call) { final Filter filter = call.rel(0); final Project project = call.rel(1); final List<RexNode> newProjects = new ArrayList<>(project.getProjects()); newProjects.add(filter.getCondition()); final RelOptCluster cluster = filter.getCluster(); RelDataType newRowType = cluster.getTypeFactory().builder() .addAll(project.getRowType().getFieldList()) .add("condition", Util.last(newProjects).getType()) .build(); final RelNode newProject = project.copy(project.getTraitSet(), project.getInput(), newProjects, newRowType); final RexInputRef newCondition = cluster.getRexBuilder().makeInputRef(newProject, newProjects.size() - 1); call.transformTo(filter.copy(filter.getTraitSet(), newProject, newCondition)); } }
final List<Integer> groupList = groupSet.asList(); assert groupList.size() == groupSet.cardinality(); final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder(); final List<RelDataTypeField> fieldList = inputRowType.getFieldList(); final Set<String> containedNames = Sets.newHashSet(); for (int groupKey : groupList) { containedNames.add(fieldList.get(groupKey).getName()); builder.add(fieldList.get(groupKey)); typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.BOOLEAN), false); String name = "i$" + fieldList.get(groupKey).getName(); int i = 0; builder.add(name, booleanType); builder.add(name, aggCall.e.type); return builder.build();
public RelNode apply(RelOptCluster cluster, RelOptSchema relOptSchema, SchemaPlus rootSchema) { final RelDataTypeFactory typeFactory = cluster.getTypeFactory(); final RexBuilder rexBuilder = cluster.getRexBuilder(); final RelOptPlanner planner = cluster.getPlanner(); final RelDataType stringType = typeFactory.createJavaType(String.class); final RelDataType integerType = typeFactory.createJavaType(Integer.class); final RelDataType sqlBigInt = typeFactory.createSqlType(SqlTypeName.BIGINT); (RexNode) rexBuilder.makeInputRef(stringType, 0), rexBuilder.makeInputRef(integerType, 1)), typeFactory.builder().add("s", stringType).add("i", integerType) .build());
final RelDataType rowType = rel.getRowType(); final List<Pair<Integer, String>> fields = Pair.zip(ImmutableIntList.identity(rowType.getFieldCount()), rowType.getFieldNames()); final RelCollation collation = rel instanceof Sort fieldOrigins = Collections.nCopies(jdbcType.getFieldCount(), null); parameterRowType = rexBuilder.getTypeFactory().builder().build();
final CorrelationId correlId = cluster.createCorrel(); mapCorrelToDeferred.put(correlId, lookup); if (resolve.path.steps().get(0).i < 0) { } else { final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder(); final ListScope ancestorScope1 = (ListScope) resolve.scope; final ImmutableMap.Builder<String, Integer> fields = int offset = 0; for (SqlValidatorNamespace c : ancestorScope1.getChildren()) { builder.addAll(c.getRowType().getFieldList()); if (i == resolve.path.steps().get(0).i) { for (RelDataTypeField field : c.getRowType().getFieldList()) { fields.put(c.translate(field.getName()), field.getIndex() + offset); offset += c.getRowType().getFieldCount(); rexBuilder.makeCorrel(builder.uniquify().build(), correlId); return Pair.<RexNode, Map<String, Integer>>of(c, fields.build());
/** * Derives the output type of a collect relational expression. * * @param rel relational expression * @param fieldName name of sole output field * @return output type of a collect relational expression */ public static RelDataType deriveCollectRowType( SingleRel rel, String fieldName) { RelDataType childType = rel.getInput().getRowType(); assert childType.isStruct(); final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory(); RelDataType ret = SqlTypeUtil.createMultisetType( typeFactory, childType, false); ret = typeFactory.builder().add(fieldName, ret).build(); return typeFactory.createTypeWithNullability(ret, false); } }
@Override protected RelDataType deriveRowType() { final RelDataTypeFactory typeFactory = getCluster().getTypeFactory(); return typeFactory.builder() .add("this", typeFactory.createJavaType(Void.TYPE)) .build(); }
final RexBuilder rexBuilder = cluster.getRexBuilder(); final RelMetadataQuery mq = RelMetadataQuery.instance(); final RelDataType rowType = cluster.getTypeFactory().builder() .add("a", SqlTypeName.INTEGER) .add("b", SqlTypeName.VARCHAR) .build(); final ImmutableList.Builder<ImmutableList<RexLiteral>> tuples = ImmutableList.builder();
final RelDataTypeFactory.FieldInfoBuilder fieldBuilder = rexBuilder.getTypeFactory().builder(); for (RelNode input : inputs) { fieldBuilder.addAll(input.getRowType().getFieldList()); final RelDataType inputRowType = fieldBuilder.build(); final RexProgramBuilder programBuilder = new RexProgramBuilder(inputRowType, rexBuilder); for (RexNode node : nodes) { final ParameterExpression inputValues = Expressions.parameter(Object[].class, "inputValues"); final ParameterExpression outputValues = Expressions.parameter(Object[].class, "outputValues"); final JavaTypeFactoryImpl javaTypeFactory = new SamzaSqlJavaTypeFactoryImpl(rexBuilder.getTypeFactory().getTypeSystem());
/** * Removes an update column from a persisted column. This means it won't be written and won't be used in matching. * * If there is not initial update column, no changes will be made. */ public static RelNode removeUpdateColumn(RelNode node){ if(node.getTraitSet() == null){ // for test purposes. return node; } RelDataTypeField field = node.getRowType().getField(UPDATE_COLUMN, false, false); if(field == null ){ return node; } final RexBuilder rexBuilder = node.getCluster().getRexBuilder(); final RelDataTypeFactory.FieldInfoBuilder rowTypeBuilder = new RelDataTypeFactory.FieldInfoBuilder(node.getCluster().getTypeFactory()); final List<RexNode> projects = FluentIterable.from(node.getRowType().getFieldList()) .filter(new Predicate<RelDataTypeField>(){ @Override public boolean apply(RelDataTypeField input) { return !UPDATE_COLUMN.equals(input.getName()); }}) .transform(new Function<RelDataTypeField, RexNode>(){ @Override public RexNode apply(RelDataTypeField input) { rowTypeBuilder.add(input); return rexBuilder.makeInputRef(input.getType(), input.getIndex()); }}).toList(); return new LogicalProject(node.getCluster(), node.getTraitSet(), node, projects, rowTypeBuilder.build()); }
PhysTable(RelOptCluster cluster) { super(cluster, cluster.traitSet().replace(PHYSICAL).replace(COLLATION)); RelDataTypeFactory typeFactory = cluster.getTypeFactory(); final RelDataType stringType = typeFactory.createJavaType(String.class); final RelDataType integerType = typeFactory.createJavaType(Integer.class); this.rowType = typeFactory.builder().add("s", stringType) .add("i", integerType).build(); }
public static RelNode removeColumns(RelNode node, Predicate<RelDataTypeField> predicate) { if (node.getTraitSet() == null) { // for test purposes. return node; } // identify all fields that match passed predicate Set<RelDataTypeField> toRemove = FluentIterable.from(node.getRowType().getFieldList()).filter(predicate).toSet(); if (toRemove.isEmpty()) { return node; } final RexBuilder rexBuilder = node.getCluster().getRexBuilder(); final RelDataTypeFactory.FieldInfoBuilder rowTypeBuilder = new RelDataTypeFactory.FieldInfoBuilder(node.getCluster().getTypeFactory()); final List<RexNode> projects = FluentIterable.from(node.getRowType().getFieldList()) .filter(Predicates.not(toRemove::contains)) .transform((RelDataTypeField field) -> { rowTypeBuilder.add(field); return (RexNode) rexBuilder.makeInputRef(field.getType(), field.getIndex()); }).toList(); return new LogicalProject(node.getCluster(), node.getTraitSet(), node, projects, rowTypeBuilder.build()); }
public RelOptTable extend(List<RelDataTypeField> extendedFields) { final RelDataType extendedRowType = getRelOptSchema().getTypeFactory().builder() .addAll(rowType.getFieldList()) .addAll(extendedFields) .build(); return new MockColumnSet(names, extendedRowType, collationList); } }
Expression predicate(EnumerableRelImplementor implementor, BlockBuilder builder, PhysType leftPhysType, PhysType rightPhysType, RexNode condition) { final ParameterExpression left_ = Expressions.parameter(leftPhysType.getJavaRowType(), "left"); final ParameterExpression right_ = Expressions.parameter(rightPhysType.getJavaRowType(), "right"); final RexProgramBuilder program = new RexProgramBuilder( implementor.getTypeFactory().builder() .addAll(left.getRowType().getFieldList()) .addAll(right.getRowType().getFieldList()) .build(), getCluster().getRexBuilder()); program.addCondition(condition); builder.add( Expressions.return_(null, RexToLixTranslator.translateCondition(program.getProgram(), implementor.getTypeFactory(), builder, new RexToLixTranslator.InputGetterImpl( ImmutableList.of(Pair.of((Expression) left_, leftPhysType), Pair.of((Expression) right_, rightPhysType))), implementor.allCorrelateVariables, implementor.getConformance()))); return Expressions.lambda(Predicate2.class, builder.toBlock(), left_, right_); } }
tupleList(fieldNames.length, values); final RelDataTypeFactory.FieldInfoBuilder rowTypeBuilder = cluster.getTypeFactory().builder(); for (final Ord<String> fieldName : Ord.zip(fieldNames)) { final String name = rowTypeBuilder.add(name, type); final RelDataType rowType = rowTypeBuilder.build(); return values(tupleList, rowType);