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