context.setCurrentTable(table.getTableRef()); PTable projectedTable = table.createProjectedTable(!projectPKColumns, context); TupleProjector projector = new TupleProjector(projectedTable); TupleProjector.serializeProjectorIntoScan(context.getScan(), projector); context.setResolver(FromCompiler.getResolverForProjectedTable(projectedTable, context.getConnection(), subquery.getUdfParseNodes())); table.projectColumns(context.getScan()); PTable projectedTable = table.createProjectedTable(plan.getProjector()); context.setResolver(FromCompiler.getResolverForProjectedTable(projectedTable, context.getConnection(), subquery.getUdfParseNodes())); return new TupleProjectionPlan(plan, new TupleProjector(plan.getProjector()), table.compilePostFilterExpression(context));
public MockResultIterator(String id, PTable table) throws SQLException { TupleProjector projector = new TupleProjector(table); List<Cell> result = new ArrayList<>(); result.add(new KeyValue(Bytes.toBytes(id), SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(id))); this.tuple = projector.projectResults(new ResultTuple(Result.create(result))); }
private Tuple join(Tuple lhs, Tuple rhs) throws SQLException { try { ProjectedValueTuple t = null; if (lhs == null) { t = new ProjectedValueTuple(rhs, rhs.getValue(0).getTimestamp(), this.emptyProjectedValue, 0, this.emptyProjectedValue.length, this.emptyProjectedValue.length); } else if (lhs instanceof ProjectedValueTuple) { t = (ProjectedValueTuple) lhs; } else { ImmutableBytesWritable ptr = context.getTempPtr(); TupleProjector.decodeProjectedValue(lhs, ptr); lhsBitSet.clear(); lhsBitSet.or(ptr); int bitSetLen = lhsBitSet.getEstimatedLength(); t = new ProjectedValueTuple(lhs, lhs.getValue(0).getTimestamp(), ptr.get(), ptr.getOffset(), ptr.getLength(), bitSetLen); } return rhsBitSet == ValueBitSet.EMPTY_VALUE_BITSET ? t : TupleProjector.mergeProjectedValue( t, joinedSchema, destBitSet, rhs, rhsSchema, rhsBitSet, rhsFieldPosition, true); } catch (IOException e) { throw new SQLException(e); } } }
return TupleProjector.mergeProjectedValue( (ProjectedValueTuple) dest, destSchema, destBitSet, src, srcSchema, srcBitSet, offset, useNewValueColumnQualifier); ProjectedValueTuple first = projector.projectResults( new SingleKeyValueTuple(dest.getValue(0))); ProjectedValueTuple merged = TupleProjector.mergeProjectedValue( first, destSchema, destBitSet, src, srcSchema, srcBitSet, offset, useNewValueColumnQualifier);
private static TupleProjector getTupleProjector(RowProjector rowProj, List<TargetDataExpression> targetTypes) throws SQLException { Expression[] exprs = new Expression[targetTypes.size()]; int i = 0; for (ColumnProjector colProj : rowProj.getColumnProjectors()) { exprs[i] = CoerceExpression.create(colProj.getExpression(), targetTypes.get(i).getType(), targetTypes.get(i).getSortOrder(), targetTypes.get(i).getMaxLength()); i++; } return new TupleProjector(exprs); }
tupleProjector.getSchema().toBytes(joinTuple, tupleProjector.getExpressions(), tupleProjector.getValueBitSet(), ptr); Cell keyValue = PhoenixKeyValueUtil.newKeyValue(firstCell.getRowArray(),firstCell.getRowOffset(),firstCell.getRowLength(), VALUE_COLUMN_FAMILY,
@Override public Tuple next() throws SQLException { Tuple tuple = super.next(); if (tuple == null) return null; return tupleProjector.projectResults(tuple); }
@Override public Info visit(ProjectedColumnExpression node) { if (projector == null) { return super.visit(node); } Expression expression = projector.getExpressions()[node.getPosition()]; // Only look one level down the projection. if (expression instanceof ProjectedColumnExpression) { return super.visit(node); } return expression.accept(this); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { try { KeyValueSchema schema = getSchema(); TupleProjector.decodeProjectedValue(tuple, ptr); bitSet.clear(); bitSet.or(ptr); int maxOffset = ptr.getOffset() + ptr.getLength() - bitSet.getEstimatedLength(); schema.iterator(ptr, position, bitSet); Boolean hasValue = schema.next(ptr, position, maxOffset, bitSet); if (hasValue == null || !hasValue.booleanValue()) { ptr.set(ByteUtil.EMPTY_BYTE_ARRAY); return true; } } catch (IOException e) { return false; } return true; }
byte[][] viewConstants = null; ColumnReference[] dataColumns = IndexUtil.deserializeDataTableColumnsToJoin(scan); final TupleProjector p = TupleProjector.deserializeProjectorFromScan(scan); final HashJoinInfo j = HashJoinInfo.deserializeHashJoinFromScan(scan); boolean useQualifierAsIndex = EncodedColumnsUtil.useQualifierAsIndex(EncodedColumnsUtil.getMinMaxQualifiersFromScan(scan));
@Override public void postGetOp(ObserverContext<RegionCoprocessorEnvironment> e, Get get, List<Cell> results) throws IOException { if (results.isEmpty()) { return; } ResultTuple rsTuple = new ResultTuple(Result.create(results)); //filter rows by the where expression byte[] whereBytes = get.getAttribute(GET_WHERE_EXPRESSION); if (whereBytes != null) { Expression expression = deserializeExpression(whereBytes); if (!expression.evaluate(rsTuple, ptr) || ptr.getLength() == 0 || !Boolean.TRUE.equals(expression.getDataType().toObject(ptr))) { results.clear(); return; } } boolean useNewValueColumnQualifier = get.getAttribute(BaseScannerRegionObserver.USE_NEW_VALUE_COLUMN_QUALIFIER) == null ? false : true; TupleProjector projector = TupleProjector.deserializeProjectorFromGet(get); if (projector != null) { Tuple projectTuple = projector.projectResults(rsTuple, useNewValueColumnQualifier); results.clear(); results.add(projectTuple.getValue(0)); } }
try { joined = rhsBitSet == ValueBitSet.EMPTY_VALUE_BITSET ? current : TupleProjector.mergeProjectedValue( convertLhs(current), joinedSchema, destBitSet, rhsCurrent, rhsSchema, rhsBitSet, rhsFieldPosition, true);
this.projector.setValueBitSet(tempDestBitSet);
public UnnestArrayResultIterator(ResultIterator iterator) { super(iterator); this.elemRefExpression = new UnnestArrayElemRefExpression(arrayExpression); this.elemIndexExpression = withOrdinality ? new UnnestArrayElemIndexExpression() : null; this.projector = new TupleProjector(withOrdinality ? new Expression[] {elemRefExpression, elemIndexExpression} : new Expression[] {elemRefExpression}); this.arrayPtr = new ImmutableBytesWritable(); this.length = 0; this.index = 0; this.closed = false; }
tupleProjector.getSchema().toBytes(joinTuple, tupleProjector.getExpressions(), tupleProjector.getValueBitSet(), ptr); Cell keyValue = PhoenixKeyValueUtil.newKeyValue(firstCell.getRowArray(),firstCell.getRowOffset(),firstCell.getRowLength(), VALUE_COLUMN_FAMILY,
Tuple toProject = useQualifierAsListIndex ? new PositionBasedResultTuple(result) : new ResultTuple( Result.create(result)); Tuple tuple = projector.projectResults(toProject, useNewValueColumnQualifier); result.clear(); result.add(tuple.getValue(0));
return TupleProjector.mergeProjectedValue( (ProjectedValueTuple) dest, destSchema, destBitSet, src, srcSchema, srcBitSet, offset, useNewValueColumnQualifier); ProjectedValueTuple first = projector.projectResults( new SingleKeyValueTuple(dest.getValue(0))); ProjectedValueTuple merged = TupleProjector.mergeProjectedValue( first, destSchema, destBitSet, src, srcSchema, srcBitSet, offset, useNewValueColumnQualifier);
public ProjectedValueTuple projectResults(Tuple tuple) { byte[] bytesValue = schema.toBytes(tuple, getExpressions(), valueSet, ptr); Cell base = tuple.getValue(0); return new ProjectedValueTuple(base.getRowArray(), base.getRowOffset(), base.getRowLength(), base.getTimestamp(), bytesValue, 0, bytesValue.length, valueSet.getEstimatedLength()); }
private ProjectedValueTuple convertLhs(Tuple lhs) throws IOException { ProjectedValueTuple t; if (lhs instanceof ProjectedValueTuple) { t = (ProjectedValueTuple) lhs; } else { ImmutableBytesWritable ptr = getContext().getTempPtr(); TupleProjector.decodeProjectedValue(lhs, ptr); lhsBitSet.clear(); lhsBitSet.or(ptr); int bitSetLen = lhsBitSet.getEstimatedLength(); t = new ProjectedValueTuple(lhs, lhs.getValue(0).getTimestamp(), ptr.get(), ptr.getOffset(), ptr.getLength(), bitSetLen); } return t; } };
final TupleProjector p = TupleProjector.deserializeProjectorFromScan(scan); final HashJoinInfo j = HashJoinInfo.deserializeHashJoinFromScan(scan); boolean useQualifierAsIndex = EncodedColumnsUtil.useQualifierAsIndex(getMinMaxQualifiersFromScan(scan))