private Filter substrFilterNew() { return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER, CompareOperator.EQUAL, new SubstringComparator(QUICK_SUBSTR)); }
/** * @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()); }
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; }
/** * 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 testRowFilter() throws Exception { RowFilter rowFilter = new RowFilter(CompareOperator.EQUAL, new SubstringComparator("testRowFilter")); assertTrue(rowFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter)))); }
@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)))); }
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); }
@Test public void testSubstringComparator() throws Exception { SubstringComparator substringComparator = new SubstringComparator("substr"); assertTrue(substringComparator.areSerializedFieldsEqual( ProtobufUtil.toComparator(ProtobufUtil.toComparator(substringComparator)))); }
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);
assertTrue(PrivateCellUtil.compareValue(kv, comparable) < 0); comparable = new SubstringComparator("cf"); assertEquals(0, PrivateCellUtil.compareFamily(bbCell, comparable)); assertEquals(0, PrivateCellUtil.compareFamily(kv, comparable));
/** * @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()); }
/** * 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"); }
Bytes.toBytes("col-5"), CompareFilter.CompareOp.NOT_EQUAL, new SubstringComparator("val-5")); filter.setFilterIfMissing(true);
new SubstringComparator(".4"));
new SubstringComparator("-5")); scan.setFilter(filter3); ResultScanner scanner3 = table.getScanner(scan);
assertTrue(PrivateCellUtil.compareValue(kv, comparable) < 0); comparable = new SubstringComparator("cf"); assertEquals(0, PrivateCellUtil.compareFamily(bbCell, comparable)); assertEquals(0, PrivateCellUtil.compareFamily(kv, comparable));