private static Filter getRowFilter(String[] args) { Filter rowFilter = null; String filterCriteria = (args.length > 3) ? args[3]: null; if (filterCriteria == null) return null; if (filterCriteria.startsWith("^")) { String regexPattern = filterCriteria.substring(1, filterCriteria.length()); rowFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator(regexPattern)); } else { rowFilter = new PrefixFilter(Bytes.toBytesBinary(filterCriteria)); } return rowFilter; }
private static Filter getExportFilter(String[] args) { Filter exportFilter; String filterCriteria = (args.length > 5) ? args[5]: null; if (filterCriteria == null) return null; if (filterCriteria.startsWith("^")) { String regexPattern = filterCriteria.substring(1, filterCriteria.length()); exportFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator(regexPattern)); } else { exportFilter = new PrefixFilter(Bytes.toBytesBinary(filterCriteria)); } return exportFilter; }
private Filter regexFilterNew() { return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER, CompareOperator.EQUAL, new RegexStringComparator(QUICK_REGEX)); }
private Filter regexFilterNew(Pattern pattern) { return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER, CompareOperator.EQUAL, new RegexStringComparator(pattern.pattern(), pattern.flags())); }
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"); }
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(); } }
protected void initialize(JobConf job, String table) throws IOException { Connection connection = ConnectionFactory.createConnection(HBaseConfiguration.create(job)); TableName tableName = TableName.valueOf(table); // mandatory initializeTable(connection, tableName); byte[][] inputColumns = new byte [][] { Bytes.toBytes("columnA"), Bytes.toBytes("columnB") }; // mandatory setInputColumns(inputColumns); Filter exampleFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator("aa.*")); // optional setRowFilter(exampleFilter); }
@Test public void testJavaEngine() throws Exception { for (TestCase t: TEST_CASES) { boolean result = new RegexStringComparator(t.regex, t.flags, EngineType.JAVA) .compareTo(Bytes.toBytes(t.haystack)) == 0; assertEquals("Regex '" + t.regex + "' failed test '" + t.haystack + "'", result, t.expected); } }
@Test public void testJoniEngine() throws Exception { for (TestCase t: TEST_CASES) { boolean result = new RegexStringComparator(t.regex, t.flags, EngineType.JONI) .compareTo(Bytes.toBytes(t.haystack)) == 0; assertEquals("Regex '" + t.regex + "' failed test '" + t.haystack + "'", result, t.expected); } }
@Override protected void initialize(JobContext job) throws IOException { Connection connection = ConnectionFactory.createConnection(HBaseConfiguration.create( job.getConfiguration())); TableName tableName = TableName.valueOf("exampleTable"); // mandatory initializeTable(connection, tableName); byte[][] inputColumns = new byte [][] { Bytes.toBytes("columnA"), Bytes.toBytes("columnB") }; //optional Scan scan = new Scan(); for (byte[] family : inputColumns) { scan.addFamily(family); } Filter exampleFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator("aa.*")); scan.setFilter(exampleFilter); setScan(scan); }
@Override public void configure(JobConf job) { try { Connection connection = ConnectionFactory.createConnection(HBaseConfiguration.create(job)); TableName tableName = TableName.valueOf("exampleJobConfigurableTable"); // mandatory initializeTable(connection, tableName); byte[][] inputColumns = new byte [][] { Bytes.toBytes("columnA"), Bytes.toBytes("columnB") }; //optional Scan scan = new Scan(); for (byte[] family : inputColumns) { scan.addFamily(family); } Filter exampleFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator("aa.*")); scan.setFilter(exampleFilter); setScan(scan); } catch (IOException exception) { throw new RuntimeException("Failed to initialize.", exception); } } }
if (proto.hasEngine()) { EngineType engine = EngineType.valueOf(proto.getEngine()); comparator = new RegexStringComparator(proto.getPattern(), proto.getPatternFlags(), engine); } else { comparator = new RegexStringComparator(proto.getPattern(), proto.getPatternFlags());
@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); }
@Override public void configure(JobConf job) { try { Connection connection = ConnectionFactory.createConnection(job); Table exampleTable = connection.getTable(TableName.valueOf("exampleDeprecatedTable")); // mandatory initializeTable(connection, exampleTable.getName()); byte[][] inputColumns = new byte [][] { Bytes.toBytes("columnA"), Bytes.toBytes("columnB") }; // mandatory setInputColumns(inputColumns); Filter exampleFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator("aa.*")); // optional setRowFilter(exampleFilter); } catch (IOException exception) { throw new RuntimeException("Failed to configure for job.", exception); } }
@Test public void testRegexStringComparator() throws Exception { // test without specifying flags RegexStringComparator regexStringComparator = new RegexStringComparator(".+-2"); assertTrue(regexStringComparator.areSerializedFieldsEqual( ProtobufUtil.toComparator(ProtobufUtil.toComparator(regexStringComparator)))); // test with specifying flags try { new RegexStringComparator("regex", Pattern.CASE_INSENSITIVE | Pattern.DOTALL); } catch (Throwable t) { assertNull("Exception occurred while created the RegexStringComparator object", t); } }
new RegexStringComparator(".+-2"))); filters.add(new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator(".+-2"))); filters.add(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("One"))); new RegexStringComparator(".+Two.+"))); filters.add(new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator(".+-2"))); filters.add(new ValueFilter(CompareOperator.EQUAL, new SubstringComparator("One")));
@Override public void configure(JobConf job) { try { Connection connection = ConnectionFactory.createConnection(job); Table exampleTable = connection.getTable(TableName.valueOf(("exampleDeprecatedTable"))); // mandatory initializeTable(connection, exampleTable.getName()); byte[][] inputColumns = new byte [][] { Bytes.toBytes("columnA"), Bytes.toBytes("columnB") }; // optional Scan scan = new Scan(); for (byte[] family : inputColumns) { scan.addFamily(family); } Filter exampleFilter = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator("aa.*")); scan.setFilter(exampleFilter); setScan(scan); } catch (IOException exception) { throw new RuntimeException("Failed to configure for job.", exception); } }
scan.addFamily(FAMILY); Filter filter = new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator("col[1-5]")); scan.setFilter(filter); ResultScanner scanner = ht.getScanner(scan);
@Test public void testSerialization() throws Exception { // Default engine is the Java engine RegexStringComparator a = new RegexStringComparator("a|b"); RegexStringComparator b = RegexStringComparator.parseFrom(a.toByteArray()); assertTrue(a.areSerializedFieldsEqual(b)); assertTrue(b.getEngine() instanceof RegexStringComparator.JavaRegexEngine); // joni engine a = new RegexStringComparator("a|b", EngineType.JONI); b = RegexStringComparator.parseFrom(a.toByteArray()); assertTrue(a.areSerializedFieldsEqual(b)); assertTrue(b.getEngine() instanceof RegexStringComparator.JoniRegexEngine); }