public CubeEnumerator(OLAPContext olapContext, DataContext optiqContext) { this.olapContext = olapContext; this.optiqContext = optiqContext; this.current = new Object[olapContext.olapRowType.getFieldCount()]; this.cursor = null; this.fieldIndexes = null; }
/** * Returns the type for a histogram function. It is either the actual * type or an an approximation to it. */ private RelDataType computeHistogramType(RelDataType type) { if (SqlTypeUtil.isExactNumeric(type) && type.getSqlTypeName() != SqlTypeName.BIGINT) { return typeFactory.createSqlType(SqlTypeName.BIGINT); } else if (SqlTypeUtil.isApproximateNumeric(type) && type.getSqlTypeName() != SqlTypeName.DOUBLE) { return typeFactory.createSqlType(SqlTypeName.DOUBLE); } else { return type; } } }
/** * Adds an expression, deducing an appropriate name if possible. * * @param expr Expression * @param name Suggested name */ private void addExpr(RexNode expr, String name) { convertedInputExprs.add(expr); if ((name == null) && (expr instanceof RexInputRef)) { final int i = ((RexInputRef) expr).getIndex(); name = bb.root.getRowType().getFieldList().get(i).getName(); } if (convertedInputExprNames.contains(name)) { // In case like 'SELECT ... GROUP BY x, y, x', don't add // name 'x' twice. name = null; } convertedInputExprNames.add(name); }
return null; RelDataTypeField field = rowType.getFieldList().get(iField); RelDataType type = field.getType(); if (type.isStruct()) { NumberUtil.rescaleBigDecimal( (BigDecimal) value, type.getScale()); return rexBuilder.makeExactLiteral( roundedValue, && (type.getSqlTypeName() == SqlTypeName.CHAR)) { Util.rpad(unpadded.getValue(), type.getPrecision()), unpadded.getCharsetName(), unpadded.getCollation()));
final RelDataType targetRowType = targetTable.getRowType(); final List<RelDataTypeField> targetFields = targetRowType.getFieldList(); final List<RexNode> sourceExps = new ArrayList<RexNode>( RelDataTypeField field = catalogReader.field(targetRowType, p.left); assert field != null : "column " + p.left + " not found"; sourceExps.set(field.getIndex(), p.right); final String fieldName = field.getName(); fieldNames.set(i, fieldName); if (sourceExps.get(i) != null) { i, castNullLiteralIfNeeded( sourceExps.get(i), field.getType()));
final List<RelDataTypeField> fields = rel.getRowType().getFieldList(); final List<Pair<RexNode, String>> newProjects = Lists.newArrayList(); for (int i = 0; i < fields.size(); i++) { Pair.of( (RexNode) new RexInputRef( squished.get(origin), field.getType()), field.getName())); createAggregate( bb, BitSets.range(rel.getRowType().getFieldCount()), ImmutableList.<AggregateCall>of());
RexNode left = rexBuilder.makeInputRef( leftField.getType(), leftField.getIndex()); final RelDataType rightRowType = rightRel.getRowType(); RelDataTypeField rightField = RexNode right = rexBuilder.makeInputRef( rightField.getType(), leftRowType.getFieldList().size() + rightField.getIndex()); RexNode equalsCall = rexBuilder.makeCall(
final RelDataType rowType = bb.root.getRowType(); final int fieldCount = rowType.getFieldCount() - orderExprList.size(); for (int i = 0; i < fieldCount; i++) { exprs.add(rexBuilder.makeInputRef(bb.root, i)); bb.root, exprs, cluster.getTypeFactory().createStructType( rowType.getFieldList().subList(0, fieldCount)), ProjectRelBase.Flags.BOXED), false);
@Override public Pair<RexNode, String> get(int index) { if (index < leftCount) { RelDataTypeField field = fields.get(index); return Pair.<RexNode, String>of( new RexInputRef(index, field.getType()), field.getName()); } else { return Pair.<RexNode, String>of( extraLeftExprs.get(index - leftCount), null); } } },
final int fieldCount = rex.getType().getFieldCount(); RexNode rexNode = rexBuilder.makeFieldAccess(rex, fieldCount - 1); rexNode = rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE, rexNode); final ProjectRelBase left = (ProjectRelBase) join.getLeft(); final RelNode leftLeft = ((JoinRelBase) left.getInput(0)).getLeft(); final int leftLeftCount = leftLeft.getRowType().getFieldCount(); final RelDataType nullableBooleanType = typeFactory.createTypeWithNullability( typeFactory.createSqlType(SqlTypeName.BOOLEAN), true); final RelDataType longType = typeFactory.createSqlType(SqlTypeName.BIGINT); final RexNode cRef = rexBuilder.makeInputRef(root, leftLeftCount); final RexNode ckRef = rexBuilder.makeInputRef(root, leftLeftCount + 1); final RexNode iRef = rexBuilder.makeInputRef(root, root.getRowType().getFieldCount() - 1);
protected RelDataType uniquifyFields(RelDataType rowType) { return validator.getTypeFactory().createStructType( RelOptUtil.getFieldTypeList(rowType), SqlValidatorUtil.uniquify(rowType.getFieldNames())); }
RelDataTypeField getRootField(RexInputRef inputRef) { int fieldOffset = inputRef.getIndex(); for (RelNode input : inputs) { RelDataType rowType = input.getRowType(); if (rowType == null) { // TODO: remove this once leastRestrictive // is correctly implemented return null; } if (fieldOffset < rowType.getFieldCount()) { return rowType.getFieldList().get(fieldOffset); } fieldOffset -= rowType.getFieldCount(); } throw new AssertionError(); }
final int origLeftInputCount = root.getRowType().getFieldCount(); if (leftKeys != null) { List<RexNode> newLeftInputExpr = Lists.newArrayList(); final int rightOffset = root.getRowType().getFieldCount() - newLeftInput.getRowType().getFieldCount(); final List<Integer> rightKeys = Util.range(rightOffset, rightOffset + leftJoinKeys.size()); int leftFieldCount = root.getRowType().getFieldCount(); final RelNode join = createJoin( && joinType == JoinRelType.LEFT) { final int leftKeyCount = leftKeys.size(); int rightFieldLength = rel.getRowType().getFieldCount(); assert leftKeyCount == rightFieldLength - 1; typeFactory.createStructType( new AbstractList<Map.Entry<String, RelDataType>>() { public Map.Entry<String, RelDataType> get(
private Object[] convertCurrentRow(ITuple tuple) { // build field index map if (this.fieldIndexes == null) { List<String> fields = tuple.getAllFields(); int size = fields.size(); this.fieldIndexes = new int[size]; for (int i = 0; i < size; i++) { String field = fields.get(i); RelDataTypeField relField = olapContext.olapRowType.getField(field, true); if (relField != null) { fieldIndexes[i] = relField.getIndex(); } else { fieldIndexes[i] = -1; } } } // set field value Object[] values = tuple.getAllValues(); for (int i = 0, n = values.length; i < n; i++) { Object value = values[i]; int index = fieldIndexes[i]; if (index >= 0) { current[index] = value; } } return current; }
/** * Adjusts the type of a reference to an input field to account for nulls * introduced by outer joins; and adjusts the offset to match the physical * implementation. * * @param bb Blackboard * @param inputRef Input ref * @return Adjusted input ref */ protected RexNode adjustInputRef( Blackboard bb, RexInputRef inputRef) { RelDataTypeField field = bb.getRootField(inputRef); if (field != null) { return rexBuilder.makeInputRef( field.getType(), inputRef.getIndex()); } return inputRef; }
private void checkConvertedType(SqlNode query, RelNode result) { if (!query.isA(SqlKind.DML)) { // Verify that conversion from SQL to relational algebra did // not perturb any type information. (We can't do this if the // SQL statement is something like an INSERT which has no // validator type information associated with its result, // hence the namespace check above.) RelDataType convertedRowType = result.getRowType(); if (!checkConvertedRowType(query, convertedRowType)) { RelDataType validatedRowType = validator.getValidatedNodeType(query); validatedRowType = uniquifyFields(validatedRowType); throw Util.newInternal( "Conversion to relational algebra failed to preserve " + "datatypes:\n" + "validated type:\n" + validatedRowType.getFullTypeString() + "\nconverted type:\n" + convertedRowType.getFullTypeString() + "\nrel:\n" + RelOptUtil.toString(result)); } } }
&& !validator.getValidatedNodeType(node).isNullable()) { logic = RelOptUtil.Logic.UNKNOWN_AS_FALSE;
SqlNodeList targetColumnList = call.getTargetColumnList(); if (targetColumnList == null) { targetColumnNames.addAll(targetRowType.getFieldNames()); } else { for (int i = 0; i < targetColumnList.size(); i++) {
@Override public Pair<RexNode, String> get(int index) { if (index < rightCount) { RelDataTypeField field = fields.get(index); return Pair.<RexNode, String>of( new RexInputRef(index, field.getType()), field.getName()); } else { return Pair.of( RexUtil.shift( extraRightExprs.get(index - rightCount), -newLeftCount), null); } } },
public void flatten( List<RelNode> rels, int systemFieldCount, int[] start, List<Pair<RelNode, Integer>> relOffsetList) { for (RelNode rel : rels) { if (leaves.contains(rel)) { relOffsetList.add( Pair.of(rel, start[0])); start[0] += rel.getRowType().getFieldCount(); } else { if (rel instanceof JoinRel || rel instanceof AggregateRel) { start[0] += systemFieldCount; } flatten( rel.getInputs(), systemFieldCount, start, relOffsetList); } } }