throws IOException { Scan scan = new Scan().withStartRow(get.getRow()).withStopRow(get.getRow(), true).readAllVersions(); NavigableMap<byte[], NavigableMap<byte[], MutableLong>> sums = new TreeMap<>(Bytes.BYTES_COMPARATOR); }); List<Cell> cells = new ArrayList<>(); try (RegionScanner scanner = c.getEnvironment().getRegion().getScanner(scan)) { boolean moreRows; do { moreRows = scanner.next(cells); for (Cell cell : cells) { byte[] family = CellUtil.cloneFamily(cell); byte[] qualifier = CellUtil.cloneQualifier(cell); long value = Bytes.toLong(cell.getValueArray(), cell.getValueOffset()); sums.get(family).get(qualifier).add(value);
private void initiateScan(HRegion region) throws IOException { Scan scan = new Scan(); scan.setCaching(1); RegionScanner resScanner = null; try { resScanner = region.getScanner(scan); List<Cell> results = new ArrayList<>(); boolean next = resScanner.next(results); try { counter.incrementAndGet(); latch.await(); } catch (InterruptedException e) { } while (next) { next = resScanner.next(results); } } finally { scanCompletedCounter.incrementAndGet(); resScanner.close(); } } }
@Override public boolean isFilterDone() throws IOException { return delegate.isFilterDone(); }
protected List<List<Cell>> getExistingLabelsWithAuths() throws IOException { Scan scan = new Scan(); RegionScanner scanner = labelsRegion.getScanner(scan); List<List<Cell>> existingLabels = new ArrayList<>(); try { while (true) { List<Cell> cells = new ArrayList<>(); scanner.next(cells); if (cells.isEmpty()) { break; } existingLabels.add(cells); } } finally { scanner.close(); } return existingLabels; }
RegionScanner s = rsh.s; LOG.info("Scanner " + this.scannerName + " lease expired on region " + s.getRegionInfo().getRegionNameAsString()); HRegion region = null; try { region = regionServer.getRegion(s.getRegionInfo().getRegionName()); if (region != null && region.getCoprocessorHost() != null) { region.getCoprocessorHost().preScannerClose(s); LOG.error("Closing scanner for " + s.getRegionInfo().getRegionNameAsString(), e); } finally { try { s.close(); if (region != null && region.getCoprocessorHost() != null) { region.getCoprocessorHost().postScannerClose(s); LOG.error("Closing scanner for " + s.getRegionInfo().getRegionNameAsString(), e);
private PSchema buildDeletedSchema(byte[] key, ImmutableBytesPtr cacheKey, Region region, long clientTimeStamp) throws IOException { if (clientTimeStamp == HConstants.LATEST_TIMESTAMP) { return null; } Scan scan = MetaDataUtil.newTableRowsScan(key, clientTimeStamp, HConstants.LATEST_TIMESTAMP); scan.setFilter(new FirstKeyOnlyFilter()); scan.setRaw(true); List<Cell> results = Lists.<Cell> newArrayList(); try (RegionScanner scanner = region.getScanner(scan);) { scanner.next(results); } // HBase ignores the time range on a raw scan (HBASE-7362) if (!results.isEmpty() && results.get(0).getTimestamp() > clientTimeStamp) { Cell kv = results.get(0); if (kv.getTypeByte() == Type.Delete.getCode()) { Cache<ImmutableBytesPtr, PMetaDataEntity> metaDataCache = GlobalCache.getInstance(this.env) .getMetaDataCache(); PSchema schema = newDeletedSchemaMarker(kv.getTimestamp()); metaDataCache.put(cacheKey, schema); return schema; } } return null; }
if (buildDeletedFunction(keys.get(0), new FunctionBytesPtr(keys.get(0)), env.getRegion(), clientTimeStamp) != null) { return new MetaDataMutationResult(MutationCode.FUNCTION_ALREADY_EXISTS, EnvironmentEdgeManager.currentTimeMillis(), null); Region region = env.getRegion(); Scan scan = MetaDataUtil.newTableRowsScan(keys.get(0), MIN_TABLE_TIMESTAMP, clientTimeStamp); List<Cell> results = Lists.newArrayList(); try (RegionScanner scanner = region.getScanner(scan);) { scanner.next(results); if (results.isEmpty()) { // Should not be possible return new MetaDataMutationResult(MutationCode.FUNCTION_NOT_FOUND, EnvironmentEdgeManager.currentTimeMillis(), null); Delete delete = new Delete(kv.getRowArray(), kv.getRowOffset(), kv.getRowLength(), clientTimeStamp); functionMetaData.add(delete); results.clear(); scanner.next(results); } while (!results.isEmpty());
ArrayList<Cell> result = Lists.newArrayList(); boolean hasMore = true; while (hasMore) { result.clear(); hasMore = aggrScanner.next(result); if (result.isEmpty()) continue; fail(); hcol.measureCodec.decode(ByteBuffer.wrap(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()), hcol.measureValues); String rowKey = toString(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength(), mask); String col = Bytes.toString(hcol.family) + ":" + Bytes.toString(hcol.qualifier); String values = Arrays.toString(hcol.measureValues); aggrScanner.close();
public void visitCube(final RpcController controller, final CubeVisitProtos.CubeVisitRequest request, RpcCallback<CubeVisitProtos.CubeVisitResponse> done) { List<RegionScanner> regionScanners = Lists.newArrayList(); HRegion region = null; region = (HRegion) env.getRegion(); region.startRegionOperation(); debugGitTag = region.getTableDesc().getValue(IRealizationConstants.HTableGitTag); checkDeadline(deadline); List<List<Integer>> hbaseColumnsToGT = Lists.newArrayList(); for (IntList intList : request.getHbaseColumnsToGTList()) { hbaseColumnsToGT.add(intList.getIntsList()); final List<InnerScannerAsIterator> cellListsForeachRawScan = Lists.newArrayList(); RegionScanner innerScanner = region.getScanner(scan); regionScanners.add(innerScanner); int counter = 0; for (RegionScanner innerScanner : regionScanners) { while (innerScanner.nextRaw(temp)) { counter++;
private PSchema getSchema(RegionScanner scanner, long clientTimeStamp) throws IOException, SQLException { List<Cell> results = Lists.newArrayList(); scanner.next(results); if (results.isEmpty()) { return null; } Cell keyValue = results.get(0); byte[] keyBuffer = keyValue.getRowArray(); int keyLength = keyValue.getRowLength(); int keyOffset = keyValue.getRowOffset(); PName tenantId = newPName(keyBuffer, keyOffset, keyLength); int tenantIdLength = (tenantId == null) ? 0 : tenantId.getBytes().length; if (tenantIdLength == 0) { tenantId = null; } PName schemaName = newPName(keyBuffer, keyOffset + tenantIdLength + 1, keyLength - tenantIdLength - 1); long timeStamp = keyValue.getTimestamp(); return new PSchema(schemaName.getString(), timeStamp); }
@Test public void testNoMeasure() throws IOException { CoprocessorRowType rowType = newRowType(); CoprocessorProjector projector = new CoprocessorProjector(mask); ObserverAggregators aggregators = new ObserverAggregators(new HCol[] {}); CoprocessorFilter filter = CoprocessorFilter.deserialize(null); // a default, // always-true, // filter HashSet<String> expectedResult = new HashSet<String>(); expectedResult.add("\\x02\\x02\\x00\\x00"); expectedResult.add("\\x01\\x01\\x00\\x00"); MockupRegionScanner innerScanner = new MockupRegionScanner(cellsInput); RegionScanner aggrScanner = new AggregationScanner(rowType, filter, projector, aggregators, innerScanner); ArrayList<Cell> result = Lists.newArrayList(); boolean hasMore = true; while (hasMore) { result.clear(); hasMore = aggrScanner.next(result); if (result.isEmpty()) continue; Cell cell = result.get(0); String rowKey = toString(cell.getRowArray(), cell.getRowOffset(), cell.getRowLength(), mask); assertTrue(expectedResult.contains(rowKey)); } aggrScanner.close(); }
@Test public void testReverseScanWithoutPadding() throws Exception { byte[] row1 = Bytes.toBytes("a"); byte[] row2 = Bytes.toBytes("ab"); byte[] row3 = Bytes.toBytes("b"); Put put1 = new Put(row1); put1.addColumn(cfName, cqName, HConstants.EMPTY_BYTE_ARRAY); Put put2 = new Put(row2); put2.addColumn(cfName, cqName, HConstants.EMPTY_BYTE_ARRAY); Put put3 = new Put(row3); put3.addColumn(cfName, cqName, HConstants.EMPTY_BYTE_ARRAY); List<Cell> res = new ArrayList<>(); int count = 1; while (scanner.next(res)) { count++; assertEquals("b", Bytes.toString(res.get(0).getRowArray(), res.get(0).getRowOffset(), res.get(0).getRowLength())); assertEquals("ab", Bytes.toString(res.get(1).getRowArray(), res.get(1).getRowOffset(), res.get(1).getRowLength()));
@Test public void testReverseScanWithPadding() throws Exception { byte[] terminator = new byte[] { -1 }; byte[] row1 = Bytes.add(invert(Bytes.toBytes("a")), terminator); byte[] row2 = Bytes.add(invert(Bytes.toBytes("ab")), terminator); byte[] row3 = Bytes.add(invert(Bytes.toBytes("b")), terminator); Put put1 = new Put(row1); put1.addColumn(cfName, cqName, HConstants.EMPTY_BYTE_ARRAY); Put put2 = new Put(row2); put2.addColumn(cfName, cqName, HConstants.EMPTY_BYTE_ARRAY); Put put3 = new Put(row3); put3.addColumn(cfName, cqName, HConstants.EMPTY_BYTE_ARRAY); region.put(put1); region.put(put2); region.put(put3); region.flush(true); Scan scan = new Scan(); scan.setCacheBlocks(false); scan.setReversed(true); scan.setFilter(new FirstKeyOnlyFilter()); scan.addFamily(cfName); RegionScanner scanner = region.getScanner(scan); List<Cell> res = new ArrayList<>(); int count = 1; while (scanner.next(res)) { count++; } assertEquals(3, count); }
@SuppressWarnings("unchecked") @Test public void testCorrectOrderingWithLazyLoadingColumns() throws Exception { Put m = new Put(row); m.add(fam, qual, ts, val); Mockito.when(env.getConfiguration()).thenReturn(conf); Mockito.when(env.getRegion()).thenReturn(region); RegionScanner scanner = Mockito.mock(RegionScanner.class); Mockito.when(region.getScanner(Mockito.any(Scan.class))).thenReturn(scanner); final byte[] stored = Bytes.toBytes("stored-value"); Mockito.when(scanner.next(Mockito.any(List.class))).thenAnswer(new Answer<Boolean>() { @Override public Boolean answer(InvocationOnMock invocation) throws Throwable { LocalTableState table = new LocalTableState(env, state, m); table.addPendingUpdates(m.get(fam, qual));
@Test public void testToShowNPEOnRegionScannerReseek() throws Exception { byte[] family = Bytes.toBytes("family"); this.region = initHRegion(tableName, method, CONF, family); Put put = new Put(Bytes.toBytes("r1")); put.addColumn(family, Bytes.toBytes("q1"), Bytes.toBytes("v1")); region.put(put); put = new Put(Bytes.toBytes("r2")); put.addColumn(family, Bytes.toBytes("q1"), Bytes.toBytes("v1")); region.put(put); region.flush(true); Scan scan = new Scan(); scan.setMaxVersions(3); // open the first scanner RegionScanner scanner1 = region.getScanner(scan); System.out.println("Smallest read point:" + region.getSmallestReadPoint()); region.compact(true); scanner1.reseek(Bytes.toBytes("r2")); List<Cell> results = new ArrayList<>(); scanner1.next(results); Cell keyValue = results.get(0); Assert.assertTrue(Bytes.compareTo(CellUtil.cloneRow(keyValue), Bytes.toBytes("r2")) == 0); scanner1.close(); }
threads[i].join(); RegionScanner regionScanner = region.getScanner(new Scan()); List<Cell> cells = new ArrayList<>(100); while(regionScanner.next(cells)) continue; assertEquals(THREAD_COUNT, cells.size()); long total = 0; for (Cell cell: cells) total += Bytes.toLong(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()); assertEquals(INCREMENT_COUNT * THREAD_COUNT, total); } finally {
@Test public void testCompactionAffectedByScanners() throws Exception { byte[] family = Bytes.toBytes("family"); this.region = initHRegion(tableName, method, CONF, family); Put put = new Put(Bytes.toBytes("r1")); put.addColumn(family, Bytes.toBytes("q1"), Bytes.toBytes("v1")); region.put(put); region.flush(true); Scan scan = new Scan(); scan.setMaxVersions(3); RegionScanner scanner1 = region.getScanner(scan); Delete delete = new Delete(Bytes.toBytes("r1")); scanner1.next(results); System.out.println(results); assertEquals(1, results.size()); scanner2.next(results); System.out.println(results); assertEquals(0, results.size()); scanner3.next(results); System.out.println(results); assertEquals(0, results.size());
this.region = TEST_UTIL.createLocalHRegion(htd, null, null); Put[] puts = new Put[1]; Put put = new Put(Bytes.toBytes("r1")); put.addColumn(Bytes.toBytes(family), Bytes.toBytes("q1"), Bytes.toBytes("10")); puts[0] = put; region.batchMutate(puts, HConstants.NO_NONCE, HConstants.NO_NONCE); MultithreadedTestUtil.TestContext ctx = new MultithreadedTestUtil.TestContext(conf); Scan s = new Scan(); RegionScanner scanner = region.getScanner(s); List<Cell> results = new ArrayList<>(); ScannerContext scannerContext = ScannerContext.newBuilder().setBatchLimit(2).build(); scanner.next(results, scannerContext); for (Cell keyValue : results) { assertEquals("50",Bytes.toString(CellUtil.cloneValue(keyValue)));
this.region.put(p); p.addColumn(FAMILIES[1], QUALIFIER, VALUES[1]); this.region.put(p); this.region.flush(true); Scan s = new Scan(); s.setStartRow(ROWS_FOUR[1]); RegionScanner scanner = region.getScanner(s); scanner.reseek(ROWS_THREE[1]); List<Cell> results = new ArrayList<>(); scanner.next(results); for (Cell keyValue : results) { assertTrue("The rows with ROWS_TWO as row key should be appearing.", scanner.reseek(ROWS_ONE[1]); results = new ArrayList<>(); scanner.next(results); for (Cell keyValue : results) { assertFalse("Cannot rewind back to a value less than previous reseek.", Bytes.toString(CellUtil.cloneRow(keyValue)).contains("testRowOne"));
synchronized(region) { LOG.debug("flushing"); region.flush(true); if (i%100==0) { region.compact(false); List<Mutation> mrm = new ArrayList<>(); if (op) { Put p = new Put(row2, ts); p.addColumn(fam1, qual1, value1); p.setDurability(Durability.ASYNC_WAL); mrm.add(p); Delete d = new Delete(row); mrm.add(p); region.mutateRowsWithLocks(mrm, rowsToLock, HConstants.NO_NONCE, HConstants.NO_NONCE); op ^= true; Scan s = new Scan(row); RegionScanner rs = region.getScanner(s); List<Cell> r = new ArrayList<>(); while (rs.next(r)) rs.close(); if (r.size() != 1) { LOG.debug(Objects.toString(r));