@Override public ResultScanner getScanner(Scan filter) throws IOException { return table.getScanner(filter); }
@Override public ResultScanner getScanner(Scan filter) throws IOException { return table.getScanner(filter); }
@Override public ResultScanner getScanner(Scan filter) throws IOException { return table.getScanner(filter); }
try (ResultScanner scanner = hTable.getScanner(s)) { int numResults = 0; for (Result rr = scanner.next(); rr != null; rr = scanner.next()) {
public Map<String, Optional<String>> findAll(String type) throws IOException { Scan scan = new Scan(); ResultScanner results = getTableInterface().getScanner(scan); Map<String, Optional<String>> allUserSettings = new HashMap<>(); for (Result result : results) { allUserSettings.put(new String(result.getRow()), getUserSettings(result, type)); } return allUserSettings; }
public Iterable<AccessTracker> loadAll(HTableInterface accessTrackerTable, final String columnFamily, final String name, final long earliest) throws IOException { Scan scan = new Scan(PersistentAccessTracker.AccessTrackerKey.getTimestampScanKey(name, earliest)); ResultScanner scanner = accessTrackerTable.getScanner(scan); return Iterables.transform(scanner, new Function<Result, AccessTracker>() { @Nullable @Override public AccessTracker apply(@Nullable Result result) { try { return deserializeTracker(result.getValue(Bytes.toBytes(columnFamily), COLUMN)); } catch (Exception e) { throw new RuntimeException("Unable to deserialize " + name + " @ " + earliest); } } }); }
public Map<String, Map<String, String>> findAll() throws IOException { Scan scan = new Scan(); ResultScanner results = getTableInterface().getScanner(scan); Map<String, Map<String, String>> allUserSettings = new HashMap<>(); for (Result result : results) { allUserSettings.put(new String(result.getRow()), getAllUserSettings(result)); } return allUserSettings; }
public HBaseClientKVIterator(HConnection hconn, String tableName, byte[] family, byte[] qualifier) throws IOException { this.family = family; this.qualifier = qualifier; this.table = hconn.getTable(tableName); this.scanner = table.getScanner(family, qualifier); this.iterator = scanner.iterator(); }
@Override protected ArrayList<String> listResourcesImpl(String resPath) throws IOException { assert resPath.startsWith("/"); String lookForPrefix = resPath.endsWith("/") ? resPath : resPath + "/"; byte[] startRow = Bytes.toBytes(lookForPrefix); byte[] endRow = Bytes.toBytes(lookForPrefix); endRow[endRow.length - 1]++; ArrayList<String> result = new ArrayList<String>(); HTableInterface table = getConnection().getTable(getAllInOneTableName()); Scan scan = new Scan(startRow, endRow); scan.setFilter(new KeyOnlyFilter()); try { ResultScanner scanner = table.getScanner(scan); for (Result r : scanner) { String path = Bytes.toString(r.getRow()); assert path.startsWith(lookForPrefix); int cut = path.indexOf('/', lookForPrefix.length()); String child = cut < 0 ? path : path.substring(0, cut); if (result.contains(child) == false) result.add(child); } } finally { IOUtils.closeQuietly(table); } // return null to indicate not a folder return result.isEmpty() ? null : result; }
scanner = hTable.getScanner(s); resultsIter = scanner.iterator();
Scan scan = new Scan(); scan.setFilter(new KeyOnlyFilter()); ResultScanner scanner = table.getScanner(scan); for (Result r : scanner) {
@Override public Object[] scanRowKeys(final HTableInterface hTable, final Filter filter, final String columnFamilyName, final String columnName, final Class rowKeyClazz) throws IOException { List<Object> rowKeys = new ArrayList<Object>(); if (scanner == null) { Scan s = new Scan(); s.setFilter(filter); s.addColumn(Bytes.toBytes(columnFamilyName), Bytes.toBytes(columnName)); scanner = hTable.getScanner(s); resultsIter = scanner.iterator(); } if (fetchSize == null) { for (Result result : scanner) { for (KeyValue keyValue : result.list()) { rowKeys.add(HBaseUtils.fromBytes(keyValue.getRow(), rowKeyClazz)); } } } if (rowKeys != null && !rowKeys.isEmpty()) { return rowKeys.toArray(new Object[0]); } return null; }
@After public void clearTable() throws Exception { List<Delete> deletions = new ArrayList<>(); for(Result r : table.getScanner(new Scan())) { deletions.add(new Delete(r.getRow())); } table.delete(deletions); }
private static void fullScan(HConnection conn, boolean[] hits, Stats stats) throws IOException { HTableInterface table = conn.getTable(TEST_TABLE); try { stats.markStart(); Scan scan = new Scan(); scan.addFamily(CF); ResultScanner scanner = table.getScanner(scan); int i = 0; for (Result r : scanner) { if (hits[i]) stats.consume(r); dot(i, N_ROWS); i++; } stats.markEnd(); } finally { IOUtils.closeQuietly(table); } }
@Test public void shouldFindAll() throws Exception { ResultScanner resultScanner = mock(ResultScanner.class); Result result1 = mock(Result.class); Result result2 = mock(Result.class); when(result1.getRow()).thenReturn("user1".getBytes()); when(result2.getRow()).thenReturn("user2".getBytes()); when(result1.getValue(cf, Bytes.toBytes("type"))).thenReturn("userSettings1String".getBytes()); when(result2.getValue(cf, Bytes.toBytes("type"))).thenReturn("userSettings2String".getBytes()); when(resultScanner.iterator()).thenReturn(Arrays.asList(result1, result2).iterator()); when(userSettingsTable.getScanner(any(Scan.class))).thenReturn(resultScanner); UserSettingsClient userSettingsClient = new UserSettingsClient(userSettingsTable, cf); assertEquals(new HashMap<String, Optional<String>>() {{ put("user1", Optional.of("userSettings1String")); put("user2", Optional.of("userSettings2String")); }}, userSettingsClient.findAll("type")); }
private Result getByScan(String path, byte[] family, byte[] column) throws IOException { byte[] startRow = Bytes.toBytes(path); byte[] endRow = plusZero(startRow); Scan scan = new Scan(startRow, endRow); if (family == null || column == null) { scan.setFilter(new KeyOnlyFilter()); } else { scan.addColumn(family, column); } HTableInterface table = getConnection().getTable(getAllInOneTableName()); try { ResultScanner scanner = table.getScanner(scan); Result result = null; for (Result r : scanner) { result = r; } return result == null || result.isEmpty() ? null : result; } finally { IOUtils.closeQuietly(table); } }
private static void testColumnScan(HConnection conn, List<Pair<Integer, Integer>> colScans) throws IOException { Stats stats = new Stats("COLUMN_SCAN"); HTableInterface table = conn.getTable(TEST_TABLE); try { stats.markStart(); int nLogicCols = colScans.size(); int nLogicRows = colScans.get(0).getSecond() - colScans.get(0).getFirst(); Scan[] scans = new Scan[nLogicCols]; ResultScanner[] scanners = new ResultScanner[nLogicCols]; for (int i = 0; i < nLogicCols; i++) { scans[i] = new Scan(); scans[i].addFamily(CF); scanners[i] = table.getScanner(scans[i]); } for (int i = 0; i < nLogicRows; i++) { for (int c = 0; c < nLogicCols; c++) { Result r = scanners[c].next(); stats.consume(r); } dot(i, nLogicRows); } stats.markEnd(); } finally { IOUtils.closeQuietly(table); } }
public TableResultIterator(StatementContext context, TableRef tableRef, Scan scan) throws SQLException { super(context, tableRef); htable = context.getConnection().getQueryServices().getTable(tableRef.getTable().getPhysicalName().getBytes()); try { delegate = new ScanningResultIterator(htable.getScanner(scan)); } catch (IOException e) { Closeables.closeQuietly(htable); throw ServerUtil.parseServerException(e); } }
scan.setFilter(new FirstKeyOnlyFilter()); scan.setTimeRange(0, ts+9); assertNull(htable.getScanner(scan).next()); conn5.close();
public static ResultScanner scanWithCoprocessorIfBeneficial(CubeSegment segment, Cuboid cuboid, TupleFilter tupleFiler, // Collection<TblColRef> groupBy, Collection<RowValueDecoder> rowValueDecoders, StorageContext context, HTableInterface table, Scan scan) throws IOException { if (context.isCoprocessorEnabled() == false) { return table.getScanner(scan); } CoprocessorRowType type = CoprocessorRowType.fromCuboid(segment, cuboid); CoprocessorFilter filter = CoprocessorFilter.fromFilter(segment, tupleFiler); CoprocessorProjector projector = CoprocessorProjector.makeForObserver(segment, cuboid, groupBy); ObserverAggregators aggrs = ObserverAggregators.fromValueDecoders(rowValueDecoders); if (DEBUG_LOCAL_COPROCESSOR) { RegionScanner innerScanner = new RegionScannerAdapter(table.getScanner(scan)); AggregationScanner aggrScanner = new AggregationScanner(type, filter, projector, aggrs, innerScanner); return new ResultScannerAdapter(aggrScanner); } else { scan.setAttribute(AggregateRegionObserver.COPROCESSOR_ENABLE, new byte[] { 0x01 }); scan.setAttribute(AggregateRegionObserver.TYPE, CoprocessorRowType.serialize(type)); scan.setAttribute(AggregateRegionObserver.PROJECTOR, CoprocessorProjector.serialize(projector)); scan.setAttribute(AggregateRegionObserver.AGGREGATORS, ObserverAggregators.serialize(aggrs)); scan.setAttribute(AggregateRegionObserver.FILTER, CoprocessorFilter.serialize(filter)); return table.getScanner(scan); } }