public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 1, "Expected 1 but got: %s", filterArguments.size()); byte [] columnPrefix = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); return new ColumnPrefixFilter(columnPrefix); }
/** * @param o the other filter to compare with * @return true if and only if the fields of the filter that are serialized * are equal to the corresponding fields in other. Used for testing. */ @Override boolean areSerializedFieldsEqual(Filter o) { if (o == this) return true; if (!(o instanceof ColumnPrefixFilter)) return false; ColumnPrefixFilter other = (ColumnPrefixFilter)o; return Bytes.equals(this.getPrefix(), other.getPrefix()); }
@Override public ReturnCode filterCell(final Cell cell) { if (this.prefix == null) { return ReturnCode.INCLUDE; } else { return filterColumn(cell); } }
@Test public void testColumnPrefixFilter() throws Exception { // empty string ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("")); assertTrue(columnPrefixFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter)))); // non-empty string columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("")); assertTrue(columnPrefixFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter)))); }
public ReturnCode filterColumn(Cell cell) { int qualifierLength = cell.getQualifierLength(); if (qualifierLength < prefix.length) { int cmp = compareQualifierPart(cell, qualifierLength, this.prefix); if (cmp <= 0) { return ReturnCode.SEEK_NEXT_USING_HINT; } else { return ReturnCode.NEXT_ROW; } } else { int cmp = compareQualifierPart(cell, this.prefix.length, this.prefix); if (cmp < 0) { return ReturnCode.SEEK_NEXT_USING_HINT; } else if (cmp > 0) { return ReturnCode.NEXT_ROW; } else { return ReturnCode.INCLUDE; } } }
@Override public boolean equals(Object obj) { return obj instanceof Filter && areSerializedFieldsEqual((Filter) obj); }
@Test public void testColumnPrefixFilter() throws Exception { // empty string ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("")); assertTrue(columnPrefixFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter)))); // non-empty string columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes("")); assertTrue(columnPrefixFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter)))); }
public ReturnCode filterColumn(Cell cell) { int qualifierLength = cell.getQualifierLength(); if (qualifierLength < prefix.length) { int cmp = compareQualifierPart(cell, qualifierLength, this.prefix); if (cmp <= 0) { return ReturnCode.SEEK_NEXT_USING_HINT; } else { return ReturnCode.NEXT_ROW; } } else { int cmp = compareQualifierPart(cell, this.prefix.length, this.prefix); if (cmp < 0) { return ReturnCode.SEEK_NEXT_USING_HINT; } else if (cmp > 0) { return ReturnCode.NEXT_ROW; } else { return ReturnCode.INCLUDE; } } }
/** * @param pbBytes A pb serialized {@link ColumnPrefixFilter} instance * @return An instance of {@link ColumnPrefixFilter} made from <code>bytes</code> * @throws org.apache.hadoop.hbase.exceptions.DeserializationException * @see #toByteArray */ public static ColumnPrefixFilter parseFrom(final byte [] pbBytes) throws DeserializationException { FilterProtos.ColumnPrefixFilter proto; try { proto = FilterProtos.ColumnPrefixFilter.parseFrom(pbBytes); } catch (InvalidProtocolBufferException e) { throw new DeserializationException(e); } return new ColumnPrefixFilter(proto.getPrefix().toByteArray()); }
@Override public int hashCode() { return Bytes.hashCode(this.getPrefix()); } }
@Override public ReturnCode filterCell(final Cell cell) { if (this.prefix == null) { return ReturnCode.INCLUDE; } else { return filterColumn(cell); } }
public ReturnCode filterColumn(Cell cell) { int qualifierLength = cell.getQualifierLength(); if (qualifierLength < prefix.length) { int cmp = compareQualifierPart(cell, qualifierLength, this.prefix); if (cmp <= 0) { return ReturnCode.SEEK_NEXT_USING_HINT; } else { return ReturnCode.NEXT_ROW; } } else { int cmp = compareQualifierPart(cell, this.prefix.length, this.prefix); if (cmp < 0) { return ReturnCode.SEEK_NEXT_USING_HINT; } else if (cmp > 0) { return ReturnCode.NEXT_ROW; } else { return ReturnCode.INCLUDE; } } }
static Scan createScanForSpaceSnapshotSizes(TableName table) { Scan s = new Scan(); if (null == table) { // Read all tables, just look at the row prefix s.setRowPrefixFilter(QUOTA_TABLE_ROW_KEY_PREFIX); } else { // Fetch the exact row for the table byte[] rowkey = getTableRowKey(table); // Fetch just this one row s.withStartRow(rowkey).withStopRow(rowkey, true); } // Just the usage family and only the snapshot size qualifiers return s.addFamily(QUOTA_FAMILY_USAGE).setFilter( new ColumnPrefixFilter(QUOTA_SNAPSHOT_SIZE_QUALIFIER)); }
@Test public void testColumnPrefixFilter() throws IOException { String filterString = " ColumnPrefixFilter('qualifier' ) "; ColumnPrefixFilter columnPrefixFilter = doTestFilter(filterString, ColumnPrefixFilter.class); byte [] columnPrefix = columnPrefixFilter.getPrefix(); assertEquals("qualifier", new String(columnPrefix, StandardCharsets.UTF_8)); }
@Override public ReturnCode filterCell(final Cell cell) { if (this.prefix == null) { return ReturnCode.INCLUDE; } else { return filterColumn(cell); } }
/** * Test partial Result re-assembly in the presence of different filters. The Results from the * partial scanner should match the Results returned from a scanner that receives all of the * results in one RPC to the server. The partial scanner is tested with a variety of different * result sizes (all of which are less than the size necessary to fetch an entire row) * @throws Exception */ @Test public void testPartialResultsWithColumnFilter() throws Exception { testPartialResultsWithColumnFilter(new FirstKeyOnlyFilter()); testPartialResultsWithColumnFilter(new ColumnPrefixFilter(Bytes.toBytes("testQualifier5"))); testPartialResultsWithColumnFilter(new ColumnRangeFilter(Bytes.toBytes("testQualifer1"), true, Bytes.toBytes("testQualifier7"), true)); Set<byte[]> qualifiers = new LinkedHashSet<>(); qualifiers.add(Bytes.toBytes("testQualifier5")); testPartialResultsWithColumnFilter(new FirstKeyValueMatchingQualifiersFilter(qualifiers)); }
break; case ColumnPrefixFilter: byte[] src = ((ColumnPrefixFilter)filter).getPrefix(); this.value = Bytes.toString(Base64.getEncoder().encode(src)); break;
@Override public ReturnCode filterKeyValue(Cell kv) { if (this.prefix == null || kv.getQualifierArray() == null) { return ReturnCode.INCLUDE; } else { return filterColumn(kv.getQualifierArray(), kv.getQualifierOffset(), kv.getQualifierLength()); } }
break; case ColumnPrefixFilter: filter = new ColumnPrefixFilter(Base64.getDecoder().decode(value)); break; case ColumnRangeFilter:
@Test public void testCompoundFilter4() throws IOException { String filterString = " ColumnPrefixFilter ('realtime') OR " + "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')"; FilterList filterList = doTestFilter(filterString, FilterList.class); ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters(); assertTrue(filters.get(0) instanceof ColumnPrefixFilter); assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); assertTrue(filters.get(2) instanceof SkipFilter); ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0); FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1); SkipFilter skipFilter = (SkipFilter) filters.get(2); byte [] columnPrefix = columnPrefixFilter.getPrefix(); assertEquals("realtime", new String(columnPrefix, StandardCharsets.UTF_8)); assertTrue(skipFilter.getFilter() instanceof FamilyFilter); FamilyFilter familyFilter = (FamilyFilter) skipFilter.getFilter(); assertEquals(CompareOperator.EQUAL, familyFilter.getCompareOperator()); assertTrue(familyFilter.getComparator() instanceof SubstringComparator); SubstringComparator substringComparator = (SubstringComparator) familyFilter.getComparator(); assertEquals("hihi", new String(substringComparator.getValue(), StandardCharsets.UTF_8)); }