@Override public boolean getValue(byte[] family, byte[] qualifier, ImmutableBytesWritable ptr) { return delegate.getValue(family, qualifier, ptr); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { return tuple.getValue(cf, cq, ptr); }
@Override public Cell getValue(int index) { return delegate.getValue(index); }
@Override public Cell getValue(byte[] family, byte[] qualifier) { return delegate.getValue(family, qualifier); }
public static void decodeProjectedValue(Tuple tuple, ImmutableBytesWritable ptr) throws IOException { boolean b = tuple.getValue(VALUE_COLUMN_FAMILY, VALUE_COLUMN_QUALIFIER, ptr); if (!b) { // fall back to use the old value column qualifier for backward compatibility b = tuple.getValue(VALUE_COLUMN_FAMILY, OLD_VALUE_COLUMN_QUALIFIER, ptr); } if (!b) throw new IOException("Trying to decode a non-projected value."); }
private boolean nextInQueue(List<Cell> results) { if (resultQueue.isEmpty()) { return false; } Tuple tuple = resultQueue.poll(); for (int i = 0; i < tuple.size(); i++) { results.add(tuple.getValue(i)); } return (count++ < limit) && (resultQueue.isEmpty() ? hasMore : true); }
private void offerResult(Tuple tuple, boolean projected, List<Cell> result) { if (!projected || !addArrayCell) { resultQueue.offer(tuple); return; } Cell projectedCell = tuple.getValue(0); int arrayCellPosition = RegionScannerFactory.getArrayCellPosition(result); Cell arrayCell = result.get(arrayCellPosition); List<Cell> cells = new ArrayList<Cell>(2); cells.add(projectedCell); cells.add(arrayCell); MultiKeyValueTuple multi = new MultiKeyValueTuple(cells); resultQueue.offer(multi); }
@Override public void readFields(ResultSet resultSet) throws SQLException { // we do this once per mapper. if(columnCount == -1) { this.columnCount = resultSet.getMetaData().getColumnCount(); } if (columnCount > 0) { this.rowTs = resultSet.unwrap(PhoenixResultSet.class).getCurrentRow().getValue(0).getTimestamp(); } values = Lists.newArrayListWithCapacity(columnCount); for(int i = 0 ; i < columnCount ; i++) { Object value = resultSet.getObject(i + 1); values.add(value); } }
@Override protected int sizeOf(Tuple e) { KeyValue kv = PhoenixKeyValueUtil.maybeCopyCell(e.getValue(0)); return Bytes.SIZEOF_INT * 2 + kv.getLength(); }
private List<KeyValue> toKeyValues(ResultEntry entry) { Tuple result = entry.getResult(); int size = result.size(); List<KeyValue> kvs = new ArrayList<KeyValue>(size); for (int i = 0; i < size; i++) { kvs.add(PhoenixKeyValueUtil.maybeCopyCell(result.getValue(i))); } return kvs; }
public static int write(Tuple result, DataOutput out) throws IOException { int size = 0; for(int i = 0; i < result.size(); i++) { KeyValue kv = PhoenixKeyValueUtil.maybeCopyCell(result.getValue(i)); size += kv.getLength(); size += Bytes.SIZEOF_INT; // kv.getLength } WritableUtils.writeVInt(out, size); for(int i = 0; i < result.size(); i++) { KeyValue kv = PhoenixKeyValueUtil.maybeCopyCell(result.getValue(i)); out.writeInt(kv.getLength()); out.write(kv.getBuffer(), kv.getOffset(), kv.getLength()); } return size; } }
@Override public boolean next(List<Cell> results) throws IOException { try { if (isFilterDone()) { return false; } for (int i = 0; i < tuple.size(); i++) { results.add(tuple.getValue(i)); } tuple = iterator.next(); return !isFilterDone(); } catch (Throwable t) { ServerUtil.throwIOException(region.getRegionInfo().getRegionNameAsString(), t); return false; } }
public ProjectedValueTuple projectResults(Tuple tuple, boolean useNewValueQualifier) { long maxTS = tuple.getValue(0).getTimestamp(); int nCells = tuple.size(); for (int i = 1; i < nCells; i++) { long ts = tuple.getValue(i).getTimestamp(); if (ts > maxTS) { maxTS = ts; } } byte[] bytesValue = schema.toBytes(tuple, getExpressions(), valueSet, ptr); Cell base = tuple.getValue(0); if (useNewValueQualifier) { return new ProjectedValueTuple(base.getRowArray(), base.getRowOffset(), base.getRowLength(), maxTS, bytesValue, 0, bytesValue.length, valueSet.getEstimatedLength()); } else { return new OldProjectedValueTuple(base.getRowArray(), base.getRowOffset(), base.getRowLength(), maxTS, bytesValue, 0, bytesValue.length, valueSet.getEstimatedLength()); } }
@Override public boolean next(List<Cell> results) throws IOException { try { if (isFilterDone()) { return false; } for (int i = 0; i < tuple.size(); i++) { results.add(tuple.getValue(i)); } tuple = iterator.next(); return !isFilterDone(); } catch (Throwable t) { ServerUtil.throwIOException(getRegion().getRegionInfo().getRegionNameAsString(), t); return false; } }
@Override public ImmutableBytesWritable getLatestValue(ColumnReference ref, long ts) throws IOException { Cell cell = rs.getCurrentRow().getValue(ref.getFamily(), ref.getQualifier()); if (cell == null) { return null; } valuePtr.set(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()); return valuePtr; }
public static Integer getRemainingOffset(Tuple offsetTuple) { if (offsetTuple != null) { ImmutableBytesPtr rowKeyPtr = new ImmutableBytesPtr(); offsetTuple.getKey(rowKeyPtr); if (QueryConstants.OFFSET_ROW_KEY_PTR.compareTo(rowKeyPtr) == 0) { Cell cell = offsetTuple.getValue(QueryConstants.OFFSET_FAMILY, QueryConstants.OFFSET_COLUMN); return PInteger.INSTANCE.toObject(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength(), PInteger.INSTANCE, SortOrder.ASC, null, null); } } return null; }
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()); }
@SuppressWarnings("deprecation") @Override protected void writeToBuffer(MappedByteBuffer buffer, Tuple e) { KeyValue kv = PhoenixKeyValueUtil.maybeCopyCell(e.getValue(0)); buffer.putInt(kv.getLength() + Bytes.SIZEOF_INT); buffer.putInt(kv.getLength()); buffer.put(kv.getBuffer(), kv.getOffset(), kv.getLength()); }
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; } };
@Override public MutationState execute() throws SQLException { connection.getMutationState().commitDDLFence(dataTable); Tuple tuple = plan.iterator().next(); long rowCount = 0; if (tuple != null) { Cell kv = tuple.getValue(0); ImmutableBytesWritable tmpPtr = new ImmutableBytesWritable(kv.getValueArray(), kv.getValueOffset(), kv.getValueLength()); // A single Cell will be returned with the count(*) - we decode that here rowCount = PLong.INSTANCE.getCodec().decodeLong(tmpPtr, SortOrder.getDefault()); } // The contract is to return a MutationState that contains the number of rows modified. In this // case, it's the number of rows in the data table which corresponds to the number of index // rows that were added. return new MutationState(0, 0, connection, rowCount); }