@Override public void scan(String tableName, Collection<Column> columns, String filterExpression, long minTime, List<String> visibilityLabels, ResultHandler handler) throws IOException { Filter filter = null; if (!StringUtils.isBlank(filterExpression)) { ParseFilter parseFilter = new ParseFilter(); filter = parseFilter.parseFilterString(filterExpression); } try (final Table table = connection.getTable(TableName.valueOf(tableName)); final ResultScanner scanner = getResults(table, columns, filter, minTime, visibilityLabels)) { for (final Result result : scanner) { final byte[] rowKey = result.getRow(); final Cell[] cells = result.rawCells(); if (cells == null) { continue; } // convert HBase cells to NiFi cells final ResultCell[] resultCells = new ResultCell[cells.length]; for (int i=0; i < cells.length; i++) { final Cell cell = cells[i]; final ResultCell resultCell = getResultCell(cell); resultCells[i] = resultCell; } // delegate to the handler handler.handle(rowKey, resultCells); } } }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 2 || filterArguments.size() == 3 || filterArguments.size() == 5, "Expected 2, 3 or 5 but got: %s", filterArguments.size()); if (filterArguments.size() == 2) { byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); return new DependentColumnFilter(family, qualifier); } else if (filterArguments.size() == 3) { byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); return new DependentColumnFilter(family, qualifier, dropDependentColumn); } else if (filterArguments.size() == 5) { byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(3)); ByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(4))); return new DependentColumnFilter(family, qualifier, dropDependentColumn, op, comparator); } else { throw new IllegalArgumentException("Expected 2, 3 or 5 but got: " + filterArguments.size()); } }
private void registerCustomFilter(Configuration conf) { String[] filterList = conf.getStrings(Constants.CUSTOM_FILTERS); if (filterList != null) { for (String filterClass : filterList) { String[] filterPart = filterClass.split(":"); if (filterPart.length != 2) { LOG.warn( "Invalid filter specification " + filterClass + " - skipping"); } else { ParseFilter.registerFilter(filterPart[0], filterPart[1]); } } } } }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 4, "Expected 4 but got: %s", filterArguments.size()); byte [] minColumn = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); boolean minColumnInclusive = ParseFilter.convertByteArrayToBoolean(filterArguments.get(1)); byte [] maxColumn = ParseFilter.removeQuotesFromByteArray(filterArguments.get(2)); boolean maxColumnInclusive = ParseFilter.convertByteArrayToBoolean(filterArguments.get(3)); if (minColumn.length == 0) minColumn = null; if (maxColumn.length == 0) maxColumn = null; return new ColumnRangeFilter(minColumn, minColumnInclusive, maxColumn, maxColumnInclusive); }
public static ArrayList<Object> extractArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 2, "Expected 2 but got: %s", filterArguments.size()); CompareOperator op = ParseFilter.createCompareOperator(filterArguments.get(0)); ByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(1))); if (comparator instanceof RegexStringComparator || comparator instanceof SubstringComparator) { if (op != CompareOperator.EQUAL && op != CompareOperator.NOT_EQUAL) { throw new IllegalArgumentException ("A regexstring comparator and substring comparator" + " can only be used with EQUAL and NOT_EQUAL"); } } ArrayList<Object> arguments = new ArrayList<>(2); arguments.add(op); arguments.add(comparator); return arguments; }
} else if (checkForOr(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.OR_BUFFER); operatorStack.push(ParseConstants.OR_BUFFER); } else if (checkForAnd(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.AND_BUFFER); operatorStack.push(ParseConstants.AND_BUFFER); } else if (checkForSkip(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.SKIP_BUFFER); operatorStack.push(ParseConstants.SKIP_BUFFER); } else if (checkForWhile(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.WHILE_BUFFER); operatorStack.push(ParseConstants.WHILE_BUFFER); } else if (filterStringAsByteArray[i] == ParseConstants.RPAREN) { filterStack.push(popArguments(operatorStack, filterStack)); if (operatorStack.empty()) { throw new IllegalArgumentException("Mismatched parenthesis"); byte [] filterSimpleExpression = extractFilterSimpleExpression(filterStringAsByteArray, i); i+= (filterSimpleExpression.length - 1); filter = parseSimpleFilterExpression(filterSimpleExpression); filterStack.push(filter); filterStack.push(popArguments(operatorStack, filterStack));
/** * Parses the filterString and constructs a filter using it * <p> * @param filterString filter string given by the user * @return filter object we constructed */ public Filter parseFilterString (String filterString) throws CharacterCodingException { return parseFilterString(Bytes.toBytes(filterString)); }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 2 || filterArguments.size() == 3 || filterArguments.size() == 5, "Expected 2, 3 or 5 but got: %s", filterArguments.size()); if (filterArguments.size() == 2) { byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); return new DependentColumnFilter(family, qualifier); } else if (filterArguments.size() == 3) { byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); return new DependentColumnFilter(family, qualifier, dropDependentColumn); } else if (filterArguments.size() == 5) { byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); boolean dropDependentColumn = ParseFilter.convertByteArrayToBoolean(filterArguments.get(2)); CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(3)); WritableByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(4))); return new DependentColumnFilter(family, qualifier, dropDependentColumn, compareOp, comparator); } else { throw new IllegalArgumentException("Expected 2, 3 or 5 but got: " + filterArguments.size()); } }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { byte [][] prefixes = new byte [filterArguments.size()][]; for (int i = 0 ; i < filterArguments.size(); i++) { byte [] columnPrefix = ParseFilter.removeQuotesFromByteArray(filterArguments.get(i)); prefixes[i] = columnPrefix; } return new MultipleColumnPrefixFilter(prefixes); }
public static ArrayList extractArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 2, "Expected 2 but got: %s", filterArguments.size()); CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(0)); WritableByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(1))); if (comparator instanceof RegexStringComparator || comparator instanceof SubstringComparator) { if (compareOp != CompareOp.EQUAL && compareOp != CompareOp.NOT_EQUAL) { throw new IllegalArgumentException ("A regexstring comparator and substring comparator" + " can only be used with EQUAL and NOT_EQUAL"); } } ArrayList arguments = new ArrayList(); arguments.add(compareOp); arguments.add(comparator); return arguments; }
@Before public void setUp() throws Exception { f = new ParseFilter(); }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument((filterArguments.isEmpty() || filterArguments.size() == 1), "Expected: 0 or 1 but got: %s", filterArguments.size()); KeyOnlyFilter filter = new KeyOnlyFilter(); if (filterArguments.size() == 1) { filter.lenAsVal = ParseFilter.convertByteArrayToBoolean(filterArguments.get(0)); } return filter; }
@Test public void testRegisterFilter() { ParseFilter.registerFilter("MyFilter", "some.class"); assertTrue(f.getSupportedFilters().contains("MyFilter")); }
} else if (checkForOr(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.OR_BUFFER); operatorStack.push(ParseConstants.OR_BUFFER); } else if (checkForAnd(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.AND_BUFFER); operatorStack.push(ParseConstants.AND_BUFFER); } else if (checkForSkip(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.SKIP_BUFFER); operatorStack.push(ParseConstants.SKIP_BUFFER); } else if (checkForWhile(filterStringAsByteArray, i)) { reduce(operatorStack, filterStack, ParseConstants.WHILE_BUFFER); operatorStack.push(ParseConstants.WHILE_BUFFER); } else if (filterStringAsByteArray[i] == ParseConstants.RPAREN) { filterStack.push(popArguments(operatorStack, filterStack)); if (operatorStack.empty()) { throw new IllegalArgumentException("Mismatched parenthesis"); byte [] filterSimpleExpression = extractFilterSimpleExpression(filterStringAsByteArray, i); i+= (filterSimpleExpression.length - 1); filter = parseSimpleFilterExpression(filterSimpleExpression); filterStack.push(filter); filterStack.push(popArguments(operatorStack, filterStack));
static Filter parseFilterString(String filterString) { if (filterString == null) { return null; } try { return FILTER_PARSEER.parseFilterString(filterString); } catch (CharacterCodingException e) { throw new DrillRuntimeException("Error parsing filter string: " + filterString, e); } }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 4 || filterArguments.size() == 6, "Expected 4 or 6 but got: %s", filterArguments.size()); byte [] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte [] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(2)); WritableByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(3))); if (comparator instanceof RegexStringComparator || comparator instanceof SubstringComparator) { if (compareOp != CompareOp.EQUAL && compareOp != CompareOp.NOT_EQUAL) { throw new IllegalArgumentException ("A regexstring comparator and substring comparator " + "can only be used with EQUAL and NOT_EQUAL"); } } SingleColumnValueFilter filter = new SingleColumnValueFilter(family, qualifier, compareOp, comparator); if (filterArguments.size() == 6) { boolean filterIfMissing = ParseFilter.convertByteArrayToBoolean(filterArguments.get(4)); boolean latestVersionOnly = ParseFilter.convertByteArrayToBoolean(filterArguments.get(5)); filter.setFilterIfMissing(filterIfMissing); filter.setLatestVersionOnly(latestVersionOnly); } return filter; }
/** * Creating this filter by reflection, it is used by {@link ParseFilter}, * @param filterArguments arguments for creating a ColumnValueFilter * @return a ColumnValueFilter */ public static Filter createFilterFromArguments(ArrayList<byte[]> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 4, "Expect 4 arguments: %s", filterArguments.size()); byte[] family = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); byte[] qualifier = ParseFilter.removeQuotesFromByteArray(filterArguments.get(1)); CompareOperator operator = ParseFilter.createCompareOperator(filterArguments.get(2)); ByteArrayComparable comparator = ParseFilter.createComparator(ParseFilter.removeQuotesFromByteArray(filterArguments.get(3))); if (comparator instanceof RegexStringComparator || comparator instanceof SubstringComparator) { if (operator != CompareOperator.EQUAL && operator != CompareOperator.NOT_EQUAL) { throw new IllegalArgumentException("A regexstring comparator and substring comparator " + "can only be used with EQUAL and NOT_EQUAL"); } } return new ColumnValueFilter(family, qualifier, operator, comparator); }
public static Filter createFilterFromArguments (ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 1, "Expected 1 but got: %s", filterArguments.size()); byte [] stopRowKey = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); return new InclusiveStopFilter(stopRowKey); }
public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 4, "Expected 4 but got: %s", filterArguments.size()); byte [] minColumn = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0)); boolean minColumnInclusive = ParseFilter.convertByteArrayToBoolean(filterArguments.get(1)); byte [] maxColumn = ParseFilter.removeQuotesFromByteArray(filterArguments.get(2)); boolean maxColumnInclusive = ParseFilter.convertByteArrayToBoolean(filterArguments.get(3)); if (minColumn.length == 0) minColumn = null; if (maxColumn.length == 0) maxColumn = null; return new ColumnRangeFilter(minColumn, minColumnInclusive, maxColumn, maxColumnInclusive); }
public static ArrayList<Object> extractArguments(ArrayList<byte []> filterArguments) { Preconditions.checkArgument(filterArguments.size() == 2, "Expected 2 but got: %s", filterArguments.size()); CompareOp compareOp = ParseFilter.createCompareOp(filterArguments.get(0)); ByteArrayComparable comparator = ParseFilter.createComparator( ParseFilter.removeQuotesFromByteArray(filterArguments.get(1))); if (comparator instanceof RegexStringComparator || comparator instanceof SubstringComparator) { if (compareOp != CompareOp.EQUAL && compareOp != CompareOp.NOT_EQUAL) { throw new IllegalArgumentException ("A regexstring comparator and substring comparator" + " can only be used with EQUAL and NOT_EQUAL"); } } ArrayList<Object> arguments = new ArrayList<Object>(); arguments.add(compareOp); arguments.add(comparator); return arguments; }