1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.hadoop.hbase.filter;
21
22 import com.google.protobuf.InvalidProtocolBufferException;
23 import org.apache.hadoop.classification.InterfaceAudience;
24 import org.apache.hadoop.classification.InterfaceStability;
25 import org.apache.hadoop.hbase.KeyValue;
26 import org.apache.hadoop.hbase.exceptions.DeserializationException;
27 import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
28 import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
29 import org.apache.hadoop.hbase.protobuf.generated.FilterProtos;
30
31 import java.io.IOException;
32 import java.util.ArrayList;
33 import java.util.Iterator;
34 import java.util.List;
35
36
37
38
39
40
41
42 @InterfaceAudience.Public
43 @InterfaceStability.Stable
44 public class SingleColumnValueExcludeFilter extends SingleColumnValueFilter {
45
46
47
48
49
50
51
52
53
54
55
56
57 public SingleColumnValueExcludeFilter(byte[] family, byte[] qualifier,
58 CompareOp compareOp, byte[] value) {
59 super(family, qualifier, compareOp, value);
60 }
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77 public SingleColumnValueExcludeFilter(byte[] family, byte[] qualifier,
78 CompareOp compareOp, ByteArrayComparable comparator) {
79 super(family, qualifier, compareOp, comparator);
80 }
81
82
83
84
85
86
87
88
89
90
91 protected SingleColumnValueExcludeFilter(final byte[] family, final byte[] qualifier,
92 final CompareOp compareOp, ByteArrayComparable comparator, final boolean filterIfMissing,
93 final boolean latestVersionOnly) {
94 super(family, qualifier, compareOp, comparator, filterIfMissing, latestVersionOnly);
95 }
96
97
98 public boolean hasFilterRow() {
99 return true;
100 }
101
102
103 public void filterRow(List<KeyValue> kvs) {
104 Iterator it = kvs.iterator();
105 while (it.hasNext()) {
106 KeyValue kv = (KeyValue)it.next();
107
108
109 if (kv.matchingColumn(this.columnFamily, this.columnQualifier)) {
110 it.remove();
111 }
112 }
113 }
114
115 public static Filter createFilterFromArguments(ArrayList<byte []> filterArguments) {
116 SingleColumnValueFilter tempFilter = (SingleColumnValueFilter)
117 SingleColumnValueFilter.createFilterFromArguments(filterArguments);
118 SingleColumnValueExcludeFilter filter = new SingleColumnValueExcludeFilter (
119 tempFilter.getFamily(), tempFilter.getQualifier(),
120 tempFilter.getOperator(), tempFilter.getComparator());
121
122 if (filterArguments.size() == 6) {
123 filter.setFilterIfMissing(tempFilter.getFilterIfMissing());
124 filter.setLatestVersionOnly(tempFilter.getLatestVersionOnly());
125 }
126 return filter;
127 }
128
129
130
131
132 public byte [] toByteArray() {
133 FilterProtos.SingleColumnValueExcludeFilter.Builder builder =
134 FilterProtos.SingleColumnValueExcludeFilter.newBuilder();
135 builder.setSingleColumnValueFilter(super.convert());
136 return builder.build().toByteArray();
137 }
138
139
140
141
142
143
144
145 public static SingleColumnValueExcludeFilter parseFrom(final byte [] pbBytes)
146 throws DeserializationException {
147 FilterProtos.SingleColumnValueExcludeFilter proto;
148 try {
149 proto = FilterProtos.SingleColumnValueExcludeFilter.parseFrom(pbBytes);
150 } catch (InvalidProtocolBufferException e) {
151 throw new DeserializationException(e);
152 }
153
154 FilterProtos.SingleColumnValueFilter parentProto = proto.getSingleColumnValueFilter();
155 final CompareOp compareOp =
156 CompareOp.valueOf(parentProto.getCompareOp().name());
157 final ByteArrayComparable comparator;
158 try {
159 comparator = ProtobufUtil.toComparator(parentProto.getComparator());
160 } catch (IOException ioe) {
161 throw new DeserializationException(ioe);
162 }
163
164 return new SingleColumnValueExcludeFilter(parentProto.hasColumnFamily() ? parentProto
165 .getColumnFamily().toByteArray() : null, parentProto.hasColumnQualifier() ? parentProto
166 .getColumnQualifier().toByteArray() : null, compareOp, comparator, parentProto
167 .getFilterIfMissing(), parentProto.getLatestVersionOnly());
168 }
169
170
171
172
173
174
175 boolean areSerializedFieldsEqual(Filter o) {
176 if (o == this) return true;
177 if (!(o instanceof SingleColumnValueExcludeFilter)) return false;
178
179 return super.areSerializedFieldsEqual(o);
180 }
181 }