try { do { if (!scanner.hasMoreRows()) { return false; nextRows = scanner.nextRows();
while (scanner.hasMoreRows()) { RowResultIterator data = scanner.nextRows(); addAllRowsToResult(data, recordcount, querySchema, result); if (recordcount == result.size()) { RowResultIterator closer = scanner.close(); addAllRowsToResult(closer, recordcount, querySchema, result); } catch (TimeoutException te) {
int rowCount = 0; int loopCount = 0; if (scanner.hasMoreRows()) { loopCount++; RowResultIterator rri = scanner.nextRows(); rowCount += rri.getNumRows(); harness.getAsyncClient().newRpcProxy(scanner.currentTablet().getReplicaSelectedServerInfo( scanner.getReplicaSelection())).getConnection().disconnect(); while (scanner.hasMoreRows()) { loopCount++; RowResultIterator rri = scanner.nextRows(); rowCount += rri.getNumRows(); assertEquals(ROW_COUNT, rowCount); } finally { scanner.close();
@Override public List<String> listSchemaNames(KuduClient client) { try { if (rawSchemasTable == null) { if (!client.tableExists(rawSchemasTableName)) { createAndFillSchemasTable(client); } rawSchemasTable = getSchemasTable(client); } KuduScanner scanner = client.newScannerBuilder(rawSchemasTable).build(); RowResultIterator iterator = scanner.nextRows(); ArrayList<String> result = new ArrayList<>(); while (iterator != null) { for (RowResult row : iterator) { result.add(row.getString(0)); } iterator = scanner.nextRows(); } return result; } catch (KuduException e) { throw new PrestoException(GENERIC_INTERNAL_ERROR, e); } }
beginScanRecord.setTabletMetadata(kuduPartitionScanAssignmentMeta); while ( aPartitionSpecificScanner.hasMoreRows()) { LOG.debug("Number of columns being returned for this read " + aPartitionSpecificScanner.getProjectionSchema().getColumnCount()); RowResultIterator resultIterator = aPartitionSpecificScanner.nextRows(); if (resultIterator == null) { break; aPartitionSpecificScanner.close(); KuduRecordWithMeta<T> endScanRecord = new KuduRecordWithMeta<>(); endScanRecord.setEndOfScanMarker(true);
@Test(timeout = 100000) public void testReadAtSnapshotNoTimestamp() throws Exception { // Perform scan in READ_AT_SNAPSHOT mode with no snapshot timestamp // specified. Verify that the scanner timestamp is set from the tablet // server response. AsyncKuduScanner scanner = asyncClient.newScannerBuilder(table) .readMode(AsyncKuduScanner.ReadMode.READ_AT_SNAPSHOT) .build(); assertEquals(AsyncKuduClient.NO_TIMESTAMP, scanner.getSnapshotTimestamp()); KuduScanner syncScanner = new KuduScanner(scanner); assertEquals(scanner.getReadMode(), syncScanner.getReadMode()); assertTrue(syncScanner.hasMoreRows()); assertEquals(AsyncKuduClient.NO_TIMESTAMP, scanner.getSnapshotTimestamp()); int rowCount = syncScanner.nextRows().getNumRows(); // At this point, the call to the first tablet server should have been // done already, so check the snapshot timestamp. final long tsRef = scanner.getSnapshotTimestamp(); assertNotEquals(AsyncKuduClient.NO_TIMESTAMP, tsRef); assertTrue(syncScanner.hasMoreRows()); while (syncScanner.hasMoreRows()) { rowCount += syncScanner.nextRows().getNumRows(); assertEquals(tsRef, scanner.getSnapshotTimestamp()); } assertEquals(9, rowCount); }
scanner.keepAlive(); int accum = scanner.nextRows().getNumRows(); while (scanner.hasMoreRows()) { int rows = scanner.nextRows().getNumRows(); accum += rows; if (scanner.currentTablet() == null) { LOG.info(String.format("Between tablets after scanning %d rows", accum)); break; scanner.keepAlive(); accum += scanner.nextRows().getNumRows(); scanner.keepAlive(); while (scanner.hasMoreRows()) { accum += scanner.nextRows().getNumRows(); scanner.keepAlive(); fail("Exception was not thrown when calling keepAlive on a closed scanner"); } catch (IllegalStateException ex) {
KuduScanner syncScanner = new KuduScanner(scanner); assertTrue(syncScanner.hasMoreRows()); assertEquals(AsyncKuduClient.NO_TIMESTAMP, asyncClient.getLastPropagatedTimestamp()); assertEquals(KuduClient.NO_TIMESTAMP, client.getLastPropagatedTimestamp()); int rowCount = syncScanner.nextRows().getNumRows(); assertNotEquals(KuduClient.NO_TIMESTAMP, syncTsRef); assertTrue(syncScanner.hasMoreRows()); while (syncScanner.hasMoreRows()) { rowCount += syncScanner.nextRows().getNumRows(); final long asyncTs = asyncClient.getLastPropagatedTimestamp(); final long syncTs = client.getLastPropagatedTimestamp();
@Test(timeout = 100000) public void testScanTokenPropagatesTimestamp() throws Exception { // Initially, the client does not have the timestamp set. assertEquals(AsyncKuduClient.NO_TIMESTAMP, asyncClient.getLastPropagatedTimestamp()); assertEquals(KuduClient.NO_TIMESTAMP, client.getLastPropagatedTimestamp()); AsyncKuduScanner scanner = asyncClient.newScannerBuilder(table).build(); KuduScanner syncScanner = new KuduScanner(scanner); // Let the client receive the propagated timestamp in the scanner response. syncScanner.nextRows().getNumRows(); final long tsPrev = asyncClient.getLastPropagatedTimestamp(); final long tsPropagated = tsPrev + 1000000; ScanTokenPB.Builder pbBuilder = ScanTokenPB.newBuilder(); pbBuilder.setTableName(table.getName()); pbBuilder.setPropagatedTimestamp(tsPropagated); Client.ScanTokenPB scanTokenPB = pbBuilder.build(); final byte[] serializedToken = KuduScanToken.serialize(scanTokenPB); // Deserialize scan tokens and make sure the client's last propagated // timestamp is updated accordingly. assertEquals(tsPrev, asyncClient.getLastPropagatedTimestamp()); KuduScanToken.deserializeIntoScanner(serializedToken, client); assertEquals(tsPropagated, asyncClient.getLastPropagatedTimestamp()); }
.readMode(AsyncKuduScanner.ReadMode.READ_YOUR_WRITES) .build(); KuduScanner syncScanner = new KuduScanner(scanner); assertEquals(scanner.getReadMode(), syncScanner.getReadMode()); assertEquals(AsyncKuduClient.NO_TIMESTAMP, scanner.getSnapshotTimestamp()); syncScanner.close(); .readMode(AsyncKuduScanner.ReadMode.READ_YOUR_WRITES) .build(); syncScanner = new KuduScanner(scanner); assertTrue(preTs < asyncClient.getLastPropagatedTimestamp()); preTs = asyncClient.getLastPropagatedTimestamp(); syncScanner.close();
.replicaSelection(replicaSelection) .build(); KuduScanner syncScanner = new KuduScanner(scanner); long preTs = asyncClient.getLastPropagatedTimestamp(); assertNotEquals(AsyncKuduClient.NO_TIMESTAMP, syncScanner.close();
@Override public void close() { if (scanner != null) { try { scanner.close(); } catch (KuduException e) { e.printStackTrace(); } } }
@Test(timeout = 100000) @Ignore("TODO(KUDU-2415)") // not fixed yet! public void testReadYourWritesFreshClientFreshTable() throws Exception { // NOTE: this test fails because the first tablet in the table // is empty and has never been written to. // Perform scan in READ_YOUR_WRITES mode. Before the scan, verify that the // propagated timestamp is unset, since this is a fresh client. AsyncKuduScanner scanner = asyncClient.newScannerBuilder(table) .readMode(AsyncKuduScanner.ReadMode.READ_YOUR_WRITES) .build(); KuduScanner syncScanner = new KuduScanner(scanner); assertEquals(scanner.getReadMode(), syncScanner.getReadMode()); assertEquals(AsyncKuduClient.NO_TIMESTAMP, asyncClient.getLastPropagatedTimestamp()); assertEquals(AsyncKuduClient.NO_TIMESTAMP, scanner.getSnapshotTimestamp()); assertEquals(9, countRowsInScan(syncScanner)); }
/** * Builds a {@link KuduScanner} using the passed configurations. * @return a new {@link KuduScanner} */ @Override public KuduScanner build() { return new KuduScanner(new AsyncKuduScanner( client, table, projectedColumnNames, projectedColumnIndexes, readMode, isFaultTolerant, scanRequestTimeout, predicates, limit, cacheBlocks, prefetching, lowerBoundPrimaryKey, upperBoundPrimaryKey, htTimestamp, batchSizeBytes, PartitionPruner.create(this), replicaSelection)); } }
int previousRow = -1; int tableBoundariesCount = 0; if (scanner.hasMoreRows()) { RowResultIterator rri = scanner.nextRows(); while (rri.hasNext()) { int key = rri.next().getInt(0); harness.restartTabletServer(scanner.currentTablet()); } else { harness.killTabletLeader(scanner.currentTablet()); while (scanner.hasMoreRows()) { RowResultIterator rri = scanner.nextRows(); while (rri.hasNext()) { int key = rri.next().getInt(0); if (finishFirstScan && !failureInjected) { if (restart) { harness.restartTabletServer(scanner.currentTablet()); } else { harness.killTabletLeader(scanner.currentTablet()); assertEquals(TABLET_COUNT, tableBoundariesCount); } finally { scanner.close();
private static RowResult getOneRowResult(KuduScanner scanner) throws KuduException { RowResultIterator rowResults; rowResults = scanner.nextRows(); if (rowResults.getNumRows() == 0) { return null; } if (rowResults.getNumRows() > 1) { throw new RuntimeException("Received too many rows from scanner " + scanner); } return rowResults.next(); }
@Override public int next() { int rowCount = 0; try { while (iterator == null || !iterator.hasNext()) { if (!scanner.hasMoreRows()) { iterator = null; return 0; } context.getStats().startWait(); try { iterator = scanner.nextRows(); } finally { context.getStats().stopWait(); } } for (; rowCount < TARGET_RECORD_COUNT && iterator.hasNext(); rowCount++) { addRowResult(iterator.next(), rowCount); } } catch (Exception ex) { throw new RuntimeException(ex); } for (ProjectedColumnInfo pci : projectedCols) { pci.vv.getMutator().setValueCount(rowCount); } return rowCount; }
while (scanner.hasMoreRows() && count < limit) { RowResultIterator rowResults = scanner.nextRows(); count = printNodesAndGetNewCount(count, limit, rowResults); RowResultIterator rowResults = scanner.close(); printNodesAndGetNewCount(count, limit, rowResults);
@Override public void open(KuduInputSplit split) throws IOException { endReached = false; startTableContext(); scanner = tableContext.scanner(split.getScanToken()); resultIterator = scanner.nextRows(); }