public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument((filterArguments.isEmpty() || filterArguments.size() == 1), "Expected: 0 or 1 but got: %s", filterArguments.size()); KeyOnlyFilter filter = new KeyOnlyFilter(); if (filterArguments.size() == 1) { filter.lenAsVal = ParseFilter.convertByteArrayToBoolean(filterArguments.get(0)); } return filter; }
/** * @param pbBytes A pb serialized {@link KeyOnlyFilter} instance * @return An instance of {@link KeyOnlyFilter} made from <code>bytes</code> * @throws DeserializationException * @see #toByteArray */ public static KeyOnlyFilter parseFrom(final byte [] pbBytes) throws DeserializationException { FilterProtos.KeyOnlyFilter proto; try { proto = FilterProtos.KeyOnlyFilter.parseFrom(pbBytes); } catch (InvalidProtocolBufferException e) { throw new DeserializationException(e); } return new KeyOnlyFilter(proto.getLenAsVal()); }
s.setFilter(new KeyOnlyFilter());
scan.setFilter(new KeyOnlyFilter()); ResultScanner scanner = table.getScanner(scan); for (Result r : scanner) {
scan.setFilter(new FilterList(new FirstKeyOnlyFilter(), new KeyOnlyFilter()));
break; case KeyOnlyFilter: filter = new KeyOnlyFilter(); break; case MultipleColumnPrefixFilter: {
@Test public void testKeyOnlyFilter() throws Exception { // KeyOnlyFilter with lenAsVal KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true); assertTrue(keyOnlyFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter)))); // KeyOnlyFilter without lenAsVal keyOnlyFilter = new KeyOnlyFilter(); assertTrue(keyOnlyFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter)))); }
@Test public void testKeyOnlyFilterTransformCell() throws IOException { Cell c; KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 1, Bytes.toBytes("value1")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 2, Bytes.toBytes("value2")); Filter filter1 = new SingleColumnValueFilter(Bytes.toBytes("cf"), Bytes.toBytes("column1"), CompareOperator.EQUAL, Bytes.toBytes("value1")); Filter filter2 = new SingleColumnValueFilter(Bytes.toBytes("cf"), Bytes.toBytes("column1"), CompareOperator.EQUAL, Bytes.toBytes("value2")); FilterList internalFilterList = new FilterList(Operator.MUST_PASS_ONE, filter1, filter2); FilterList keyOnlyFilterFirst = new FilterList(Operator.MUST_PASS_ALL, new KeyOnlyFilter(), internalFilterList); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterFirst.filterCell(kv1)); c = keyOnlyFilterFirst.transformCell(kv1); assertEquals(0, c.getValueLength()); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterFirst.filterCell(kv2)); c = keyOnlyFilterFirst.transformCell(kv2); assertEquals(0, c.getValueLength()); internalFilterList.reset(); FilterList keyOnlyFilterLast = new FilterList(Operator.MUST_PASS_ALL, new KeyOnlyFilter(), internalFilterList); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterLast.filterCell(kv1)); c = keyOnlyFilterLast.transformCell(kv1); assertEquals(0, c.getValueLength()); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterLast.filterCell(kv2)); c = keyOnlyFilterLast.transformCell(kv2); assertEquals(0, c.getValueLength()); }
Filter filter = new KeyOnlyFilter(true); scan.setFilter(filter); ResultScanner scanner = ht.getScanner(scan);
scan.setReversed(true); scan.addFamily(FAMILY); Filter filter = new KeyOnlyFilter(true); scan.setFilter(filter); ResultScanner scanner = ht.getScanner(scan);
@Override protected boolean doAction() throws Exception { ResultScanner rs = null; try { Scan s = new Scan(); s.setBatch(2); s.addFamily(FAMILY); s.setFilter(new KeyOnlyFilter()); s.setMaxVersions(1); rs = table.getScanner(s); Result result = rs.next(); return result != null && result.size() > 0; } finally { if (rs != null) { rs.close(); } } } @Override
new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("fam"))), new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("qual1"))), new KeyOnlyFilter())), new FilterList(Operator.MUST_PASS_ALL, Lists.<Filter>newArrayList( new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("fam"))),
for (boolean useLen : new boolean[]{false,true}) { Scan s = new Scan(); s.setFilter(new KeyOnlyFilter(useLen)); verifyScan(s, expectedRows, expectedKeys); verifyScanFullNoValues(s, expectedKVs, useLen);
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument((filterArguments.isEmpty() || filterArguments.size() == 1), "Expected: 0 or 1 but got: %s", filterArguments.size()); KeyOnlyFilter filter = new KeyOnlyFilter(); if (filterArguments.size() == 1) { filter.lenAsVal = ParseFilter.convertByteArrayToBoolean(filterArguments.get(0)); } return filter; }
/** * On find key only. * * @param filterList * the filter list * @param isFindKeyOnly * the is find key only * @return the filter list */ private FilterList onFindKeyOnly(FilterList filterList, boolean isFindKeyOnly) { if (isFindKeyOnly) { if (filterList == null) { filterList = new FilterList(); } filterList.addFilter(new KeyOnlyFilter()); } return filterList; }
public static void main(String[] args) throws IOException { Configuration conf = HBaseConfiguration.create(); HBaseHelper helper = HBaseHelper.getHelper(conf); helper.dropTable("testtable"); helper.createTable("testtable", "colfam1"); System.out.println("Adding rows to table..."); helper.fillTableRandom("testtable", /* row */ 1, 5, 0, /* col */ 1, 30, 0, /* val */ 0, 10000, 0, true, "colfam1"); Connection connection = ConnectionFactory.createConnection(conf); table = connection.getTable(TableName.valueOf("testtable")); System.out.println("Scan #1"); // vv KeyOnlyFilterExample Filter filter1 = new KeyOnlyFilter(); scan(filter1); // ^^ KeyOnlyFilterExample System.out.println("Scan #2"); // vv KeyOnlyFilterExample Filter filter2 = new KeyOnlyFilter(true); scan(filter2); // ^^ KeyOnlyFilterExample } }
/** * @param pbBytes A pb serialized {@link KeyOnlyFilter} instance * @return An instance of {@link KeyOnlyFilter} made from <code>bytes</code> * @throws DeserializationException * @see #toByteArray */ public static KeyOnlyFilter parseFrom(final byte [] pbBytes) throws DeserializationException { FilterProtos.KeyOnlyFilter proto; try { proto = FilterProtos.KeyOnlyFilter.parseFrom(pbBytes); } catch (InvalidProtocolBufferException e) { throw new DeserializationException(e); } return new KeyOnlyFilter(proto.getLenAsVal()); }
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); } }
@Override public Object[] findIdsByColumn(String schemaName, String tableName, String pKeyName, String columnName, Object columnValue, Class entityClazz) { EntityMetadata m = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClazz); byte[] valueInBytes = HBaseUtils.getBytes(columnValue); Filter f = new SingleColumnValueFilter(Bytes.toBytes(tableName), Bytes.toBytes(columnName), CompareOp.EQUAL, valueInBytes); KeyOnlyFilter keyFilter = new KeyOnlyFilter(); FilterList filterList = new FilterList(f, keyFilter); try { return handler.scanRowyKeys(filterList, schemaName, tableName, columnName + "_" + columnValue, m .getIdAttribute().getBindableJavaType()); } catch (IOException e) { log.error("Error while executing findIdsByColumn(), Caused by: .", e); throw new KunderaException(e); } }
@Override public Object[] findIdsByColumn(String schemaName, String tableName, String pKeyName, String columnName, Object columnValue, Class entityClazz) { CompareOp operator = HBaseUtils.getOperator("=", false, false).getOperator(); EntityMetadata m = KunderaMetadataManager.getEntityMetadata(kunderaMetadata, entityClazz); byte[] valueInBytes = HBaseUtils.getBytes(columnValue); Filter f = new SingleColumnValueFilter(Bytes.toBytes(tableName), Bytes.toBytes(columnName), operator, valueInBytes); KeyOnlyFilter keyFilter = new KeyOnlyFilter(); FilterList filterList = new FilterList(f, keyFilter); try { return handler.scanRowyKeys(filterList, schemaName, tableName, columnName + "_" + columnValue, m .getIdAttribute().getBindableJavaType()); } catch (IOException e) { log.error("Error while executing findIdsByColumn(), Caused by: .", e); throw new KunderaException(e); } }