Refine search
Filter f = new RowFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("testRowOne-2"))); Scan s = new Scan(); s.setFilter(f); verifyScanNoEarlyOut(s, expectedRows, expectedKeys); f = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator("testRow.+-2")); s = new Scan(); s.setFilter(f); verifyScanNoEarlyOut(s, expectedRows, expectedKeys); f = new RowFilter(CompareOperator.LESS, new BinaryComparator(Bytes.toBytes("testRowOne-2"))); s = new Scan(); s.setFilter(f); expectedKeys = colsPerRow; f = new RowFilter(CompareOperator.LESS_OR_EQUAL, new BinaryComparator(Bytes.toBytes("testRowOne-2"))); s = new Scan(); s.setFilter(f); f = new RowFilter(CompareOperator.EQUAL, new RegexStringComparator(".+-2")); s = new Scan(); s.setFilter(f);
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()); comparator.getEngine().setCharset(charset); } catch (IllegalCharsetNameException e) { LOG.error("invalid charset", e);
@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 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); }
@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); } }
@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); } }
@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); }
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>"), ht.put(put); Scan scan = new Scan(); scan.addFamily(FAMILY); Filter filter = new QualifierFilter(CompareOperator.EQUAL, new RegexStringComparator("col[1-5]")); scan.setFilter(filter); ResultScanner scanner = ht.getScanner(scan); int expectedIndex = 1;
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; Scan scan = new Scan(); scan.setStartRow(scanStartRow); FilterList filters = new FilterList(FilterList.Operator.MUST_PASS_ALL); byte[] scanEndRow = Bytes.add(rowPrefix, Bytes.toBytes(startRunId), Constants.ZERO_SINGLE_BYTE); scan.setStopRow(scanEndRow); } else { new RegexStringComparator( "^c\\!((?!" + Constants.HRAVEN_QUEUE + ").)*$")));
RegexStringComparator regexStringComparator = new RegexStringComparator(rowkeyRegex); regexStringComparator.setCharset(Charset.forName("ISO-8859-1")); RowFilter filter = new RowFilter(CompareOp.EQUAL, regexStringComparator); FilterList filterList = new FilterList(); filterList.addFilter(filter); Scan s1 = new Scan(); s1.setStartRow(stopKey); s1.setStopRow(startKey); s1.setFilter(filterList);
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); }
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(); } }
private void initScan() throws IOException{ scan = new Scan(); scan.setCacheBlocks(cacheBlocks_); scan.setCaching(caching_); gt_ = Bytes.toBytesBinary(Utils.slashisize(configuredOptions_.getOptionValue("gt"))); addRowFilter(CompareOp.GREATER, gt_); scan.setStartRow(gt_); lt_ = Bytes.toBytesBinary(Utils.slashisize(configuredOptions_.getOptionValue("lt"))); addRowFilter(CompareOp.LESS, lt_); scan.setStopRow(lt_); gte_ = Bytes.toBytesBinary(Utils.slashisize(configuredOptions_.getOptionValue("gte"))); scan.setStartRow(gte_); addFilter(new WhileMatchFilter(new RowFilter(CompareOp.LESS_OR_EQUAL, new BinaryComparator(lte_)))); addFilter(new RowFilter(CompareOp.EQUAL, new RegexStringComparator(regex_)));
byte[] startRowKey = FIRST_ROW_OF_THE_TABLE; Scan scan = new Scan(); Filter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,new RegexStringComparator("YOUR_REGEX")); scan.setFilter(filter); ResultScanner scanner1 = table.getScanner(scan); for (Result res : scanner1) { byte[] stopRowKey = res.getRow(); } scanner1.close(); scan.setStartRow(startRowKey); scan.setStopRow(stopRowKey); ResultScanner scanner2 = table.getScanner(scan); for (Result res : scanner2) { //you final result }
Configuration conf = HBaseConfiguration.create(); HTable table = new HTable(conf, "t1"); Scan s = new Scan (); RegexStringComparator keyRegEx = new RegexStringComparator(".*tom.*"); RowFilter rowFilter = new RowFilter(CompareOp.EQUAL, new RegexStringComparator(".*tom.*")); s.setFilter(rowFilter); ResultScanner scanner = table.getScanner(s); Iterator<Result> it = scanner.iterator(); while(it.hasNext()){ // ... your code ... }
/** * 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"); }
public static void main(String[] args) throws IOException { // ^^ DependentColumnFilterExample Configuration conf = HBaseConfiguration.create(); HBaseHelper helper = HBaseHelper.getHelper(conf); helper.dropTable("testtable"); helper.createTable("testtable", "colfam1", "colfam2"); System.out.println("Adding rows to table..."); helper.fillTable("testtable", 1, 10, 10, true, "colfam1", "colfam2"); Connection connection = ConnectionFactory.createConnection(conf); table = connection.getTable(TableName.valueOf("testtable")); // vv DependentColumnFilterExample filter(true, CompareFilter.CompareOp.NO_OP, null); filter(false, CompareFilter.CompareOp.NO_OP, null); // co DependentColumnFilterExample-2-Filter Call filter method with various options. filter(true, CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("val-5"))); filter(false, CompareFilter.CompareOp.EQUAL, new BinaryPrefixComparator(Bytes.toBytes("val-5"))); filter(true, CompareFilter.CompareOp.EQUAL, new RegexStringComparator(".*\\.5")); filter(false, CompareFilter.CompareOp.EQUAL, new RegexStringComparator(".*\\.5")); } // ^^ DependentColumnFilterExample
/** * Extract a regular expression from a RegexStringComparator. * * @param comparator a {@link org.apache.hadoop.hbase.filter.RegexStringComparator} object. * @return a {@link java.lang.String} object. */ public static String extractRegexPattern(RegexStringComparator comparator) { return Bytes.toString(comparator.getValue()); } }
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; }
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; }