public static <T> Map<Cell, T> convertRowResultsToCells(Collection<RowResult<T>> rows) { Map<Cell, T> ret = Maps.newHashMapWithExpectedSize(rows.size()); for (RowResult<T> row : rows) { byte[] rowName = row.getRowName(); for (Map.Entry<byte[], T> col : row.getColumns().entrySet()) { Cell cell = Cell.create(rowName, col.getKey()); ret.put(cell, col.getValue()); } } return ret; }
public static <T, U> Function<RowResult<T>, RowResult<U>> transformValues(final Function<T, U> transform) { return row -> RowResult.create(row.getRowName(), Maps.transformValues(row.getColumns(), transform)); }
public static long getApproximateSizeOfRowResult(RowResult<byte[]> rr) { long size = rr.getRowName().length; for (Map.Entry<Cell, byte[]> entry : rr.getCells()) { size += Cells.getApproxSizeOfCell(entry.getKey()) + entry.getValue().length; } return size; } }
MapEntries.putAll(vals, item.getCells()); if (Arrays.equals(item.getRowName(), "row1".getBytes())) { assertEquals(3, IterableView.of(item.getCells()).size()); assertEquals("v5", new String(item.getColumns().get("col1".getBytes())));
private static <T> Function<Entry<byte[], SortedMap<byte[], T>>, RowResult<T>> createRowResultFunction() { return entry -> RowResult.create(entry.getKey(), entry.getValue()); }
finalResults.add(RowResult.create(entry.getKey(), entry.getValue())); byte[] lastRow = Iterables.getLast(finalResults).getRowName(); if (!RangeRequests.isTerminalRow(rangeRequest.isReverse(), lastRow)) { nextRow = RangeRequests.getNextStartRow(rangeRequest.isReverse(), lastRow);
@Override public TokenBackedBasicResultsPage<RowResult<Set<Value>>, byte[]> withHandle(Handle handle) throws Exception { Collection<byte[]> rows = getRowsInRange(tableName, rangeRequest, timestamp, maxRows, handle); if (rows.isEmpty()) { return SimpleTokenBackedResultsPage.create(rangeRequest.getStartInclusive(), Collections.<RowResult<Set<Value>>> emptyList(), false); } ListMultimap<Cell, Value> timestamps = getAllVersionsInternal(tableName, rows, RangeRequests.extractColumnSelection(rangeRequest), timestamp); final Ordering<RowResult<Set<Value>>> ordering = RowResult.getOrderingByRowName(rangeRequest.isReverse()); final SortedSet<RowResult<Set<Value>>> result = ImmutableSortedSet.orderedBy(ordering) .addAll(AtlasSqlUtils.cellsToRows(timestamps)).build(); return SimpleTokenBackedResultsPage.create( AtlasSqlUtils.generateToken(rangeRequest, result.last().getRowName()), assertThatRowResultsAreOrdered(result, rangeRequest), rows.size() == maxRows); } });
private void cacheLoadedRows(TableReference tableRef, Iterable<RowResult<byte[]>> rowView) { for (RowResult<byte[]> loadedRow : rowView) { for (Map.Entry<Cell, byte[]> e : loadedRow.getCells()) { cacheLoadedCell(tableRef, e.getKey(), e.getValue()); } } }
public static <T> Ordering<RowResult<T>> getOrderingByRowName(boolean reverse) { Ordering<RowResult<T>> ordering = getOrderingByRowName(); if (reverse) { return ordering.reverse(); } return ordering; }
throw Throwables.throwUncheckedException(e); MapEntries.putAll(vals, item.getCells()); if (Arrays.equals(item.getRowName(), "row1".getBytes())) { assertEquals("v5", new String(item.getColumns().get("col1".getBytes()))); assertEquals(3, IterableView.of(item.getCells()).size());
public static <T> SortedMap<byte[], RowResult<T>> viewOfSortedMap(SortedMap<byte[], SortedMap<byte[], T>> map) { return Maps.transformEntries(map, (key, value) -> RowResult.create(key, value)); }
finalResults.add(RowResult.create(entry.getKey(), entry.getValue())); byte[] lastRow = Iterables.getLast(finalResults).getRowName(); if (!RangeRequests.isTerminalRow(rangeRequest.isReverse(), lastRow)) { nextRow = RangeRequests.getNextStartRow(rangeRequest.isReverse(), lastRow);
@Override public TokenBackedBasicResultsPage<RowResult<Set<Long>>, byte[]> withHandle(Handle handle) throws Exception { Collection<byte[]> rows = getRowsInRange(tableName, rangeRequest, timestamp, maxRows, handle); if (rows.isEmpty()) { return SimpleTokenBackedResultsPage.create(rangeRequest.getStartInclusive(), Collections.<RowResult<Set<Long>>> emptyList(), false); } ColumnSelection columns = RangeRequests.extractColumnSelection(rangeRequest); ListMultimap<Cell,Long> timestamps = getAllTimestampsInternal(tableName, rows, columns, timestamp); final Ordering<RowResult<Set<Long>>> ordering = RowResult.<Set<Long>>getOrderingByRowName(rangeRequest.isReverse()); final SortedSet<RowResult<Set<Long>>> result = ImmutableSortedSet.orderedBy(ordering) .addAll(AtlasSqlUtils.cellsToRows(timestamps)).build(); return new SimpleTokenBackedResultsPage<RowResult<Set<Long>>, byte[]>( AtlasSqlUtils.generateToken(rangeRequest, result.last().getRowName()), assertThatRowResultsAreOrdered(result, rangeRequest), rows.size() == maxRows); } });
private List<Entry<Cell, ByteBuffer>> filterWritesFromRows( Iterable<RowResult<byte[]>> rows, @Nullable Map<Cell, byte[]> writes) { List<Entry<Cell, ByteBuffer>> rowsWithoutWrites = Lists.newArrayList(); for (RowResult<byte[]> row : rows) { rowsWithoutWrites.addAll(filterWritesFromCells(row.getCells(), writes)); } return rowsWithoutWrites; }
private static Iterator<RowResult<byte[]>> mergeInLocalWritesRows( Iterator<RowResult<byte[]>> postFilterIterator, Iterator<RowResult<byte[]>> localWritesInRange, boolean isReverse) { Ordering<RowResult<byte[]>> ordering = RowResult.getOrderingByRowName(); Iterator<RowResult<byte[]>> mergeIterators = IteratorUtils.mergeIterators( postFilterIterator, localWritesInRange, isReverse ? ordering.reverse() : ordering, from -> RowResults.merge(from.lhSide, from.rhSide)); // prefer local writes return RowResults.filterDeletedColumnsAndEmptyRows(mergeIterators); }
private static Multimap<ValueStreamMetadataRow, ValueStreamMetadataNamedColumnValue<?>> getRowMapFromRowResults(Collection<RowResult<byte[]>> rowResults) { Multimap<ValueStreamMetadataRow, ValueStreamMetadataNamedColumnValue<?>> rowMap = HashMultimap.create(); for (RowResult<byte[]> result : rowResults) { ValueStreamMetadataRow row = ValueStreamMetadataRow.BYTES_HYDRATOR.hydrateFromBytes(result.getRowName()); for (Entry<byte[], byte[]> e : result.getColumns().entrySet()) { rowMap.put(row, shortNameToHydrator.get(PtBytes.toString(e.getKey())).hydrateFromBytes(e.getValue())); } } return rowMap; }
public static <T> Function<RowResult<T>, RowResult<T>> createFilterColumns(final Predicate<byte[]> keepColumn) { return row -> RowResult.create(row.getRowName(), Maps.filterKeys(row.getColumns(), keepColumn)); }
MapEntries.putAll(vals, item.getCells()); if (Arrays.equals(item.getRowName(), "row1".getBytes())) { assertEquals(3, IterableView.of(item.getCells()).size()); assertEquals("v5", new String(item.getColumns().get("col1".getBytes())));
private void markRangeRead(TableReference table, RangeRequest range, List<RowResult<byte[]>> result) { if (!isSerializableTable(table)) { return; } ConcurrentNavigableMap<Cell, byte[]> reads = getReadsForTable(table); for (RowResult<byte[]> row : result) { Map<Cell, byte[]> map = Maps2.fromEntries(row.getCells()); map = transformGetsForTesting(map); reads.putAll(map); } setRangeEnd(table, range, Iterables.getLast(result).getRowName()); }
private Optional<RowResult<Value>> getCurrentRowResult() { ImmutableSortedMap<byte[], Value> cells = currentRowCells.build(); if (cells.isEmpty()) { return Optional.empty(); } else { return Optional.of(RowResult.create(currentRowName, cells)); } }