View Javadoc

1   /**
2    * Copyright The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  package org.apache.hadoop.hbase.filter;
21  
22  import static org.junit.Assert.assertTrue;
23  
24  import java.util.ArrayList;
25  import java.util.LinkedList;
26  import java.util.List;
27  import java.util.TreeSet;
28  
29  import org.apache.hadoop.hbase.testclassification.SmallTests;
30  import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
31  import org.apache.hadoop.hbase.filter.MultiRowRangeFilter.RowRange;
32  import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
33  import org.apache.hadoop.hbase.util.Bytes;
34  import org.apache.hadoop.hbase.util.Pair;
35  import org.junit.Test;
36  import org.junit.experimental.categories.Category;
37  
38  @Category(SmallTests.class)
39  public class TestFilterSerialization {
40  
41    @Test
42    public void testColumnCountGetFilter() throws Exception {
43      ColumnCountGetFilter columnCountGetFilter = new ColumnCountGetFilter(1);
44      assertTrue(columnCountGetFilter.areSerializedFieldsEqual(
45        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnCountGetFilter))));
46    }
47  
48    @Test
49    public void testColumnPaginationFilter() throws Exception {
50      ColumnPaginationFilter columnPaginationFilter = new ColumnPaginationFilter(1,7);
51      assertTrue(columnPaginationFilter.areSerializedFieldsEqual(
52        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPaginationFilter))));
53    }
54  
55    @Test
56    public void testColumnPrefixFilter() throws Exception {
57      // empty string
58      ColumnPrefixFilter columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
59      assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
60        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
61  
62      // non-empty string
63      columnPrefixFilter = new ColumnPrefixFilter(Bytes.toBytes(""));
64      assertTrue(columnPrefixFilter.areSerializedFieldsEqual(
65        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnPrefixFilter))));
66    }
67  
68    @Test
69    public void testColumnRangeFilter() throws Exception {
70      // null columns
71      ColumnRangeFilter columnRangeFilter = new ColumnRangeFilter(null, true, null, false);
72      assertTrue(columnRangeFilter.areSerializedFieldsEqual(
73        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
74  
75      // non-null columns
76      columnRangeFilter = new ColumnRangeFilter(Bytes.toBytes("a"), false, Bytes.toBytes("b"), true);
77      assertTrue(columnRangeFilter.areSerializedFieldsEqual(
78        ProtobufUtil.toFilter(ProtobufUtil.toFilter(columnRangeFilter))));
79    }
80  
81    @Test
82    public void testDependentColumnFilter() throws Exception {
83      // null column qualifier/family
84      DependentColumnFilter dependentColumnFilter = new DependentColumnFilter(null, null);
85      assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
86        ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
87  
88      // non-null column qualifier/family
89      dependentColumnFilter = new DependentColumnFilter(Bytes.toBytes("family"),
90        Bytes.toBytes("qual"), true, CompareOp.GREATER_OR_EQUAL,
91        new BitComparator(Bytes.toBytes("bitComparator"), BitComparator.BitwiseOp.OR));
92      assertTrue(dependentColumnFilter.areSerializedFieldsEqual(
93        ProtobufUtil.toFilter(ProtobufUtil.toFilter(dependentColumnFilter))));
94    }
95  
96    @Test
97    public void testFamilyFilter() throws Exception {
98      FamilyFilter familyFilter = new FamilyFilter(CompareFilter.CompareOp.EQUAL,
99        new BinaryPrefixComparator(Bytes.toBytes("testValueOne")));
100     assertTrue(familyFilter.areSerializedFieldsEqual(
101       ProtobufUtil.toFilter(ProtobufUtil.toFilter(familyFilter))));
102   }
103 
104   @Test
105   public void testFilterList() throws Exception {
106     // empty filter list
107     FilterList filterList = new FilterList(new LinkedList<Filter>());
108     assertTrue(filterList.areSerializedFieldsEqual(
109       ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
110 
111     // non-empty filter list
112     LinkedList<Filter> list = new LinkedList<Filter>();
113     list.add(new ColumnCountGetFilter(1));
114     list.add(new RowFilter(CompareFilter.CompareOp.EQUAL,
115       new SubstringComparator("testFilterList")));
116     assertTrue(filterList.areSerializedFieldsEqual(
117       ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterList))));
118   }
119 
120   @Test
121   public void testFilterWrapper() throws Exception {
122     FilterWrapper filterWrapper =
123       new FilterWrapper(
124         new ColumnRangeFilter(Bytes.toBytes("e"), false, Bytes.toBytes("f"), true));
125     assertTrue(filterWrapper.areSerializedFieldsEqual(
126       ProtobufUtil.toFilter(ProtobufUtil.toFilter(filterWrapper))));
127   }
128 
129   @Test
130   public void testFirstKeyValueMatchingQualifiersFilter() throws Exception {
131     // empty qualifiers set
132     TreeSet<byte []> set = new TreeSet<byte []>(Bytes.BYTES_COMPARATOR);
133     FirstKeyValueMatchingQualifiersFilter firstKeyValueMatchingQualifiersFilter =
134       new FirstKeyValueMatchingQualifiersFilter(set);
135     assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
136       ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
137 
138     // non-empty qualifiers set
139     set.add(Bytes.toBytes("col0"));
140     set.add(Bytes.toBytes("col1"));
141     firstKeyValueMatchingQualifiersFilter =
142       new FirstKeyValueMatchingQualifiersFilter(set);
143     assertTrue(firstKeyValueMatchingQualifiersFilter.areSerializedFieldsEqual(
144       ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyValueMatchingQualifiersFilter))));
145   }
146 
147   @Test
148   public void testFirstKeyOnlyFilter() throws Exception {
149     FirstKeyOnlyFilter firstKeyOnlyFilter = new FirstKeyOnlyFilter();
150     assertTrue(firstKeyOnlyFilter.areSerializedFieldsEqual(
151       ProtobufUtil.toFilter(ProtobufUtil.toFilter(firstKeyOnlyFilter))));
152   }
153 
154   @Test
155   public void testFuzzyRowFilter() throws Exception {
156     LinkedList<Pair<byte[], byte[]>> fuzzyList = new LinkedList<Pair<byte[], byte[]>>();
157     fuzzyList.add(new Pair<byte[], byte[]>(Bytes.toBytes("999"),new byte[] {0, 0, 1}));
158     fuzzyList.add(new Pair<byte[], byte[]>(Bytes.toBytes("abcd"),new byte[] {1, 0, 1, 1}));
159     FuzzyRowFilter fuzzyRowFilter = new FuzzyRowFilter(fuzzyList);
160     assertTrue(fuzzyRowFilter.areSerializedFieldsEqual(
161       ProtobufUtil.toFilter(ProtobufUtil.toFilter(fuzzyRowFilter))));
162   }
163 
164   @Test
165   public void testInclusiveStopFilter() throws Exception {
166     // InclusveStopFilter with null stopRowKey
167     InclusiveStopFilter inclusiveStopFilter = new InclusiveStopFilter(null);
168     assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
169       ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
170 
171     // InclusveStopFilter with non-null stopRowKey
172     inclusiveStopFilter = new InclusiveStopFilter(Bytes.toBytes("inclusiveStopFilter"));
173     assertTrue(inclusiveStopFilter.areSerializedFieldsEqual(
174       ProtobufUtil.toFilter(ProtobufUtil.toFilter(inclusiveStopFilter))));
175   }
176 
177   @Test
178   public void testKeyOnlyFilter() throws Exception {
179     // KeyOnlyFilter with lenAsVal
180     KeyOnlyFilter keyOnlyFilter = new KeyOnlyFilter(true);
181     assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
182       ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
183 
184     // KeyOnlyFilter without lenAsVal
185     keyOnlyFilter = new KeyOnlyFilter();
186     assertTrue(keyOnlyFilter.areSerializedFieldsEqual(
187       ProtobufUtil.toFilter(ProtobufUtil.toFilter(keyOnlyFilter))));
188   }
189 
190   @Test
191   public void testMultipleColumnPrefixFilter() throws Exception {
192     // empty array
193     byte [][] prefixes = null;
194     MultipleColumnPrefixFilter multipleColumnPrefixFilter =
195       new MultipleColumnPrefixFilter(prefixes);
196     assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
197       ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
198 
199     // non-empty array
200     prefixes = new byte[2][];
201     prefixes[0] = Bytes.toBytes("a");
202     prefixes[1] = Bytes.toBytes("");
203     multipleColumnPrefixFilter = new MultipleColumnPrefixFilter(prefixes);
204     assertTrue(multipleColumnPrefixFilter.areSerializedFieldsEqual(
205       ProtobufUtil.toFilter(ProtobufUtil.toFilter(multipleColumnPrefixFilter))));
206   }
207 
208   @Test
209   public void testPageFilter() throws Exception {
210     PageFilter pageFilter = new PageFilter(6);
211     assertTrue(pageFilter.areSerializedFieldsEqual(
212       ProtobufUtil.toFilter(ProtobufUtil.toFilter(pageFilter))));
213   }
214 
215   @Test
216   public void testPrefixFilter() throws Exception {
217     // null prefix
218     PrefixFilter prefixFilter = new PrefixFilter(null);
219     assertTrue(prefixFilter.areSerializedFieldsEqual(
220       ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
221 
222     // non-null prefix
223     prefixFilter = new PrefixFilter(Bytes.toBytes("abc"));
224     assertTrue(prefixFilter.areSerializedFieldsEqual(
225       ProtobufUtil.toFilter(ProtobufUtil.toFilter(prefixFilter))));
226   }
227 
228   @Test
229   public void testQualifierFilter() throws Exception {
230     QualifierFilter qualifierFilter = new QualifierFilter(CompareFilter.CompareOp.EQUAL,
231       new NullComparator());
232     assertTrue(qualifierFilter.areSerializedFieldsEqual(
233       ProtobufUtil.toFilter(ProtobufUtil.toFilter(qualifierFilter))));
234   }
235 
236   @Test
237   public void testRandomRowFilter() throws Exception {
238     RandomRowFilter randomRowFilter = new RandomRowFilter((float)0.1);
239     assertTrue(randomRowFilter.areSerializedFieldsEqual(
240       ProtobufUtil.toFilter(ProtobufUtil.toFilter(randomRowFilter))));
241   }
242 
243   @Test
244   public void testRowFilter() throws Exception {
245     RowFilter rowFilter = new RowFilter(CompareFilter.CompareOp.EQUAL,
246       new SubstringComparator("testRowFilter"));
247     assertTrue(rowFilter.areSerializedFieldsEqual(
248       ProtobufUtil.toFilter(ProtobufUtil.toFilter(rowFilter))));
249   }
250 
251   @Test
252   public void testSingleColumnValueExcludeFilter() throws Exception {
253     // null family/column SingleColumnValueExcludeFilter
254     SingleColumnValueExcludeFilter singleColumnValueExcludeFilter =
255       new SingleColumnValueExcludeFilter(null, null,
256       CompareFilter.CompareOp.GREATER_OR_EQUAL, Bytes.toBytes("value"));
257     assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
258       ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
259 
260     // non-null family/column SingleColumnValueFilter
261     singleColumnValueExcludeFilter =
262       new SingleColumnValueExcludeFilter(Bytes.toBytes("fam"), Bytes.toBytes("qual"),
263       CompareFilter.CompareOp.LESS_OR_EQUAL, new NullComparator(), false, false);
264     assertTrue(singleColumnValueExcludeFilter.areSerializedFieldsEqual(
265       ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueExcludeFilter))));
266   }
267 
268   @Test
269   public void testSingleColumnValueFilter() throws Exception {
270     // null family/column SingleColumnValueFilter
271     SingleColumnValueFilter singleColumnValueFilter =
272       new SingleColumnValueFilter(null, null,
273       CompareFilter.CompareOp.LESS, Bytes.toBytes("value"));
274     assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
275       ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
276 
277     // non-null family/column SingleColumnValueFilter
278     singleColumnValueFilter =
279       new SingleColumnValueFilter(Bytes.toBytes("family"), Bytes.toBytes("qualifier"),
280       CompareFilter.CompareOp.NOT_EQUAL, new NullComparator(), true, true);
281     assertTrue(singleColumnValueFilter.areSerializedFieldsEqual(
282       ProtobufUtil.toFilter(ProtobufUtil.toFilter(singleColumnValueFilter))));
283   }
284 
285   @Test
286   public void testSkipFilter() throws Exception {
287     SkipFilter skipFilter = new SkipFilter(new PageFilter(6));
288     assertTrue(skipFilter.areSerializedFieldsEqual(
289       ProtobufUtil.toFilter(ProtobufUtil.toFilter(skipFilter))));
290   }
291 
292   @Test
293   public void testTimestampsFilter() throws Exception {
294     // Empty timestamp list
295     TimestampsFilter timestampsFilter = new TimestampsFilter(new LinkedList<Long>());
296     assertTrue(timestampsFilter.areSerializedFieldsEqual(
297       ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
298 
299     // Non-empty timestamp list
300     LinkedList<Long> list = new LinkedList<Long>();
301     list.add(new Long(System.currentTimeMillis()));
302     list.add(new Long(System.currentTimeMillis()));
303     timestampsFilter = new TimestampsFilter(list);
304     assertTrue(timestampsFilter.areSerializedFieldsEqual(
305       ProtobufUtil.toFilter(ProtobufUtil.toFilter(timestampsFilter))));
306   }
307 
308   @Test
309   public void testValueFilter() throws Exception {
310     ValueFilter valueFilter = new ValueFilter(CompareFilter.CompareOp.NO_OP,
311       new BinaryComparator(Bytes.toBytes("testValueOne")));
312     assertTrue(valueFilter.areSerializedFieldsEqual(
313       ProtobufUtil.toFilter(ProtobufUtil.toFilter(valueFilter))));
314   }
315 
316   @Test
317   public void testWhileMatchFilter() throws Exception {
318     WhileMatchFilter whileMatchFilter =
319       new WhileMatchFilter(
320         new ColumnRangeFilter(Bytes.toBytes("c"), false, Bytes.toBytes("d"), true));
321     assertTrue(whileMatchFilter.areSerializedFieldsEqual(
322       ProtobufUtil.toFilter(ProtobufUtil.toFilter(whileMatchFilter))));
323   }
324 
325   @Test
326   public void testMultiRowRangeFilter() throws Exception {
327     List<RowRange> ranges = new ArrayList<RowRange>();
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 =
333       new MultiRowRangeFilter(ranges);
334     assertTrue(multiRowRangeFilter.areSerializedFieldsEqual(
335       ProtobufUtil.toFilter(ProtobufUtil.toFilter(multiRowRangeFilter))));
336   }
337 }