@Override public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, TException { ResultScanner scanner = getScanner(scannerId); if (scanner == null) { TIllegalArgument ex = new TIllegalArgument(); ex.setMessage("Invalid scanner Id"); throw ex; } try { return resultsFromHBase(scanner.next(numRows)); } catch (IOException e) { throw getTIOError(e); } }
@Override public List<TResult> getScannerRows(int scannerId, int numRows) throws TIOError, TIllegalArgument, TException { ResultScanner scanner = getScanner(scannerId); if (scanner == null) { TIllegalArgument ex = new TIllegalArgument(); ex.setMessage("Invalid scanner Id"); throw ex; } try { connectionCache.updateConnectionAccessTime(); return resultsFromHBase(scanner.next(numRows)); } catch (IOException e) { throw getTIOError(e); } }
@Override public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, TException { LOG.debug("scannerClose: id=" + scannerId); ResultScanner scanner = getScanner(scannerId); if (scanner == null) { String message = "scanner ID is invalid"; LOG.warn(message); TIllegalArgument ex = new TIllegalArgument(); ex.setMessage("Invalid scanner Id"); throw ex; } scanner.close(); removeScanner(scannerId); }
@Override public void closeScanner(int scannerId) throws TIOError, TIllegalArgument, TException { if (removeScanner(scannerId) == null) { TIllegalArgument ex = new TIllegalArgument(); ex.setMessage("Invalid scanner Id"); throw ex; } }
@Test public void testScanWithVisibilityLabels() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<TColumnValue>(); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(("testScan" + i).getBytes()), columnValues); if (i == 5) { put.setCellVisibility(new TCellVisibility().setExpression(PUBLIC)); } else { put.setCellVisibility(new TCellVisibility().setExpression("(" + SECRET + "|" + CONFIDENTIAL + ")" + "&" + "!" + TOPSECRET)); } handler.put(table, put); } // create scan instance TScan scan = new TScan(); List<TColumn> columns = new ArrayList<TColumn>(); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow("testScan".getBytes()); scan.setStopRow("testScan\uffff".getBytes()); TAuthorization tauth = new TAuthorization(); List<String> labels = new ArrayList<String>(); labels.add(SECRET); labels.add(PRIVATE); tauth.setLabels(labels); scan.setAuthorizations(tauth); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(9, results.size()); Assert.assertFalse(Bytes.equals(results.get(5).getRow(), ("testScan" + 5).getBytes())); for (int i = 0; i < 9; i++) { if (i < 5) { assertArrayEquals(("testScan" + i).getBytes(), results.get(i).getRow()); } else if (i == 5) { continue; } else { assertArrayEquals(("testScan" + (i + 1)).getBytes(), results.get(i) .getRow()); } } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 9); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 9); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testScan() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<TColumnValue>(); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(("testScan" + i).getBytes()), columnValues); handler.put(table, put); } // create scan instance TScan scan = new TScan(); List<TColumn> columns = new ArrayList<TColumn>(); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow("testScan".getBytes()); scan.setStopRow("testScan\uffff".getBytes()); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(("testScan" + i).getBytes(), results.get(i).getRow()); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testReverseScan() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<TColumnValue>(); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(("testReverseScan" + i).getBytes()), columnValues); handler.put(table, put); } // create reverse scan instance TScan scan = new TScan(); scan.setReversed(true); List<TColumn> columns = new ArrayList<TColumn>(); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow("testReverseScan\uffff".getBytes()); scan.setStopRow("testReverseScan".getBytes()); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(("testReverseScan" + (9 - i)).getBytes(), results.get(i).getRow()); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testScanWithFilter() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<TColumnValue>(); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(("testScanWithFilter" + i).getBytes()), columnValues); handler.put(table, put); } // create scan instance with filter TScan scan = new TScan(); List<TColumn> columns = new ArrayList<TColumn>(); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow("testScanWithFilter".getBytes()); scan.setStopRow("testScanWithFilter\uffff".getBytes()); // only get the key part scan.setFilterString(wrap(("KeyOnlyFilter()").getBytes())); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(("testScanWithFilter" + i).getBytes(), results.get(i).getRow()); // check that the value is indeed stripped by the filter assertEquals(0, results.get(i).getColumnValues().get(0).getValue().length); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testScanWithVisibilityLabels() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<>(1); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(Bytes.toBytes("testScan" + i)), columnValues); if (i == 5) { put.setCellVisibility(new TCellVisibility().setExpression(PUBLIC)); } else { put.setCellVisibility(new TCellVisibility().setExpression("(" + SECRET + "|" + CONFIDENTIAL + ")" + "&" + "!" + TOPSECRET)); } handler.put(table, put); } // create scan instance TScan scan = new TScan(); List<TColumn> columns = new ArrayList<>(1); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow(Bytes.toBytes("testScan")); scan.setStopRow(Bytes.toBytes("testScan\uffff")); TAuthorization tauth = new TAuthorization(); List<String> labels = new ArrayList<>(2); labels.add(SECRET); labels.add(PRIVATE); tauth.setLabels(labels); scan.setAuthorizations(tauth); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(9, results.size()); Assert.assertFalse(Bytes.equals(results.get(5).getRow(), Bytes.toBytes("testScan" + 5))); for (int i = 0; i < 9; i++) { if (i < 5) { assertArrayEquals(Bytes.toBytes("testScan" + i), results.get(i).getRow()); } else if (i == 5) { continue; } else { assertArrayEquals(Bytes.toBytes("testScan" + (i + 1)), results.get(i) .getRow()); } } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 9); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 9); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testScan() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<>(1); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(Bytes.toBytes("testScan" + i)), columnValues); handler.put(table, put); } // create scan instance TScan scan = new TScan(); List<TColumn> columns = new ArrayList<>(1); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow(Bytes.toBytes("testScan")); scan.setStopRow(Bytes.toBytes("testScan\uffff")); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(Bytes.toBytes("testScan" + i), results.get(i).getRow()); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testReverseScan() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<>(1); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(Bytes.toBytes("testReverseScan" + i)), columnValues); handler.put(table, put); } // create reverse scan instance TScan scan = new TScan(); scan.setReversed(true); List<TColumn> columns = new ArrayList<>(1); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow(Bytes.toBytes("testReverseScan\uffff")); scan.setStopRow(Bytes.toBytes("testReverseScan")); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(Bytes.toBytes("testReverseScan" + (9 - i)), results.get(i).getRow()); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testScanWithFilter() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<>(1); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(Bytes.toBytes("testScanWithFilter" + i)), columnValues); handler.put(table, put); } // create scan instance with filter TScan scan = new TScan(); List<TColumn> columns = new ArrayList<>(1); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow(Bytes.toBytes("testScanWithFilter")); scan.setStopRow(Bytes.toBytes("testScanWithFilter\uffff")); // only get the key part scan.setFilterString(wrap(Bytes.toBytes("KeyOnlyFilter()"))); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(Bytes.toBytes("testScanWithFilter" + i), results.get(i).getRow()); // check that the value is indeed stripped by the filter assertEquals(0, results.get(i).getColumnValues().get(0).getValue().length); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testSmallScan() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = wrap(tableAname); // insert data TColumnValue columnValue = new TColumnValue(wrap(familyAname), wrap(qualifierAname), wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<>(); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(wrap(Bytes.toBytes("testSmallScan" + i)), columnValues); handler.put(table, put); } // small scan instance TScan scan = new TScan(); scan.setStartRow(Bytes.toBytes("testSmallScan")); scan.setStopRow(Bytes.toBytes("testSmallScan\uffff")); scan.setReadType(TReadType.PREAD); scan.setCaching(2); // get scanner and rows int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { // check if the rows are returned and in order assertArrayEquals(Bytes.toBytes("testSmallScan" + i), results.get(i).getRow()); } // check that we are at the end of the scan results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); // close scanner and check that it was indeed closed handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }
@Test public void testScan() throws Exception { ThriftHBaseServiceHandler handler = createHandler(); ByteBuffer table = ByteBuffer.wrap(tableAname); TScan scan = new TScan(); List<TColumn> columns = new ArrayList<TColumn>(); TColumn column = new TColumn(); column.setFamily(familyAname); column.setQualifier(qualifierAname); columns.add(column); scan.setColumns(columns); scan.setStartRow("testScan".getBytes()); TColumnValue columnValue = new TColumnValue(ByteBuffer.wrap(familyAname), ByteBuffer.wrap(qualifierAname), ByteBuffer.wrap(valueAname)); List<TColumnValue> columnValues = new ArrayList<TColumnValue>(); columnValues.add(columnValue); for (int i = 0; i < 10; i++) { TPut put = new TPut(ByteBuffer.wrap(("testScan" + i).getBytes()), columnValues); handler.put(table, put); } int scanId = handler.openScanner(table, scan); List<TResult> results = handler.getScannerRows(scanId, 10); assertEquals(10, results.size()); for (int i = 0; i < 10; i++) { assertArrayEquals(("testScan" + i).getBytes(), results.get(i).getRow()); } results = handler.getScannerRows(scanId, 10); assertEquals(0, results.size()); handler.closeScanner(scanId); try { handler.getScannerRows(scanId, 10); fail("Scanner id should be invalid"); } catch (TIllegalArgument e) { } }