Refine search
Filter f = new SkipFilter(new QualifierFilter(CompareOperator.NOT_EQUAL, new BinaryComparator(Bytes.toBytes("testQualifierOne-2")))); Scan s = new Scan(); s.setFilter(f);
@Test public void testQualifierFilter() throws IOException { String filterString = "QualifierFilter(=, 'regexstring:pre*')"; QualifierFilter qualifierFilter = doTestFilter(filterString, QualifierFilter.class); assertEquals(CompareOperator.EQUAL, qualifierFilter.getCompareOperator()); assertTrue(qualifierFilter.getComparator() instanceof RegexStringComparator); RegexStringComparator regexStringComparator = (RegexStringComparator) qualifierFilter.getComparator(); assertEquals("pre*", new String(regexStringComparator.getValue(), StandardCharsets.UTF_8)); }
@Test public void testQualifierFilter() throws Exception { QualifierFilter qualifierFilter = new QualifierFilter(CompareOperator.EQUAL, new NullComparator()); assertTrue(qualifierFilter.areSerializedFieldsEqual( ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter)))); }
@Override public ReturnCode filterCell(final Cell c) { if (compareQualifier(getCompareOperator(), this.comparator, c)) { return ReturnCode.SKIP; } return ReturnCode.INCLUDE; }
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"))), new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("qual2")))))));
byte [][] ROWS = makeN(ROW, 10); byte [][] QUALIFIERS = { Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"), Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"), Bytes.toBytes("col4-<d2v1>-<d3v2>"), Bytes.toBytes("col5-<d2v1>-<d3v2>"), Bytes.toBytes("col6-<d2v1>-<d3v2>"), Bytes.toBytes("col7-<d2v1>-<d3v2>"), Filter filter = new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator("col[1-5]")); scan.setFilter(filter);
byte[] rowPrefix = Bytes.toBytes((cluster + Constants.SEP + user + Constants.SEP + appId + Constants.SEP)); byte[] scanStartRow; Bytes.add(rowPrefix, Bytes.toBytes(endRunId), Constants.SEP_BYTES); } else { scanStartRow = rowPrefix; filters.addFilter(new QualifierFilter(CompareFilter.CompareOp.NOT_EQUAL, new RegexStringComparator( "^c\\!((?!" + Constants.HRAVEN_QUEUE + ").)*$")));
static private void removeTablePermissions(TableName tableName, byte[] column, Table table, boolean closeTable) throws IOException { Scan scan = new Scan(); scan.addFamily(ACL_LIST_FAMILY); String columnName = Bytes.toString(column); scan.setFilter(new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator( String.format("(%s%s%s)|(%s%s)$", ACL_KEY_DELIMITER, columnName, ACL_KEY_DELIMITER, ACL_KEY_DELIMITER, columnName)))); Set<byte[]> qualifierSet = new TreeSet<>(Bytes.BYTES_COMPARATOR); ResultScanner scanner = null; try { scanner = table.getScanner(scan); for (Result res : scanner) { for (byte[] q : res.getFamilyMap(ACL_LIST_FAMILY).navigableKeySet()) { qualifierSet.add(q); } } if (qualifierSet.size() > 0) { Delete d = new Delete(tableName.getName()); for (byte[] qualifier : qualifierSet) { d.addColumns(ACL_LIST_FAMILY, qualifier); } table.delete(d); } } finally { if (scanner != null) scanner.close(); if (closeTable) table.close(); } }
/** * @param columns columns to filter * @return filter that will skip any {@link KeyValue} that doesn't match one of the passed columns * and the */ private Filter getColumnFilters(Collection<? extends ColumnReference> columns) { // each column needs to be added as an OR, so we need to separate them out FilterList columnFilters = new FilterList(FilterList.Operator.MUST_PASS_ONE); // create a filter that matches each column reference for (ColumnReference ref : columns) { Filter columnFilter = new FamilyFilter(CompareOp.EQUAL, new BinaryComparator(ref.getFamily())); // combine with a match for the qualifier, if the qualifier is a specific qualifier if (!Bytes.equals(ColumnReference.ALL_QUALIFIERS, ref.getQualifier())) { columnFilter = new FilterList(columnFilter, new QualifierFilter(CompareOp.EQUAL, new BinaryComparator( ref.getQualifier()))); } columnFilters.addFilter(columnFilter); } return columnFilters; }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { ArrayList<?> arguments = CompareFilter.extractArguments(filterArguments); CompareOperator compareOp = (CompareOperator)arguments.get(0); ByteArrayComparable comparator = (ByteArrayComparable)arguments.get(1); return new QualifierFilter(compareOp, comparator); }
@Override public boolean equals(Object obj) { return obj instanceof Filter && areSerializedFieldsEqual((Filter) obj); }
new BinaryComparator(Bytes.toBytes("row-03"))); filters.add(filter1); new BinaryComparator(Bytes.toBytes("row-06"))); filters.add(filter2); Filter filter3 = new QualifierFilter(CompareFilter.CompareOp.EQUAL, new RegexStringComparator("col-0[03]")); filters.add(filter3); for (Cell cell : result.rawCells()) { System.out.println("Cell: " + cell + ", Value: " + Bytes.toString(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength()));
Table ht = TEST_UTIL.createTable(tableName, FAMILY); byte[][] ROWS = makeN(ROW, 10); byte[][] QUALIFIERS = { Bytes.toBytes("col0-<d2v1>-<d3v2>"), Bytes.toBytes("col1-<d2v1>-<d3v2>"), Bytes.toBytes("col2-<d2v1>-<d3v2>"), Bytes.toBytes("col3-<d2v1>-<d3v2>"), Bytes.toBytes("col4-<d2v1>-<d3v2>"), scan.setReversed(true); scan.addFamily(FAMILY); Filter filter = new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator("col[1-5]")); scan.setFilter(filter);
byte[] rowPrefix = Bytes.toBytes((cluster + Constants.SEP + user + Constants.SEP + appId + Constants.SEP)); byte[] scanStartRow; Bytes.add(rowPrefix, Bytes.toBytes(endRunId), Constants.SEP_BYTES); } else { scanStartRow = rowPrefix; filters.addFilter(new QualifierFilter(CompareFilter.CompareOp.NOT_EQUAL, new RegexStringComparator( "^c\\!((?!" + Constants.HRAVEN_QUEUE + ").)*$")));
LOG.debug("Removing permissions of removed column " + Bytes.toString(column) + " from table "+ tableName); scan.addFamily(ACL_LIST_FAMILY); String columnName = Bytes.toString(column); scan.setFilter(new QualifierFilter(CompareOp.EQUAL, new RegexStringComparator( String.format("(%s%s%s)|(%s%s)$", ACL_KEY_DELIMITER, columnName, ACL_KEY_DELIMITER,
new FamilyFilter(CompareOp.EQUAL, new BinaryComparator(ref.getFamily())); if (!Bytes.equals(ColumnReference.ALL_QUALIFIERS, ref.getQualifier())) { columnFilter = new FilterList(columnFilter, new QualifierFilter(CompareOp.EQUAL, new BinaryComparator( ref.getQualifier())));
break; case QualifierFilter: filter = new QualifierFilter(CompareOperator.valueOf(op), comparator.build()); break; case RandomRowFilter:
@Override public ReturnCode filterCell(final Cell c) { if (compareQualifier(getCompareOperator(), this.comparator, c)) { return ReturnCode.SKIP; } return ReturnCode.INCLUDE; }
Filter f = new SkipFilter(new QualifierFilter(CompareOperator.NOT_EQUAL, new BinaryComparator(Bytes.toBytes("testQualifierOne-2")))); Scan s = new Scan(); s.setFilter(f);
for (String cfString : groupedMap.keySet()) { List<ColumnInfo> columnInfoList = groupedMap.get(cfString); byte[] cf = Bytes.toBytes(cfString); Bytes.toString(colInfo.getColumnFamily()) + COLON + Bytes.toString(colInfo.getColumnPrefix())); columnFilters.addFilter(new QualifierFilter(CompareOp.EQUAL, new BinaryComparator(colInfo.getColumnName())));