public Expression generateSelector(final ParameterExpression parameter, final List<Integer> fields, List<Integer> usedFields, JavaRowFormat targetFormat) { final PhysType targetPhysType = project(fields, true, targetFormat); final List<Expression> expressions = new ArrayList<>(); for (Ord<Integer> ord : Ord.zip(fields)) { final Integer field = ord.e; if (usedFields.contains(field)) { expressions.add(fieldReference(parameter, field)); } else { final Primitive primitive = Primitive.of(targetPhysType.fieldClass(ord.i)); expressions.add( Expressions.constant( primitive != null ? primitive.defaultValue : null)); } } for (Integer field : fields) { expressions.add(Expressions.constant(!usedFields.contains(field))); } return Expressions.lambda(Function1.class, targetPhysType.record(expressions), parameter); }
final int outputFieldCount = physType.getRowType().getFieldCount(); for (Ord<PhysType> ord : Ord.zip(inputPhysTypes)) { final PhysType inputPhysType = ord.e.makeNullable(joinType.generatesNullsOn(ord.i)); Expressions.parameter(Primitive.box(inputPhysType.getJavaRowType()), EnumUtils.LEFT_RIGHT.get(ord.i)); parameters.add(parameter); final int fieldCount = inputPhysType.getRowType().getFieldCount(); for (int i = 0; i < fieldCount; i++) { Expression expression = inputPhysType.fieldReference(parameter, i, physType.getJavaFieldType(expressions.size())); if (joinType.generatesNullsOn(ord.i)) { expression = physType.record(expressions), parameters);
public Expression field(BlockBuilder list, int index, Type storageType) { int offset = 0; for (Pair<Expression, PhysType> input : inputs) { final PhysType physType = input.right; int fieldCount = physType.getRowType().getFieldCount(); if (index >= offset + fieldCount) { offset += fieldCount; continue; } final Expression left = list.append("current", input.left); return physType.fieldReference(left, index - offset, storageType); } throw new IllegalArgumentException("Unable to find field #" + index); } }
Expressions.parameter(inputPhysType.getJavaRowType(), "a0"); inputPhysType.project(groupSet.asList(), getGroupType() != Group.SIMPLE, JavaRowFormat.LIST); final int groupCount = getGroupCount(); if (accPhysType.getJavaRowType() instanceof JavaTypeFactoryImpl.SyntheticRecordType) { accPhysType.getJavaRowType(); final ParameterExpression record0_ = Expressions.parameter(accPhysType.getJavaRowType(), "record0"); initBlock.add(Expressions.declare(0, record0_, null)); initBlock.add( Expressions.statement( Expressions.assign(record0_, Expressions.new_(accPhysType.getJavaRowType())))); List<Types.RecordField> fieldList = synType.getRecordFields(); for (int i = 0; i < initExpressions.size(); i++) { initBlock.add(accPhysType.record(initExpressions)); Expressions.parameter(inputPhysType.getJavaRowType(), "in"); final ParameterExpression acc_ = Expressions.parameter(accPhysType.getJavaRowType(), "acc"); for (int i = 0, stateOffset = 0; i < aggs.size(); i++) { final AggImpState agg = aggs.get(i); final List<Expression> accumulator = new ArrayList<>(stateSize); for (int j = 0; j < stateSize; j++) {
builder.append("left", leftResult.block); final ParameterExpression left_ = Expressions.parameter(leftResult.physType.getJavaRowType(), "left"); final Result rightResult = implementor.visitChild(this, 1, (EnumerableRel) right, pref); builder.append("right", rightResult.block); final ParameterExpression right_ = Expressions.parameter(rightResult.physType.getJavaRowType(), "right"); final JavaTypeFactory typeFactory = implementor.getTypeFactory(); final PhysType physType = leftExpressions.add( Types.castIfNecessary(keyClass, leftResult.physType.fieldReference(left_, pair.left))); rightExpressions.add( Types.castIfNecessary(keyClass, rightResult.physType.fieldReference(right_, pair.right))); leftResult.physType.project(leftKeys, JavaRowFormat.LIST); final PhysType rightKeyPhysType = rightResult.physType.project(rightKeys, JavaRowFormat.LIST); return implementor.result( physType, rightExpression, Expressions.lambda( leftKeyPhysType.record(leftExpressions), left_), Expressions.lambda(
private Expression fieldExpression(ParameterExpression row_, int i, PhysType physType, JavaRowFormat format) { final Expression e = format.field(row_, i, null, physType.getJavaFieldType(i)); final RelDataType relFieldType = physType.getRowType().getFieldList().get(i).getType(); switch (relFieldType.getSqlTypeName()) { case ARRAY: case MULTISET: // We can't represent a multiset or array as a List<Employee>, because // the consumer does not know the element type. // The standard element type is List. // We need to convert to a List<List>. final JavaTypeFactory typeFactory = (JavaTypeFactory) getCluster().getTypeFactory(); final PhysType elementPhysType = PhysTypeImpl.of( typeFactory, relFieldType.getComponentType(), JavaRowFormat.CUSTOM); final MethodCallExpression e2 = Expressions.call(BuiltInMethod.AS_ENUMERABLE2.method, e); final RelDataType dummyType = this.rowType; final Expression e3 = elementPhysType.convertTo(e2, PhysTypeImpl.of(typeFactory, dummyType, JavaRowFormat.LIST)); return Expressions.call(e3, BuiltInMethod.ENUMERABLE_TO_LIST.method); default: return e; } }
implementor.getTypeFactory(), getRowType(), pref.preferArray()); final PhysType keyPhysType = leftResult.physType.project( leftKeys, JavaRowFormat.LIST); return implementor.result( Expressions.list( rightExpression, leftResult.physType.generateAccessor(leftKeys), rightResult.physType.generateAccessor(rightKeys), EnumUtils.joinSelector(joinType, physType, leftResult.physType, rightResult.physType))) .append( Util.first(keyPhysType.comparer(), Expressions.constant(null))) .append(
int i, Expression target, Expression calendar_, SqlDialect.CalendarPolicy calendarPolicy) { final Primitive primitive = Primitive.ofBoxOr(physType.fieldClass(i)); final RelDataType fieldType = physType.getRowType().getFieldList().get(i).getType(); final List<Expression> dateTimeArgs = new ArrayList<>(); dateTimeArgs.add(Expressions.constant(i + 1));
List<Type> storageTypes = null; if (outputPhysType != null) { final RelDataType rowType = outputPhysType.getRowType(); storageTypes = new ArrayList<>(rowType.getFieldCount()); for (int i = 0; i < rowType.getFieldCount(); i++) { storageTypes.add(outputPhysType.getJavaFieldType(i));
@Override public Class get(int index) { return physType.fieldClass(index); }
private Expression toRows(PhysType physType, Expression expression) { if (physType.getFormat() == JavaRowFormat.SCALAR && Object[].class.isAssignableFrom(elementType) && getRowType().getFieldCount() == 1 && (table.unwrap(ScannableTable.class) != null || table.unwrap(FilterableTable.class) != null || table.unwrap(ProjectableFilterableTable.class) != null)) { return Expressions.call(BuiltInMethod.SLICE0.method, expression); } JavaRowFormat oldFormat = format(); if (physType.getFormat() == oldFormat && !hasCollectionField(rowType)) { return expression; } final ParameterExpression row_ = Expressions.parameter(elementType, "row"); final int fieldCount = table.getRowType().getFieldCount(); List<Expression> expressionList = new ArrayList<>(fieldCount); for (int i = 0; i < fieldCount; i++) { expressionList.add(fieldExpression(row_, i, physType, oldFormat)); } return Expressions.call(expression, BuiltInMethod.SELECT.method, Expressions.lambda(Function1.class, physType.record(expressionList), row_)); }
switch (prefer) { case ARRAY: if (result.physType.getFormat() == JavaRowFormat.ARRAY && rootRel.getRowType().getFieldCount() == 1) { BlockBuilder bb = new BlockBuilder(); Blocks.toFunctionBlock( Expressions.return_(null, Expressions.constant(result.physType.getJavaRowType()))))); return Expressions.classDecl(Modifier.PUBLIC, "Baz",
PhysTypeImpl.of(typeFactory, builder.build(), JavaRowFormat.ARRAY); final ParameterExpression inParameter = Expressions.parameter(inputPhysType.getJavaRowType(), "in"); final ParameterExpression acc_ = Expressions.parameter(accPhysType.getJavaRowType(), "acc"); accumulator.add(accPhysType.fieldReference(acc_, j + stateOffset));
public Expression keyField(int i) { return keyPhysType.fieldReference(key, i); }
BuiltInMethod.UNION.method, Expressions.list(childExp) .appendIfNotNull(result.physType.comparer()));
private Pair<Expression, Expression> getRowCollationKey( BlockBuilder builder, PhysType inputPhysType, Group group, int windowIdx) { if (!(group.isRows || (group.upperBound.isUnbounded() && group.lowerBound.isUnbounded()))) { Pair<Expression, Expression> pair = inputPhysType.generateCollationKey( group.collation().getFieldCollations()); // optimize=false to prevent inlining of object create into for-loops return Pair.of( builder.append("keySelector" + windowIdx, pair.left, false), builder.append("keyComparator" + windowIdx, pair.right, false)); } else { return Pair.of(null, null); } }
public Expression convertTo(Expression exp, PhysType targetPhysType) { final JavaRowFormat targetFormat = targetPhysType.getFormat(); if (format == targetFormat) { return exp; } final ParameterExpression o_ = Expressions.parameter(javaRowClass, "o"); final int fieldCount = rowType.getFieldCount(); return Expressions.call(exp, BuiltInMethod.SELECT.method, generateSelector(o_, Util.range(fieldCount), targetFormat)); }
public Result implement(EnumerableRelImplementor implementor, Prefer pref) { BlockBuilder builder = new BlockBuilder(); final Result leftResult = implementor.visitChild(this, 0, (EnumerableRel) left, pref); Expression leftExpression = builder.append( "left", leftResult.block); final Result rightResult = implementor.visitChild(this, 1, (EnumerableRel) right, pref); Expression rightExpression = builder.append( "right", rightResult.block); final PhysType physType = leftResult.physType; return implementor.result( physType, builder.append( Expressions.call( BuiltInMethod.SEMI_JOIN.method, Expressions.list( leftExpression, rightExpression, leftResult.physType.generateAccessor(leftKeys), rightResult.physType.generateAccessor(rightKeys)))) .toBlock()); } }
Expressions.parameter(inputPhysType.getJavaRowType(), "a0"); inputPhysType.project(groupSet.asList(), getGroupType() != Group.SIMPLE, JavaRowFormat.LIST); final int groupCount = getGroupCount(); Expressions.parameter(inputPhysType.getJavaRowType(), "in"); final ParameterExpression acc_ = Expressions.parameter(accPhysType.getJavaRowType(), "acc"); for (int i = 0, stateOffset = 0; i < aggs.size(); i++) { final BlockBuilder builder2 = new BlockBuilder(); final List<Expression> accumulator = new ArrayList<>(stateSize); for (int j = 0; j < stateSize; j++) { accumulator.add(accPhysType.fieldReference(acc_, j + stateOffset)); key_ = null; } else { final Type keyType = keyPhysType.getJavaRowType(); key_ = Expressions.parameter(keyType, "key"); for (int j = 0; j < groupCount; j++) { final Expression ref = keyPhysType.fieldReference(key_, j); if (getGroupType() == Group.SIMPLE) { results.add(ref); results.add( Expressions.condition( keyPhysType.fieldReference(key_, groupCount + j), Expressions.constant(null),
builder.append("left", leftResult.block); final ParameterExpression left_ = Expressions.parameter(leftResult.physType.getJavaRowType(), "left"); final Result rightResult = implementor.visitChild(this, 1, (EnumerableRel) right, pref); builder.append("right", rightResult.block); final ParameterExpression right_ = Expressions.parameter(rightResult.physType.getJavaRowType(), "right"); final JavaTypeFactory typeFactory = implementor.getTypeFactory(); final PhysType physType = leftExpressions.add( Types.castIfNecessary(keyClass, leftResult.physType.fieldReference(left_, pair.left))); rightExpressions.add( Types.castIfNecessary(keyClass, rightResult.physType.fieldReference(right_, pair.right))); leftResult.physType.project(leftKeys, JavaRowFormat.LIST); final PhysType rightKeyPhysType = rightResult.physType.project(rightKeys, JavaRowFormat.LIST); return implementor.result( physType, rightExpression, Expressions.lambda( leftKeyPhysType.record(leftExpressions), left_), Expressions.lambda(