1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.filter;
20
21 import java.io.ByteArrayInputStream;
22 import java.io.ByteArrayOutputStream;
23 import java.io.DataInputStream;
24 import java.io.DataOutputStream;
25 import java.util.regex.Pattern;
26
27 import org.apache.hadoop.hbase.KeyValue;
28 import org.apache.hadoop.hbase.SmallTests;
29 import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
30 import org.apache.hadoop.hbase.util.Bytes;
31
32 import org.junit.Before;
33 import org.junit.Test;
34 import org.junit.experimental.categories.Category;
35
36 import static org.junit.Assert.*;
37
38
39
40
41 @Category(SmallTests.class)
42 public class TestSingleColumnValueFilter {
43 private static final byte[] ROW = Bytes.toBytes("test");
44 private static final byte[] COLUMN_FAMILY = Bytes.toBytes("test");
45 private static final byte [] COLUMN_QUALIFIER = Bytes.toBytes("foo");
46 private static final byte[] VAL_1 = Bytes.toBytes("a");
47 private static final byte[] VAL_2 = Bytes.toBytes("ab");
48 private static final byte[] VAL_3 = Bytes.toBytes("abc");
49 private static final byte[] VAL_4 = Bytes.toBytes("abcd");
50 private static final byte[] FULLSTRING_1 =
51 Bytes.toBytes("The quick brown fox jumps over the lazy dog.");
52 private static final byte[] FULLSTRING_2 =
53 Bytes.toBytes("The slow grey fox trips over the lazy dog.");
54 private static final String QUICK_SUBSTR = "quick";
55 private static final String QUICK_REGEX = ".+quick.+";
56 private static final Pattern QUICK_PATTERN = Pattern.compile("QuIcK", Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
57
58 Filter basicFilter;
59 Filter substrFilter;
60 Filter regexFilter;
61 Filter regexPatternFilter;
62
63 @Before
64 public void setUp() throws Exception {
65 basicFilter = basicFilterNew();
66 substrFilter = substrFilterNew();
67 regexFilter = regexFilterNew();
68 regexPatternFilter = regexFilterNew(QUICK_PATTERN);
69 }
70
71 private Filter basicFilterNew() {
72 return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
73 CompareOp.GREATER_OR_EQUAL, VAL_2);
74 }
75
76 private Filter substrFilterNew() {
77 return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
78 CompareOp.EQUAL,
79 new SubstringComparator(QUICK_SUBSTR));
80 }
81
82 private Filter regexFilterNew() {
83 return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
84 CompareOp.EQUAL,
85 new RegexStringComparator(QUICK_REGEX));
86 }
87
88 private Filter regexFilterNew(Pattern pattern) {
89 return new SingleColumnValueFilter(COLUMN_FAMILY, COLUMN_QUALIFIER,
90 CompareOp.EQUAL,
91 new RegexStringComparator(pattern.pattern(), pattern.flags()));
92 }
93
94 private void basicFilterTests(SingleColumnValueFilter filter)
95 throws Exception {
96 KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
97 assertTrue("basicFilter1", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
98 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_3);
99 assertTrue("basicFilter2", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
100 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_4);
101 assertTrue("basicFilter3", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
102 assertFalse("basicFilterNotNull", filter.filterRow());
103 filter.reset();
104 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
105 assertTrue("basicFilter4", filter.filterKeyValue(kv) == Filter.ReturnCode.NEXT_ROW);
106 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
107 assertTrue("basicFilter4", filter.filterKeyValue(kv) == Filter.ReturnCode.NEXT_ROW);
108 assertFalse("basicFilterAllRemaining", filter.filterAllRemaining());
109 assertTrue("basicFilterNotNull", filter.filterRow());
110 filter.reset();
111 filter.setLatestVersionOnly(false);
112 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_1);
113 assertTrue("basicFilter5", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
114 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER, VAL_2);
115 assertTrue("basicFilter5", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
116 assertFalse("basicFilterNotNull", filter.filterRow());
117 }
118
119 private void substrFilterTests(Filter filter)
120 throws Exception {
121 KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
122 FULLSTRING_1);
123 assertTrue("substrTrue",
124 filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
125 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
126 FULLSTRING_2);
127 assertTrue("substrFalse", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
128 assertFalse("substrFilterAllRemaining", filter.filterAllRemaining());
129 assertFalse("substrFilterNotNull", filter.filterRow());
130 }
131
132 private void regexFilterTests(Filter filter)
133 throws Exception {
134 KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
135 FULLSTRING_1);
136 assertTrue("regexTrue",
137 filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
138 kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
139 FULLSTRING_2);
140 assertTrue("regexFalse", filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
141 assertFalse("regexFilterAllRemaining", filter.filterAllRemaining());
142 assertFalse("regexFilterNotNull", filter.filterRow());
143 }
144
145 private void regexPatternFilterTests(Filter filter)
146 throws Exception {
147 KeyValue kv = new KeyValue(ROW, COLUMN_FAMILY, COLUMN_QUALIFIER,
148 FULLSTRING_1);
149 assertTrue("regexTrue",
150 filter.filterKeyValue(kv) == Filter.ReturnCode.INCLUDE);
151 assertFalse("regexFilterAllRemaining", filter.filterAllRemaining());
152 assertFalse("regexFilterNotNull", filter.filterRow());
153 }
154
155 private Filter serializationTest(Filter filter)
156 throws Exception {
157
158 byte[] buffer = filter.toByteArray();
159
160
161 Filter newFilter = SingleColumnValueFilter.parseFrom(buffer);
162 return newFilter;
163 }
164
165
166
167
168
169 @Test
170 public void testStop() throws Exception {
171 basicFilterTests((SingleColumnValueFilter)basicFilter);
172 substrFilterTests(substrFilter);
173 regexFilterTests(regexFilter);
174 regexPatternFilterTests(regexPatternFilter);
175 }
176
177
178
179
180
181 @Test
182 public void testSerialization() throws Exception {
183 Filter newFilter = serializationTest(basicFilter);
184 basicFilterTests((SingleColumnValueFilter)newFilter);
185 newFilter = serializationTest(substrFilter);
186 substrFilterTests(newFilter);
187 newFilter = serializationTest(regexFilter);
188 regexFilterTests(newFilter);
189 newFilter = serializationTest(regexPatternFilter);
190 regexPatternFilterTests(newFilter);
191 }
192
193 }
194