001/**
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements.  See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership.  The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License.  You may obtain a copy of the License at
009 *
010 *     http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018package org.apache.hadoop.hbase.filter;
019
020import static org.junit.Assert.assertTrue;
021
022import java.util.ArrayList;
023import java.util.LinkedList;
024import java.util.List;
025import java.util.TreeSet;
026import org.apache.hadoop.hbase.CompareOperator;
027import org.apache.hadoop.hbase.HBaseClassTestRule;
028import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
029import org.apache.hadoop.hbase.filter.MultiRowRangeFilter.RowRange;
030import org.apache.hadoop.hbase.testclassification.FilterTests;
031import org.apache.hadoop.hbase.testclassification.SmallTests;
032import org.apache.hadoop.hbase.util.Bytes;
033import org.apache.hadoop.hbase.util.Pair;
034import org.junit.ClassRule;
035import org.junit.Test;
036import org.junit.experimental.categories.Category;
037
038import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil;
039
040@Category({FilterTests.class, SmallTests.class})
041public class TestFilterSerialization {
042
043  @ClassRule
044  public static final HBaseClassTestRule CLASS_RULE =
045      HBaseClassTestRule.forClass(TestFilterSerialization.class);
046
047  @Test
048  public void testColumnCountGetFilter() throws Exception {
049    ColumnCountGetFilter columnCountGetFilter = new ColumnCountGetFilter(1);
050    assertTrue(columnCountGetFilter.areSerializedFieldsEqual(
051      ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnCountGetFilter))));
052  }
053
054  @Test
055  public void testColumnPaginationFilter() throws Exception {
056    ColumnPaginationFilter columnPaginationFilter = new ColumnPaginationFilter(1,7);
057    assertTrue(columnPaginationFilter.areSerializedFieldsEqual(
058      ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPaginationFilter))));
059  }
060
061  @Test
062  public void testColumnPrefixFilter() throws Exception {
063    // empty string
064    ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
065    assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
066      ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
067
068    // non-empty string
069    columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
070    assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
071      ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
072  }
073
074  @Test
075  public void testColumnRangeFilter() throws Exception {
076    // null columns
077    ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(null, true, null, false);
078    assertTrue(columnRangeFilter.areSerializedFieldsEqual(
079      ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
080
081    // non-null columns
082    columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("a"), false, Bytes.toBytes("b"), true);
083    assertTrue(columnRangeFilter.areSerializedFieldsEqual(
084      ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
085  }
086
087  @Test
088  public void testDependentColumnFilter() throws Exception {
089    // null column qualifier/family
090    DependentColumnFilter dependentColumnFilter = new DependentColumnFilter(null, null);
091    assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
092      ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
093
094    // non-null column qualifier/family
095    dependentColumnFilter = new DependentColumnFilter(Bytes.toBytes("family"),
096      Bytes.toBytes("qual"), true, CompareOperator.GREATER_OR_EQUAL,
097      new BitComparator(Bytes.toBytes("bitComparator"), BitComparator.BitwiseOp.OR));
098    assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
099      ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
100  }
101
102  @Test
103  public void testFamilyFilter() throws Exception {
104    FamilyFilter familyFilter = new FamilyFilter(CompareOperator.EQUAL,
105      new BinaryPrefixComparator(Bytes.toBytes("testValueOne")));
106    assertTrue(familyFilter.areSerializedFieldsEqual(
107      ProtobufUtil.toFilter(ProtobufUtil.toFilter(familyFilter))));
108  }
109
110  @Test
111  public void testFilterList() throws Exception {
112    // empty filter list
113    FilterList filterList = new FilterList(new LinkedList<>());
114    assertTrue(filterList.areSerializedFieldsEqual(
115      ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
116
117    // non-empty filter list
118    LinkedList<Filter> list = new LinkedList<>();
119    list.add(new ColumnCountGetFilter(1));
120    list.add(new RowFilter(CompareOperator.EQUAL,
121      new SubstringComparator("testFilterList")));
122    assertTrue(filterList.areSerializedFieldsEqual(
123      ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
124  }
125
126  @Test
127  public void testFilterWrapper() throws Exception {
128    FilterWrapper filterWrapper =
129      new FilterWrapper(
130        new ColumnRangeFilter(Bytes.toBytes("e"), false, Bytes.toBytes("f"), true));
131    assertTrue(filterWrapper.areSerializedFieldsEqual(
132      ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterWrapper))));
133  }
134
135  @SuppressWarnings("deprecation")
136  @Test
137  public void testFirstKeyValueMatchingQualifiersFilter() throws Exception {
138    // empty qualifiers set
139    TreeSet<byte []> set = new TreeSet<>(Bytes.BYTES_COMPARATOR);
140    FirstKeyValueMatchingQualifiersFilter firstKeyValueMatchingQualifiersFilter =
141      new FirstKeyValueMatchingQualifiersFilter(set);
142    assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
143      ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
144
145    // non-empty qualifiers set
146    set.add(Bytes.toBytes("col0"));
147    set.add(Bytes.toBytes("col1"));
148    firstKeyValueMatchingQualifiersFilter =
149      new FirstKeyValueMatchingQualifiersFilter(set);
150    assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
151      ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
152  }
153
154  @Test
155  public void testFirstKeyOnlyFilter() throws Exception {
156    FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
157    assertTrue(firstKeyOnlyFilter.areSerializedFieldsEqual(
158      ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyOnlyFilter))));
159  }
160
161  @Test
162  public void testFuzzyRowFilter() throws Exception {
163    LinkedList<Pair<byte[], byte[]>> fuzzyList = new LinkedList<>();
164    fuzzyList.add(new Pair<>(Bytes.toBytes("999"),new byte[] {0, 0, 1}));
165    fuzzyList.add(new Pair<>(Bytes.toBytes("abcd"),new byte[] {1, 0, 1, 1}));
166    FuzzyRowFilter fuzzyRowFilter = new FuzzyRowFilter(fuzzyList);
167    assertTrue(fuzzyRowFilter.areSerializedFieldsEqual(
168      ProtobufUtil.toFilter(ProtobufUtil.toFilter(fuzzyRowFilter))));
169  }
170
171  @Test
172  public void testInclusiveStopFilter() throws Exception {
173    // InclusveStopFilter with null stopRowKey
174    InclusiveStopFilter inclusiveStopFilter = new InclusiveStopFilter(null);
175    assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
176      ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
177
178    // InclusveStopFilter with non-null stopRowKey
179    inclusiveStopFilter = new InclusiveStopFilter(Bytes.toBytes("inclusiveStopFilter"));
180    assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
181      ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
182  }
183
184  @Test
185  public void testKeyOnlyFilter() throws Exception {
186    // KeyOnlyFilter with lenAsVal
187    KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true);
188    assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
189      ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
190
191    // KeyOnlyFilter without lenAsVal
192    keyOnlyFilter = new KeyOnlyFilter();
193    assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
194      ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
195  }
196
197  @Test
198  public void testMultipleColumnPrefixFilter() throws Exception {
199    // empty array
200    byte [][] prefixes = null;
201    MultipleColumnPrefixFilter multipleColumnPrefixFilter =
202      new MultipleColumnPrefixFilter(prefixes);
203    assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
204      ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
205
206    // non-empty array
207    prefixes = new byte[2][];
208    prefixes[0] = Bytes.toBytes("a");
209    prefixes[1] = Bytes.toBytes("");
210    multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(prefixes);
211    assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
212      ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
213  }
214
215  @Test
216  public void testPageFilter() throws Exception {
217    PageFilter pageFilter = new PageFilter(6);
218    assertTrue(pageFilter.areSerializedFieldsEqual(
219      ProtobufUtil.toFilter(ProtobufUtil.toFilter(pageFilter))));
220  }
221
222  @Test
223  public void testPrefixFilter() throws Exception {
224    // null prefix
225    PrefixFilter prefixFilter = new PrefixFilter(null);
226    assertTrue(prefixFilter.areSerializedFieldsEqual(
227      ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
228
229    // non-null prefix
230    prefixFilter = new PrefixFilter(Bytes.toBytes("abc"));
231    assertTrue(prefixFilter.areSerializedFieldsEqual(
232      ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
233  }
234
235  @Test
236  public void testQualifierFilter() throws Exception {
237    QualifierFilter qualifierFilter = new QualifierFilter(CompareOperator.EQUAL,
238      new NullComparator());
239    assertTrue(qualifierFilter.areSerializedFieldsEqual(
240      ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter))));
241  }
242
243  @Test
244  public void testRandomRowFilter() throws Exception {
245    RandomRowFilter randomRowFilter = new RandomRowFilter((float)0.1);
246    assertTrue(randomRowFilter.areSerializedFieldsEqual(
247      ProtobufUtil.toFilter(ProtobufUtil.toFilter(randomRowFilter))));
248  }
249
250  @Test
251  public void testRowFilter() throws Exception {
252    RowFilter rowFilter = new RowFilter(CompareOperator.EQUAL,
253      new SubstringComparator("testRowFilter"));
254    assertTrue(rowFilter.areSerializedFieldsEqual(
255      ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter))));
256  }
257
258  @Test
259  public void testSingleColumnValueExcludeFilter() throws Exception {
260    // null family/column SingleColumnValueExcludeFilter
261    SingleColumnValueExcludeFilter singleColumnValueExcludeFilter =
262      new SingleColumnValueExcludeFilter(null, null,
263      CompareOperator.GREATER_OR_EQUAL, Bytes.toBytes("value"));
264    assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
265      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
266
267    // non-null family/column SingleColumnValueFilter
268    singleColumnValueExcludeFilter =
269      new SingleColumnValueExcludeFilter(Bytes.toBytes("fam"), Bytes.toBytes("qual"),
270      CompareOperator.LESS_OR_EQUAL, new NullComparator(), false, false);
271    assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
272      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
273  }
274
275  @Test
276  public void testSingleColumnValueFilter() throws Exception {
277    // null family/column SingleColumnValueFilter
278    SingleColumnValueFilter singleColumnValueFilter =
279      new SingleColumnValueFilter(null, null,
280      CompareOperator.LESS, Bytes.toBytes("value"));
281    assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
282      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
283
284    // non-null family/column SingleColumnValueFilter
285    singleColumnValueFilter =
286      new SingleColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"),
287       CompareOperator.NOT_EQUAL, new NullComparator(), true, true);
288    assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
289      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
290  }
291
292  @Test
293  public void testSkipFilter() throws Exception {
294    SkipFilter skipFilter = new SkipFilter(new PageFilter(6));
295    assertTrue(skipFilter.areSerializedFieldsEqual(
296      ProtobufUtil.toFilter(ProtobufUtil.toFilter(skipFilter))));
297  }
298
299  @Test
300  public void testTimestampsFilter() throws Exception {
301    // Empty timestamp list
302    TimestampsFilter timestampsFilter = new TimestampsFilter(new LinkedList<>());
303    assertTrue(timestampsFilter.areSerializedFieldsEqual(
304      ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
305
306    // Non-empty timestamp list
307    LinkedList<Long> list = new LinkedList<>();
308    list.add(System.currentTimeMillis());
309    list.add(System.currentTimeMillis());
310    timestampsFilter = new TimestampsFilter(list);
311    assertTrue(timestampsFilter.areSerializedFieldsEqual(
312      ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
313  }
314
315  @Test
316  public void testValueFilter() throws Exception {
317    ValueFilter valueFilter = new ValueFilter(CompareOperator.NO_OP,
318      new BinaryComparator(Bytes.toBytes("testValueOne")));
319    assertTrue(valueFilter.areSerializedFieldsEqual(
320      ProtobufUtil.toFilter(ProtobufUtil.toFilter(valueFilter))));
321  }
322
323  @Test
324  public void testWhileMatchFilter() throws Exception {
325    WhileMatchFilter whileMatchFilter =
326      new WhileMatchFilter(
327        new ColumnRangeFilter(Bytes.toBytes("c"), false, Bytes.toBytes("d"), true));
328    assertTrue(whileMatchFilter.areSerializedFieldsEqual(
329      ProtobufUtil.toFilter(ProtobufUtil.toFilter(whileMatchFilter))));
330  }
331
332  @Test
333  public void testMultiRowRangeFilter() throws Exception {
334    List<RowRange> ranges = new ArrayList<>();
335    ranges.add(new RowRange(Bytes.toBytes(30), true, Bytes.toBytes(40), false));
336    ranges.add(new RowRange(Bytes.toBytes(10), true, Bytes.toBytes(20), false));
337    ranges.add(new RowRange(Bytes.toBytes(60), true, Bytes.toBytes(70), false));
338
339    MultiRowRangeFilter multiRowRangeFilter =
340      new MultiRowRangeFilter(ranges);
341    assertTrue(multiRowRangeFilter.areSerializedFieldsEqual(
342      ProtobufUtil.toFilter(ProtobufUtil.toFilter(multiRowRangeFilter))));
343  }
344
345  @Test
346  public void testColumnValueFilter() throws Exception {
347    ColumnValueFilter columnValueFilter =
348        new ColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"),
349            CompareOperator.EQUAL, Bytes.toBytes("value"));
350    assertTrue(columnValueFilter.areSerializedFieldsEqual(
351        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnValueFilter))));
352  }
353}