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}