private Filter substrFilterNew() { return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER, CompareOperator.EQUAL, new SubstringComparator(QUICK_SUBSTR)); }
@Test public void testSubstringComparator() throws Exception { SubstringComparator substringComparator = new SubstringComparator("substr"); assertTrue(substringComparator.areSerializedFieldsEqual( ProtobufUtil.toComparator(ProtobufUtil.toComparator(substringComparator)))); }
@Test public void testValueFilter() throws IOException { String filterString = "ValueFilter(!=, 'substring:pre')"; ValueFilter valueFilter = doTestFilter(filterString, ValueFilter.class); assertEquals(CompareOperator.NOT_EQUAL, valueFilter.getCompareOperator()); assertTrue(valueFilter.getComparator() instanceof SubstringComparator); SubstringComparator substringComparator = (SubstringComparator) valueFilter.getComparator(); assertEquals("pre", new String(substringComparator.getValue(), StandardCharsets.UTF_8)); }
/** * @param pbBytes A pb serialized {@link SubstringComparator} instance * @return An instance of {@link SubstringComparator} made from <code>bytes</code> * @throws DeserializationException * @see #toByteArray */ public static SubstringComparator parseFrom(final byte [] pbBytes) throws DeserializationException { ComparatorProtos.SubstringComparator proto; try { proto = ComparatorProtos.SubstringComparator.parseFrom(pbBytes); } catch (InvalidProtocolBufferException e) { throw new DeserializationException(e); } return new SubstringComparator(proto.getSubstr()); }
@Test public void testSubstringComparator() throws Exception { SubstringComparator substringComparator = new SubstringComparator("substr"); assertTrue(substringComparator.areSerializedFieldsEqual( ProtobufUtil.toComparator(ProtobufUtil.toComparator(substringComparator)))); }
@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)); }
public ByteArrayComparable build() { ByteArrayComparable comparator; switch (ComparatorType.valueOf(type)) { case BinaryComparator: comparator = new BinaryComparator(Base64.getDecoder().decode(value)); break; case BinaryPrefixComparator: comparator = new BinaryPrefixComparator(Base64.getDecoder().decode(value)); break; case BitComparator: comparator = new BitComparator(Base64.getDecoder().decode(value), BitComparator.BitwiseOp.valueOf(op)); break; case NullComparator: comparator = new NullComparator(); break; case RegexStringComparator: comparator = new RegexStringComparator(value); break; case SubstringComparator: comparator = new SubstringComparator(value); break; default: throw new RuntimeException("unhandled comparator type: " + type); } return comparator; }
@Test public void testCompoundFilter3() throws IOException { String filterString = " ColumnPrefixFilter ('realtime')AND " + "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')"; FilterList filterList = doTestFilter(filterString, FilterList.class); ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters(); assertTrue(filters.get(0) instanceof FilterList); assertTrue(filters.get(1) instanceof SkipFilter); filterList = (FilterList) filters.get(0); SkipFilter skipFilter = (SkipFilter) filters.get(1); filters = (ArrayList<Filter>) filterList.getFilters(); assertTrue(filters.get(0) instanceof ColumnPrefixFilter); assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0); byte [] columnPrefix = columnPrefixFilter.getPrefix(); assertEquals("realtime", new String(columnPrefix, StandardCharsets.UTF_8)); FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1); 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)); }
/** * Parses a comparator of the form comparatorType:comparatorValue form and returns a comparator * <p> * @param comparator the comparator in the form comparatorType:comparatorValue * @return the parsed comparator */ public static ByteArrayComparable createComparator (byte [] comparator) { if (comparator == null) throw new IllegalArgumentException("Incorrect Comparator"); byte [][] parsedComparator = ParseFilter.parseComparator(comparator); byte [] comparatorType = parsedComparator[0]; byte [] comparatorValue = parsedComparator[1]; if (Bytes.equals(comparatorType, ParseConstants.binaryType)) return new BinaryComparator(comparatorValue); else if (Bytes.equals(comparatorType, ParseConstants.binaryPrefixType)) return new BinaryPrefixComparator(comparatorValue); else if (Bytes.equals(comparatorType, ParseConstants.regexStringType)) return new RegexStringComparator(new String(comparatorValue, StandardCharsets.UTF_8)); else if (Bytes.equals(comparatorType, ParseConstants.substringType)) return new SubstringComparator(new String(comparatorValue, StandardCharsets.UTF_8)); else throw new IllegalArgumentException("Incorrect comparatorType"); }
@Test public void testCompoundFilter3() throws IOException { String filterString = " ColumnPrefixFilter ('realtime')AND " + "FirstKeyOnlyFilter() OR SKIP FamilyFilter(=, 'substring:hihi')"; FilterList filterList = doTestFilter(filterString, FilterList.class); ArrayList<Filter> filters = (ArrayList<Filter>) filterList.getFilters(); assertTrue(filters.get(0) instanceof FilterList); assertTrue(filters.get(1) instanceof SkipFilter); filterList = (FilterList) filters.get(0); SkipFilter skipFilter = (SkipFilter) filters.get(1); filters = (ArrayList<Filter>) filterList.getFilters(); assertTrue(filters.get(0) instanceof ColumnPrefixFilter); assertTrue(filters.get(1) instanceof FirstKeyOnlyFilter); ColumnPrefixFilter columnPrefixFilter = (ColumnPrefixFilter) filters.get(0); byte [] columnPrefix = columnPrefixFilter.getPrefix(); assertEquals("realtime", new String(columnPrefix, StandardCharsets.UTF_8)); FirstKeyOnlyFilter firstKeyOnlyFilter = (FirstKeyOnlyFilter) filters.get(1); 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)); }
@Test public void testRowFilter() throws Exception { RowFilter rowFilter = new RowFilter(CompareOperator.EQUAL, new SubstringComparator("testRowFilter")); assertTrue(rowFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter)))); }
@Test public void testValueFilter() throws IOException { String filterString = "ValueFilter(!=, 'substring:pre')"; ValueFilter valueFilter = doTestFilter(filterString, ValueFilter.class); assertEquals(CompareOperator.NOT_EQUAL, valueFilter.getCompareOperator()); assertTrue(valueFilter.getComparator() instanceof SubstringComparator); SubstringComparator substringComparator = (SubstringComparator) valueFilter.getComparator(); assertEquals("pre", new String(substringComparator.getValue(), StandardCharsets.UTF_8)); }
@Test public void testFilterList() throws Exception { // empty filter list FilterList filterList = new FilterList(new LinkedList<>()); assertTrue(filterList.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList)))); // non-empty filter list LinkedList<Filter> list = new LinkedList<>(); list.add(new ColumnCountGetFilter(1)); list.add(new RowFilter(CompareOperator.EQUAL, new SubstringComparator("testFilterList"))); assertTrue(filterList.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList)))); }
@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)); }
SingleColumnValueFilter filter = new SingleColumnValueFilter( Bytes.toBytes(columnFamily), Bytes.toBytes("c5"), CompareOperator .EQUAL, new SubstringComparator("2_c5"));
@Test public void testFilterList() throws IOException { // Test getting a single row, single key using Row, Qualifier, and Value // regular expression and substring filters // Use must pass all List<Filter> filters = new ArrayList<>(); filters.add(new RowFilter(CompareOperator.EQUAL, new RegexStringComparator(".+-2"))); filters.add(new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator(".+-2"))); filters.add(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("One"))); Filter f = new FilterList(Operator.MUST_PASS_ALL, filters); Scan s = new Scan(); s.addFamily(FAMILIES[0]); s.setFilter(f); KeyValue [] kvs = { new KeyValue(ROWS_ONE[2], FAMILIES[0], QUALIFIERS_ONE[2], VALUES[0]) }; verifyScanFull(s, kvs); // Test getting everything with a MUST_PASS_ONE filter including row, qf, val // regular expression and substring filters filters.clear(); filters.add(new RowFilter(CompareOperator.EQUAL, new RegexStringComparator(".+Two.+"))); filters.add(new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator(".+-2"))); filters.add(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("One"))); f = new FilterList(Operator.MUST_PASS_ONE, filters); s = new Scan(); s.setFilter(f); verifyScanNoEarlyOut(s, this.numRows, this.colsPerRow); }
new SubstringComparator("c5")); PageFilter f2 = new PageFilter(2); fs.add(f1);
new RegexStringComparator(".+-2"))); filters.add(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("One"))); Filter f = new FilterList(Operator.MUST_PASS_ALL, filters); Scan s = new Scan(); new RegexStringComparator(".+-2"))); filters.add(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("One"))); f = new FilterList(Operator.MUST_PASS_ONE, filters); s = new Scan();
new Scan().setFilter(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("value-a"))) .setMaxVersions(3); ResultScanner scanner = table.getScanner(scan); .setFilter(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("value-a"))) .setMaxVersions(3); result = table.get(get); new Scan().setFilter(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("value-a"))) .setMaxVersions(1); scanner = table.getScanner(scan); .setFilter(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("value-a"))) .setMaxVersions(1); result = table.get(get); new Scan().setFilter(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("value-a"))) .setMaxVersions(5); scanner = table.getScanner(scan); .setFilter(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("value-a"))) .setMaxVersions(5); result = table.get(get);
get.setFilter(new ValueFilter(CompareOp.EQUAL, new SubstringComparator("value"))); res = region.get(get);