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