@Override public boolean next(ImmutableBytesWritable key, Result value) throws IOException { if (!delegate.nextKeyValue()) { return false; } ImmutableBytesWritable currentKey = delegate.getCurrentKey(); key.set(currentKey.get(), currentKey.getOffset(), currentKey.getLength()); value.copyFrom(delegate.getCurrentValue()); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (!tuple.getValue(QueryConstants.ARRAY_VALUE_COLUMN_FAMILY, QueryConstants.ARRAY_VALUE_COLUMN_QUALIFIER, ptr)) { return false; } int maxOffset = ptr.getOffset() + ptr.getLength(); arrayIndexesBitSet.or(ptr); arrayIndexesSchema.iterator(ptr, position, arrayIndexesBitSet); Boolean hasValue = arrayIndexesSchema.next(ptr, position, maxOffset, arrayIndexesBitSet); arrayIndexesBitSet.clear(); if (hasValue == null) { ptr.set(ByteUtil.EMPTY_BYTE_ARRAY); } return true; }
@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; }
private void writeResult(ImmutableBytesWritable key, Result result, Context context) throws IOException, InterruptedException { Put put = null; Delete delete = null; if (LOG.isTraceEnabled()) { LOG.trace("Considering the row." + Bytes.toString(key.get(), key.getOffset(), key.getLength())); } if (filter == null || !filter.filterRowKey(PrivateCellUtil.createFirstOnRow(key.get(), key.getOffset(), (short) key.getLength()))) { processKV(key, result, context, put, delete); } }
/** * @param row The current table row key. * @param value The columns. * @param context The current context. * @throws IOException When something is broken with the data. */ @Override public void map(ImmutableBytesWritable row, Result value, Context context) throws IOException { try { if (LOG.isTraceEnabled()) { LOG.trace("Considering the row." + Bytes.toString(row.get(), row.getOffset(), row.getLength())); } if (filter == null || !filter.filterRowKey(PrivateCellUtil.createFirstOnRow(row.get(), row.getOffset(), (short) row.getLength()))) { for (Cell kv : value.rawCells()) { kv = filterKv(filter, kv); // skip if we filtered it out if (kv == null) continue; context.write(row, new MapReduceExtendedCell(convertKv(kv, cfRenameMap))); } } } catch (InterruptedException e) { LOG.error("Interrupted while emitting Cell", e); Thread.currentThread().interrupt(); } }
/** * @param row The current table row key. * @param value The columns. * @param context The current context. * @throws IOException When something is broken with the data. */ @Override public void map(ImmutableBytesWritable row, Result value, Context context) throws IOException { try { if (LOG.isTraceEnabled()) { LOG.trace("Considering the row." + Bytes.toString(row.get(), row.getOffset(), row.getLength())); } if (filter == null || !filter.filterRowKey( PrivateCellUtil.createFirstOnRow(row.get(), row.getOffset(), (short) row.getLength()))) { for (Cell kv : value.rawCells()) { kv = filterKv(filter, kv); // skip if we filtered it out if (kv == null) continue; Cell ret = convertKv(kv, cfRenameMap); context.write(new CellWritableComparable(ret), ret); } } } catch (InterruptedException e) { LOG.error("Interrupted while emitting Cell", e); Thread.currentThread().interrupt(); } }
@Override public int getPartition(final ImmutableBytesWritable key, final VALUE value, final int reduces) { if (reduces == 1) return 0; if (this.lastReduces != reduces) { this.splits = Bytes.split(this.startkey, this.endkey, reduces - 1); for (int i = 0; i < splits.length; i++) { LOG.info(Bytes.toStringBinary(splits[i])); } this.lastReduces = reduces; } int pos = Bytes.binarySearch(this.splits, key.get(), key.getOffset(), key.getLength()); // Below code is from hfile index search. if (pos < 0) { pos++; pos *= -1; if (pos == 0) { // falls before the beginning of the file. throw new RuntimeException("Key outside start/stop range: " + key.toString()); } pos--; } return pos; }
@Override public Cell getValue(byte[] family, byte[] qualifier) { if (keyValue == null) { keyValue = PhoenixKeyValueUtil.newKeyValue(keyPtr.get(), keyPtr.getOffset(), keyPtr.getLength(), VALUE_COLUMN_FAMILY, VALUE_COLUMN_QUALIFIER, timestamp, projectedValue.get(), projectedValue.getOffset(), projectedValue.getLength()); } return keyValue; }
public final int compareTo(ImmutableBytesWritable ptr1, SortOrder ptr1SortOrder, ImmutableBytesWritable ptr2, SortOrder ptr2SortOrder, PDataType type2) { return compareTo(ptr1.get(), ptr1.getOffset(), ptr1.getLength(), ptr1SortOrder, ptr2.get(), ptr2.getOffset(), ptr2.getLength(), ptr2SortOrder, type2); }