Best code snippets using org.apache.hadoop.hbase.filter.PrefixFilter.<init>(Showing top 15 results out of 315)

@Test
public void testPrefixFilter() throws Exception {
 // Grab rows from group one (half of total)
 long expectedRows = numRows / 2;
 long expectedKeys = colsPerRow;
 Scan s = new Scan();
 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne")));
 verifyScan(s, expectedRows, expectedKeys);
}

@Test
public void testPrefixFilter() throws Exception {
 // null prefix
 PrefixFilter prefixFilter = new PrefixFilter(null);
 assertTrue(prefixFilter.areSerializedFieldsEqual(
  ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
 // non-null prefix
 prefixFilter = new PrefixFilter(Bytes.toBytes("abc"));
 assertTrue(prefixFilter.areSerializedFieldsEqual(
  ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
}

public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
 Preconditions.checkArgument(filterArguments.size() == 1,
               "Expected 1 but got: %s", filterArguments.size());
 byte [] prefix = ParseFilter.removeQuotesFromByteArray(filterArguments.get(0));
 return new PrefixFilter(prefix);
}

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;
}

public Filter getOrderingFilter() {
 List<Filter> filters = new ArrayList<>();
 filters.add(new PrefixFilter(Bytes.toBytes("yyy")));
 filters.add(new PageFilter(MAX_PAGES));
 Filter filterMPONE =
  new FilterList(FilterList.Operator.MUST_PASS_ONE, filters);
 return filterMPONE;
}

/**
 * @param pbBytes A pb serialized {@link PrefixFilter} instance
 * @return An instance of {@link PrefixFilter} made from <code>bytes</code>
 * @throws org.apache.hadoop.hbase.exceptions.DeserializationException
 * @see #toByteArray
 */
public static PrefixFilter parseFrom(final byte [] pbBytes)
throws DeserializationException {
 FilterProtos.PrefixFilter proto;
 try {
  proto = FilterProtos.PrefixFilter.parseFrom(pbBytes);
 } catch (InvalidProtocolBufferException e) {
  throw new DeserializationException(e);
 }
 return new PrefixFilter(proto.hasPrefix()?proto.getPrefix().toByteArray():null);
}

private static void setRowPrefixFilter(Scan scan, String rowPrefixes) {
 if (rowPrefixes != null && !rowPrefixes.isEmpty()) {
  String[] rowPrefixArray = rowPrefixes.split(",");
  Arrays.sort(rowPrefixArray);
  FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ONE);
  for (String prefix : rowPrefixArray) {
   Filter filter = new PrefixFilter(Bytes.toBytes(prefix));
   filterList.addFilter(filter);
  }
  scan.setFilter(filterList);
  byte[] startPrefixRow = Bytes.toBytes(rowPrefixArray[0]);
  byte[] lastPrefixRow = Bytes.toBytes(rowPrefixArray[rowPrefixArray.length -1]);
  setStartAndStopRows(scan, startPrefixRow, lastPrefixRow);
 }
}

private InternalScanner buildScanner(String keyPrefix, String value, HRegion r)
  throws IOException {
 // Defaults FilterList.Operator.MUST_PASS_ALL.
 FilterList allFilters = new FilterList();
 allFilters.addFilter(new PrefixFilter(Bytes.toBytes(keyPrefix)));
 // Only return rows where this column value exists in the row.
 SingleColumnValueFilter filter = new SingleColumnValueFilter(Bytes.toBytes("trans-tags"),
   Bytes.toBytes("qual2"), CompareOp.EQUAL, Bytes.toBytes(value));
 filter.setFilterIfMissing(true);
 allFilters.addFilter(filter);
 Scan scan = new Scan();
 scan.addFamily(Bytes.toBytes("trans-blob"));
 scan.addFamily(Bytes.toBytes("trans-type"));
 scan.addFamily(Bytes.toBytes("trans-date"));
 scan.addFamily(Bytes.toBytes("trans-tags"));
 scan.addFamily(Bytes.toBytes("trans-group"));
 scan.setFilter(allFilters);
 return r.getScanner(scan);
}

@Test
public void testFilters() throws IOException {
 try {
  this.region = TEST_UTIL.createLocalHRegion(TESTTABLEDESC, null, null);
  HBaseTestCase.addContent(this.region, HConstants.CATALOG_FAMILY);
  byte [] prefix = Bytes.toBytes("ab");
  Filter newFilter = new PrefixFilter(prefix);
  Scan scan = new Scan();
  scan.setFilter(newFilter);
  rowPrefixFilter(scan);
  byte[] stopRow = Bytes.toBytes("bbc");
  newFilter = new WhileMatchFilter(new InclusiveStopFilter(stopRow));
  scan = new Scan();
  scan.setFilter(newFilter);
  rowInclusiveStopFilter(scan, stopRow);
 } finally {
  HBaseTestingUtility.closeRegionAndWAL(this.region);
 }
}

private Filter getMPALLFilter() {
 List<Filter> filters = new ArrayList<>();
 filters.add(new PageFilter(MAX_PAGES));
 filters.add(new WhileMatchFilter(new PrefixFilter(Bytes.toBytes("yyy"))));
 Filter filterMPALL =
  new FilterList(FilterList.Operator.MUST_PASS_ALL, filters);
 return filterMPALL;
}

@Test
public void testPrefixFilterWithReverseScan() throws Exception {
 // Grab rows from group one (half of total)
 long expectedRows = this.numRows / 2;
 long expectedKeys = this.colsPerRow;
 Scan s = new Scan();
 s.setReversed(true);
 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne")));
 verifyScan(s, expectedRows, expectedKeys);
}

@Before
public void setUp() throws Exception {
 this.mainFilter = new PrefixFilter(Bytes.toBytes(HOST_PREFIX));
}

@Test
public void testPrefixFilter() throws Exception {
 // Grab rows from group one (half of total)
 long expectedRows = this.numRows / 2;
 long expectedKeys = this.colsPerRow;
 Scan s = new Scan();
 s.setFilter(new PrefixFilter(Bytes.toBytes("testRowOne")));
 verifyScan(s, expectedRows, expectedKeys);
}

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 Filter getFilterMPONE() {
 List<Filter> filters = new ArrayList<>();
 filters.add(new PageFilter(MAX_PAGES));
 filters.add(new WhileMatchFilter(new PrefixFilter(Bytes.toBytes("yyy"))));
 Filter filterMPONE =
  new FilterList(FilterList.Operator.MUST_PASS_ONE, filters);
 return filterMPONE;
}