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.MediumTests;
031import org.apache.hadoop.hbase.util.Bytes;
032import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
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, MediumTests.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
066      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
067
068    // non-empty string
069    columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
070    assertTrue(columnPrefixFilter
071      .areSerializedFieldsEqual(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
079      .areSerializedFieldsEqual(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
084      .areSerializedFieldsEqual(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
107      .areSerializedFieldsEqual(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
115      .areSerializedFieldsEqual(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, new SubstringComparator("testFilterList")));
121    assertTrue(filterList
122      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
123  }
124
125  @Test
126  public void testFilterWrapper() throws Exception {
127    FilterWrapper filterWrapper =
128      new FilterWrapper(new ColumnRangeFilter(Bytes.toBytes("e"), false, Bytes.toBytes("f"), true));
129    assertTrue(filterWrapper
130      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterWrapper))));
131  }
132
133  @SuppressWarnings("deprecation")
134  @Test
135  public void testFirstKeyValueMatchingQualifiersFilter() throws Exception {
136    // empty qualifiers set
137    TreeSet<byte[]> set = new TreeSet<>(Bytes.BYTES_COMPARATOR);
138    FirstKeyValueMatchingQualifiersFilter firstKeyValueMatchingQualifiersFilter =
139      new FirstKeyValueMatchingQualifiersFilter(set);
140    assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
141      ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
142
143    // non-empty qualifiers set
144    set.add(Bytes.toBytes("col0"));
145    set.add(Bytes.toBytes("col1"));
146    firstKeyValueMatchingQualifiersFilter = new FirstKeyValueMatchingQualifiersFilter(set);
147    assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
148      ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
149  }
150
151  @Test
152  public void testFirstKeyOnlyFilter() throws Exception {
153    FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
154    assertTrue(firstKeyOnlyFilter
155      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyOnlyFilter))));
156  }
157
158  @Test
159  public void testFuzzyRowFilter() throws Exception {
160    LinkedList<Pair<byte[], byte[]>> fuzzyList = new LinkedList<>();
161    fuzzyList.add(new Pair<>(Bytes.toBytes("999"), new byte[] { 0, 0, 1 }));
162    fuzzyList.add(new Pair<>(Bytes.toBytes("abcd"), new byte[] { 1, 0, 1, 1 }));
163    FuzzyRowFilter fuzzyRowFilter = new FuzzyRowFilter(fuzzyList);
164    assertTrue(fuzzyRowFilter
165      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(fuzzyRowFilter))));
166  }
167
168  @Test
169  public void testInclusiveStopFilter() throws Exception {
170    // InclusveStopFilter with null stopRowKey
171    InclusiveStopFilter inclusiveStopFilter = new InclusiveStopFilter(null);
172    assertTrue(inclusiveStopFilter
173      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
174
175    // InclusveStopFilter with non-null stopRowKey
176    inclusiveStopFilter = new InclusiveStopFilter(Bytes.toBytes("inclusiveStopFilter"));
177    assertTrue(inclusiveStopFilter
178      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
179  }
180
181  @Test
182  public void testKeyOnlyFilter() throws Exception {
183    // KeyOnlyFilter with lenAsVal
184    KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true);
185    assertTrue(keyOnlyFilter
186      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
187
188    // KeyOnlyFilter without lenAsVal
189    keyOnlyFilter = new KeyOnlyFilter();
190    assertTrue(keyOnlyFilter
191      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
192  }
193
194  @Test
195  public void testMultipleColumnPrefixFilter() throws Exception {
196    // empty array
197    byte[][] prefixes = null;
198    MultipleColumnPrefixFilter multipleColumnPrefixFilter =
199      new MultipleColumnPrefixFilter(prefixes);
200    assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
201      ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
202
203    // non-empty array
204    prefixes = new byte[2][];
205    prefixes[0] = Bytes.toBytes("a");
206    prefixes[1] = Bytes.toBytes("");
207    multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(prefixes);
208    assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
209      ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
210  }
211
212  @Test
213  public void testPageFilter() throws Exception {
214    PageFilter pageFilter = new PageFilter(6);
215    assertTrue(pageFilter
216      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(pageFilter))));
217  }
218
219  @Test
220  public void testPrefixFilter() throws Exception {
221    // null prefix
222    PrefixFilter prefixFilter = new PrefixFilter(null);
223    assertTrue(prefixFilter
224      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
225
226    // non-null prefix
227    prefixFilter = new PrefixFilter(Bytes.toBytes("abc"));
228    assertTrue(prefixFilter
229      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
230  }
231
232  @Test
233  public void testQualifierFilter() throws Exception {
234    QualifierFilter qualifierFilter =
235      new QualifierFilter(CompareOperator.EQUAL, new NullComparator());
236    assertTrue(qualifierFilter
237      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter))));
238  }
239
240  @Test
241  public void testRandomRowFilter() throws Exception {
242    RandomRowFilter randomRowFilter = new RandomRowFilter((float) 0.1);
243    assertTrue(randomRowFilter
244      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(randomRowFilter))));
245  }
246
247  @Test
248  public void testRowFilter() throws Exception {
249    RowFilter rowFilter =
250      new RowFilter(CompareOperator.EQUAL, new SubstringComparator("testRowFilter"));
251    assertTrue(
252      rowFilter.areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter))));
253  }
254
255  @Test
256  public void testSingleColumnValueExcludeFilter() throws Exception {
257    // null family/column SingleColumnValueExcludeFilter
258    SingleColumnValueExcludeFilter singleColumnValueExcludeFilter =
259      new SingleColumnValueExcludeFilter(null, null, CompareOperator.GREATER_OR_EQUAL,
260        Bytes.toBytes("value"));
261    assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
262      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
263
264    // non-null family/column SingleColumnValueFilter
265    singleColumnValueExcludeFilter = new SingleColumnValueExcludeFilter(Bytes.toBytes("fam"),
266      Bytes.toBytes("qual"), CompareOperator.LESS_OR_EQUAL, new NullComparator(), false, false);
267    assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
268      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
269  }
270
271  @Test
272  public void testSingleColumnValueFilter() throws Exception {
273    // null family/column SingleColumnValueFilter
274    SingleColumnValueFilter singleColumnValueFilter =
275      new SingleColumnValueFilter(null, null, CompareOperator.LESS, Bytes.toBytes("value"));
276    assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
277      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
278
279    // non-null family/column SingleColumnValueFilter
280    singleColumnValueFilter = new SingleColumnValueFilter(Bytes.toBytes("family"),
281      Bytes.toBytes("qualifier"), CompareOperator.NOT_EQUAL, new NullComparator(), true, true);
282    assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
283      ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
284  }
285
286  @Test
287  public void testSkipFilter() throws Exception {
288    SkipFilter skipFilter = new SkipFilter(new PageFilter(6));
289    assertTrue(skipFilter
290      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(skipFilter))));
291  }
292
293  @Test
294  public void testTimestampsFilter() throws Exception {
295    // Empty timestamp list
296    TimestampsFilter timestampsFilter = new TimestampsFilter(new LinkedList<>());
297    assertTrue(timestampsFilter
298      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
299
300    // Non-empty timestamp list
301    LinkedList<Long> list = new LinkedList<>();
302    list.add(EnvironmentEdgeManager.currentTime());
303    list.add(EnvironmentEdgeManager.currentTime());
304    timestampsFilter = new TimestampsFilter(list);
305    assertTrue(timestampsFilter
306      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
307  }
308
309  @Test
310  public void testValueFilter() throws Exception {
311    ValueFilter valueFilter =
312      new ValueFilter(CompareOperator.NO_OP, new BinaryComparator(Bytes.toBytes("testValueOne")));
313    assertTrue(valueFilter
314      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(valueFilter))));
315  }
316
317  @Test
318  public void testWhileMatchFilter() throws Exception {
319    WhileMatchFilter whileMatchFilter = new WhileMatchFilter(
320      new ColumnRangeFilter(Bytes.toBytes("c"), false, Bytes.toBytes("d"), true));
321    assertTrue(whileMatchFilter
322      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(whileMatchFilter))));
323  }
324
325  @Test
326  public void testMultiRowRangeFilter() throws Exception {
327    List<RowRange> ranges = new ArrayList<>();
328    ranges.add(new RowRange(Bytes.toBytes(30), true, Bytes.toBytes(40), false));
329    ranges.add(new RowRange(Bytes.toBytes(10), true, Bytes.toBytes(20), false));
330    ranges.add(new RowRange(Bytes.toBytes(60), true, Bytes.toBytes(70), false));
331
332    MultiRowRangeFilter multiRowRangeFilter = new MultiRowRangeFilter(ranges);
333    assertTrue(multiRowRangeFilter
334      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(multiRowRangeFilter))));
335  }
336
337  @Test
338  public void testColumnValueFilter() throws Exception {
339    ColumnValueFilter columnValueFilter = new ColumnValueFilter(Bytes.toBytes("family"),
340      Bytes.toBytes("qualifier"), CompareOperator.EQUAL, Bytes.toBytes("value"));
341    assertTrue(columnValueFilter
342      .areSerializedFieldsEqual(ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnValueFilter))));
343  }
344}