@Override @Deprecated public ReturnCode filterKeyValue(final Cell c) throws IOException { return filterCell(c); }
@Test public void testRowCountFilter() throws IOException { KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam1"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam2"), Bytes.toBytes("a"), 2, Bytes.toBytes("value")); MockNextRowFilter mockNextRowFilter = new MockNextRowFilter(); FilterList filter = new FilterList(Operator.MUST_PASS_ONE, mockNextRowFilter); filter.filterCell(kv1); filter.filterCell(kv2); assertEquals(2, mockNextRowFilter.getHitCount()); }
@Test public void testMPONEWithSeekNextUsingHint() throws Exception { byte[] col = Bytes.toBytes("c"); FilterList filterList = new FilterList(Operator.MUST_PASS_ONE, new ColumnPaginationFilter(1, col)); KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("b"), 2, Bytes.toBytes("value")); KeyValue kv3 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("c"), 3, Bytes.toBytes("value")); KeyValue kv4 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("c"), 4, Bytes.toBytes("value")); assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, filterList.filterCell(kv1)); assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, filterList.filterCell(kv2)); assertEquals(ReturnCode.INCLUDE_AND_NEXT_COL, filterList.filterCell(kv3)); assertEquals(ReturnCode.NEXT_COL, filterList.filterCell(kv4)); }
@Test public void testWithMultiVersionsInSameRow() throws Exception { FilterList filterList01 = new FilterList(Operator.MUST_PASS_ONE, new ColumnPaginationFilter(1, 0)); KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("qual"), 1, Bytes.toBytes("value")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("qual"), 2, Bytes.toBytes("value")); KeyValue kv3 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("qual"), 3, Bytes.toBytes("value")); assertEquals(ReturnCode.INCLUDE_AND_NEXT_COL, filterList01.filterCell(kv1)); assertEquals(ReturnCode.NEXT_COL, filterList01.filterCell(kv2)); assertEquals(ReturnCode.NEXT_COL, filterList01.filterCell(kv3)); FilterList filterList11 = new FilterList(Operator.MUST_PASS_ONE, new ColumnPaginationFilter(1, 1)); assertEquals(ReturnCode.NEXT_COL, filterList11.filterCell(kv1)); assertEquals(ReturnCode.NEXT_COL, filterList11.filterCell(kv2)); assertEquals(ReturnCode.NEXT_COL, filterList11.filterCell(kv3)); }
@Test public void testEmptyFilterListTransformCell() throws IOException { KeyValue kv = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 1, Bytes.toBytes("value")); FilterList filterList = new FilterList(Operator.MUST_PASS_ALL); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv)); assertEquals(kv, filterList.transformCell(kv)); filterList = new FilterList(Operator.MUST_PASS_ONE); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv)); assertEquals(kv, filterList.transformCell(kv)); }
Arrays.asList(new Filter[] { includeFilter, alternateIncludeFilter, alternateFilter })); assertEquals(ReturnCode.INCLUDE, mpOnefilterList.filterCell(null)); assertEquals(Filter.ReturnCode.INCLUDE, mpOnefilterList.filterCell(null)); Arrays.asList(new Filter[] { includeFilter, alternateIncludeFilter, alternateFilter })); assertEquals(Filter.ReturnCode.INCLUDE_AND_NEXT_COL, mpAllfilterList.filterCell(null)); assertEquals(Filter.ReturnCode.SKIP, mpAllfilterList.filterCell(null));
filter.filterCell(kv1); assertTrue(mockFilter.didCellPassToTheFilter); filter.filterCell(kv2); assertFalse(mockFilter.didCellPassToTheFilter); filter.filterCell(kv3); assertTrue(mockFilter.didCellPassToTheFilter); filter.filterCell(kv1); assertTrue(mockFilter.didCellPassToTheFilter); filter.filterCell(kv2); assertFalse(mockFilter.didCellPassToTheFilter); filter.filterCell(kv3); assertTrue(mockFilter.didCellPassToTheFilter); filter.filterCell(kv1); assertTrue(mockFilter.didCellPassToTheFilter); filter.filterCell(kv2); assertFalse(mockFilter.didCellPassToTheFilter); filter.filterCell(kv3); assertFalse(mockFilter.didCellPassToTheFilter); filter.filterCell(kv4); assertTrue(mockFilter.didCellPassToTheFilter);
@Test public void testTheMaximalRule() throws IOException { KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); MockFilter filter1 = new MockFilter(ReturnCode.INCLUDE); MockFilter filter2 = new MockFilter(ReturnCode.INCLUDE_AND_NEXT_COL); MockFilter filter3 = new MockFilter(ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW); MockFilter filter4 = new MockFilter(ReturnCode.NEXT_COL); MockFilter filter5 = new MockFilter(ReturnCode.SKIP); MockFilter filter6 = new MockFilter(ReturnCode.SEEK_NEXT_USING_HINT); MockFilter filter7 = new MockFilter(ReturnCode.NEXT_ROW); FilterList filterList = new FilterList(Operator.MUST_PASS_ALL, filter1, filter2); assertEquals(ReturnCode.INCLUDE_AND_NEXT_COL, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter2, filter3); assertEquals(ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter4, filter5, filter6); assertEquals(ReturnCode.NEXT_COL, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter4, filter6); assertEquals(ReturnCode.NEXT_COL, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter3, filter1); assertEquals(ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter3, filter2, filter1, filter5); assertEquals(ReturnCode.NEXT_ROW, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter2, new FilterList(Operator.MUST_PASS_ALL, filter3, filter4)); assertEquals(ReturnCode.NEXT_ROW, filterList.filterCell(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL, filter3, filter7); assertEquals(ReturnCode.NEXT_ROW, filterList.filterCell(kv1)); }
MockFilter filter6 = new MockFilter(ReturnCode.SEEK_NEXT_USING_HINT); FilterList filterList = new FilterList(Operator.MUST_PASS_ONE, filter1, filter2); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv1)); assertEquals(ReturnCode.INCLUDE_AND_NEXT_COL, filterList.filterCell(kv1)); assertEquals(ReturnCode.SKIP, filterList.filterCell(kv1)); assertEquals(ReturnCode.SKIP, filterList.filterCell(kv1)); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv1)); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv1)); assertEquals(ReturnCode.INCLUDE_AND_NEXT_COL, filterList.filterCell(kv1)); assertEquals(ReturnCode.INCLUDE_AND_NEXT_COL, filterList.filterCell(kv1)); assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, filterList.filterCell(kv1));
@Test public void testKeyOnlyFilterTransformCell() throws IOException { Cell c; KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 1, Bytes.toBytes("value1")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 2, Bytes.toBytes("value2")); Filter filter1 = new SingleColumnValueFilter(Bytes.toBytes("cf"), Bytes.toBytes("column1"), CompareOperator.EQUAL, Bytes.toBytes("value1")); Filter filter2 = new SingleColumnValueFilter(Bytes.toBytes("cf"), Bytes.toBytes("column1"), CompareOperator.EQUAL, Bytes.toBytes("value2")); FilterList internalFilterList = new FilterList(Operator.MUST_PASS_ONE, filter1, filter2); FilterList keyOnlyFilterFirst = new FilterList(Operator.MUST_PASS_ALL, new KeyOnlyFilter(), internalFilterList); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterFirst.filterCell(kv1)); c = keyOnlyFilterFirst.transformCell(kv1); assertEquals(0, c.getValueLength()); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterFirst.filterCell(kv2)); c = keyOnlyFilterFirst.transformCell(kv2); assertEquals(0, c.getValueLength()); internalFilterList.reset(); FilterList keyOnlyFilterLast = new FilterList(Operator.MUST_PASS_ALL, new KeyOnlyFilter(), internalFilterList); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterLast.filterCell(kv1)); c = keyOnlyFilterLast.transformCell(kv1); assertEquals(0, c.getValueLength()); assertEquals(ReturnCode.INCLUDE, keyOnlyFilterLast.filterCell(kv2)); c = keyOnlyFilterLast.transformCell(kv2); assertEquals(0, c.getValueLength()); }
/** * When we do a "MUST_PASS_ONE" (a logical 'OR') of the two filters * we expect to get the same result as the inclusive stop result. * @throws Exception */ @Test public void testFilterListWithInclusiveStopFilterMustPassOne() throws Exception { byte[] r1 = Bytes.toBytes("Row1"); byte[] r11 = Bytes.toBytes("Row11"); byte[] r2 = Bytes.toBytes("Row2"); FilterList flist = new FilterList(FilterList.Operator.MUST_PASS_ONE); flist.addFilter(new AlwaysNextColFilter()); flist.addFilter(new InclusiveStopFilter(r1)); flist.filterRowKey(KeyValueUtil.createFirstOnRow(r1)); assertEquals(ReturnCode.INCLUDE, flist.filterCell(new KeyValue(r1, r1, r1))); assertEquals(ReturnCode.INCLUDE, flist.filterCell(new KeyValue(r11, r11, r11))); flist.reset(); flist.filterRowKey(KeyValueUtil.createFirstOnRow(r2)); assertEquals(ReturnCode.NEXT_COL, flist.filterCell(new KeyValue(r2, r2, r2))); }
@Test public void testReversedFilterListWithMockSeekHintFilter() throws IOException { KeyValue kv1 = new KeyValue(Bytes.toBytes("row1"), Bytes.toBytes("fam"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row2"), Bytes.toBytes("fam"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); KeyValue kv3 = new KeyValue(Bytes.toBytes("row3"), Bytes.toBytes("fam"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); Filter filter1 = new MockSeekHintFilter(kv1); filter1.setReversed(true); Filter filter2 = new MockSeekHintFilter(kv2); filter2.setReversed(true); Filter filter3 = new MockSeekHintFilter(kv3); filter3.setReversed(true); FilterList filterList = new FilterList(Operator.MUST_PASS_ONE); filterList.setReversed(true); filterList.addFilter(filter1); filterList.addFilter(filter2); filterList.addFilter(filter3); Assert.assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, filterList.filterCell(kv1)); Assert.assertEquals(kv3, filterList.getNextCellHint(kv1)); filterList = new FilterList(Operator.MUST_PASS_ALL); filterList.setReversed(true); filterList.addFilter(filter1); filterList.addFilter(filter2); filterList.addFilter(filter3); Assert.assertEquals(ReturnCode.SEEK_NEXT_USING_HINT, filterList.filterCell(kv1)); Assert.assertEquals(kv1, filterList.getNextCellHint(kv1)); }
/** * When we do a "MUST_PASS_ONE" (a logical 'OR') of the above two filters * we expect to get the same result as the 'prefix' only result. * @throws Exception */ @Test public void testFilterListTwoFiltersMustPassOne() throws Exception { byte[] r1 = Bytes.toBytes("Row1"); byte[] r11 = Bytes.toBytes("Row11"); byte[] r2 = Bytes.toBytes("Row2"); FilterList flist = new FilterList(FilterList.Operator.MUST_PASS_ONE); flist.addFilter(new PrefixFilter(r1)); flist.filterRowKey(KeyValueUtil.createFirstOnRow(r1)); assertEquals(ReturnCode.INCLUDE, flist.filterCell(new KeyValue(r1, r1, r1))); assertEquals(ReturnCode.INCLUDE, flist.filterCell(new KeyValue(r11, r11, r11))); flist.reset(); flist.filterRowKey(KeyValueUtil.createFirstOnRow(r2)); assertEquals(ReturnCode.SKIP, flist.filterCell(new KeyValue(r2, r2, r2))); flist = new FilterList(FilterList.Operator.MUST_PASS_ONE); flist.addFilter(new AlwaysNextColFilter()); flist.addFilter(new PrefixFilter(r1)); flist.filterRowKey(KeyValueUtil.createFirstOnRow(r1)); assertEquals(ReturnCode.INCLUDE, flist.filterCell(new KeyValue(r1, r1, r1))); assertEquals(ReturnCode.INCLUDE, flist.filterCell(new KeyValue(r11, r11, r11))); flist.reset(); flist.filterRowKey(KeyValueUtil.createFirstOnRow(r2)); assertEquals(ReturnCode.NEXT_COL, flist.filterCell(new KeyValue(r2, r2, r2))); }
@Override @Deprecated public ReturnCode filterKeyValue(final Cell c) throws IOException { return filterCell(c); }
filterList.addFilter(prefixFilter); filterList.filterRowKey(KeyValueUtil.createFirstOnRow(r22)); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(new KeyValue(r22, r22, r22))); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(new KeyValue(r2, r2, r2))); assertEquals(ReturnCode.SKIP, filterList.filterCell(new KeyValue(r1, r1, r1))); filterList.addFilter(prefixFilter); filterList.filterRowKey(KeyValueUtil.createFirstOnRow(r22)); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(new KeyValue(r22, r22, r22))); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(new KeyValue(r2, r2, r2))); assertEquals(ReturnCode.NEXT_COL, filterList.filterCell(new KeyValue(r1, r1, r1)));
assertEquals(Filter.ReturnCode.INCLUDE, flist.filterCell(kvQual1)); final KeyValue transformedQual1 = KeyValueUtil.ensureKeyValue(flist.transformCell(kvQual1)); assertEquals(0, transformedQual1.getValueLength()); assertEquals(Filter.ReturnCode.INCLUDE, flist.filterCell(kvQual2)); final KeyValue transformedQual2 = KeyValueUtil.ensureKeyValue(flist.transformCell(kvQual2)); assertEquals("value", Bytes.toString(transformedQual2.getValueArray(), assertEquals(Filter.ReturnCode.SKIP, flist.filterCell(kvQual3));
filterList.filterCell(null); assertEquals(0, comparator.compare(filterList.getNextCellHint(null), minKeyValue)); filterList.filterCell(null); assertEquals(0, comparator.compare(filterList.getNextCellHint(null), maxKeyValue)); filterList.filterCell(null); assertEquals(0, comparator.compare(filterList.getNextCellHint(null), minKeyValue)); filterList = new FilterList(Operator.MUST_PASS_ALL, Arrays.asList(new Filter[] { filterNoHint, filterMaxHint })); filterList.filterCell(null); assertEquals(0, comparator.compare(filterList.getNextCellHint(null), maxKeyValue)); filterList = new FilterList(Operator.MUST_PASS_ALL, Arrays.asList(new Filter[] { filterNoHint, filterMinHint })); filterList.filterCell(null); assertEquals(0, comparator.compare(filterList.getNextCellHint(null), minKeyValue));
@Test public void testTransformCell() throws IOException { KeyValue kv = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 1, Bytes.toBytes("value")); // case MUST_PASS_ONE TransformFilter filter1 = new TransformFilter(ReturnCode.INCLUDE); TransformFilter filter2 = new TransformFilter(ReturnCode.NEXT_ROW); TransformFilter filter3 = new TransformFilter(ReturnCode.SEEK_NEXT_USING_HINT); FilterList filterList = new FilterList(Operator.MUST_PASS_ONE, filter1, filter2, filter3); Assert.assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv)); Assert.assertEquals(kv, filterList.transformCell(kv)); Assert.assertEquals(true, filter1.getTransformed()); Assert.assertEquals(false, filter2.getTransformed()); Assert.assertEquals(false, filter3.getTransformed()); // case MUST_PASS_ALL filter1 = new TransformFilter(ReturnCode.INCLUDE); filter2 = new TransformFilter(ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW); filter3 = new TransformFilter(ReturnCode.INCLUDE_AND_NEXT_COL); filterList = new FilterList(Operator.MUST_PASS_ALL, filter1, filter2, filter3); Assert.assertEquals(ReturnCode.INCLUDE_AND_SEEK_NEXT_ROW, filterList.filterCell(kv)); Assert.assertEquals(kv, filterList.transformCell(kv)); Assert.assertEquals(true, filter1.getTransformed()); Assert.assertEquals(true, filter2.getTransformed()); Assert.assertEquals(true, filter3.getTransformed()); }
@Test public void testRowCountFilter() throws IOException { KeyValue kv1 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam1"), Bytes.toBytes("a"), 1, Bytes.toBytes("value")); KeyValue kv2 = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("fam2"), Bytes.toBytes("a"), 2, Bytes.toBytes("value")); MockNextRowFilter mockNextRowFilter = new MockNextRowFilter(); FilterList filter = new FilterList(Operator.MUST_PASS_ONE, mockNextRowFilter); filter.filterCell(kv1); filter.filterCell(kv2); assertEquals(2, mockNextRowFilter.getHitCount()); }
@Test public void testEmptyFilterListTransformCell() throws IOException { KeyValue kv = new KeyValue(Bytes.toBytes("row"), Bytes.toBytes("cf"), Bytes.toBytes("column1"), 1, Bytes.toBytes("value")); FilterList filterList = new FilterList(Operator.MUST_PASS_ALL); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv)); assertEquals(kv, filterList.transformCell(kv)); filterList = new FilterList(Operator.MUST_PASS_ONE); assertEquals(ReturnCode.INCLUDE, filterList.filterCell(kv)); assertEquals(kv, filterList.transformCell(kv)); }