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.client;
21
22 import java.io.IOException;
23 import java.nio.ByteBuffer;
24 import java.util.ArrayList;
25 import java.util.List;
26 import java.util.Map;
27 import java.util.NavigableMap;
28 import java.util.TreeMap;
29 import java.util.UUID;
30
31 import org.apache.hadoop.hbase.Cell;
32 import org.apache.hadoop.hbase.CellUtil;
33 import org.apache.hadoop.hbase.HConstants;
34 import org.apache.hadoop.hbase.KeyValue;
35 import org.apache.hadoop.hbase.Tag;
36 import org.apache.hadoop.hbase.classification.InterfaceAudience;
37 import org.apache.hadoop.hbase.classification.InterfaceStability;
38 import org.apache.hadoop.hbase.io.HeapSize;
39 import org.apache.hadoop.hbase.security.access.Permission;
40 import org.apache.hadoop.hbase.security.visibility.CellVisibility;
41 import org.apache.hadoop.hbase.util.Bytes;
42
43
44
45
46
47
48
49
50 @InterfaceAudience.Public
51 @InterfaceStability.Stable
52 public class Put extends Mutation implements HeapSize, Comparable<Row> {
53
54
55
56
57 public Put(byte [] row) {
58 this(row, HConstants.LATEST_TIMESTAMP);
59 }
60
61
62
63
64
65
66
67 public Put(byte[] row, long ts) {
68 this(row, 0, row.length, ts);
69 }
70
71
72
73
74
75
76
77 public Put(byte [] rowArray, int rowOffset, int rowLength) {
78 this(rowArray, rowOffset, rowLength, HConstants.LATEST_TIMESTAMP);
79 }
80
81
82
83
84
85 public Put(ByteBuffer row, long ts) {
86 if (ts < 0) {
87 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
88 }
89 checkRow(row);
90 this.row = new byte[row.remaining()];
91 row.get(this.row);
92 this.ts = ts;
93 }
94
95
96
97
98 public Put(ByteBuffer row) {
99 this(row, HConstants.LATEST_TIMESTAMP);
100 }
101
102
103
104
105
106
107
108
109 public Put(byte [] rowArray, int rowOffset, int rowLength, long ts) {
110 checkRow(rowArray, rowOffset, rowLength);
111 this.row = Bytes.copy(rowArray, rowOffset, rowLength);
112 this.ts = ts;
113 if (ts < 0) {
114 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
115 }
116 }
117
118
119
120
121
122 public Put(Put putToCopy) {
123 this(putToCopy.getRow(), putToCopy.ts);
124 this.familyMap = new TreeMap<byte [], List<Cell>>(Bytes.BYTES_COMPARATOR);
125 for(Map.Entry<byte [], List<Cell>> entry: putToCopy.getFamilyCellMap().entrySet()) {
126 this.familyMap.put(entry.getKey(), new ArrayList<Cell>(entry.getValue()));
127 }
128 this.durability = putToCopy.durability;
129 for (Map.Entry<String, byte[]> entry : putToCopy.getAttributesMap().entrySet()) {
130 this.setAttribute(entry.getKey(), entry.getValue());
131 }
132 }
133
134
135
136
137
138
139
140
141 public Put addColumn(byte [] family, byte [] qualifier, byte [] value) {
142 return addColumn(family, qualifier, this.ts, value);
143 }
144
145
146
147
148
149
150 public Put addImmutable(byte [] family, byte [] qualifier, byte [] value) {
151 return addImmutable(family, qualifier, this.ts, value);
152 }
153
154
155
156
157
158
159
160 @InterfaceAudience.Private
161 public Put addImmutable(byte[] family, byte [] qualifier, byte [] value, Tag[] tag) {
162 return addImmutable(family, qualifier, this.ts, value, tag);
163 }
164
165
166
167
168
169
170
171
172
173
174 public Put addColumn(byte [] family, byte [] qualifier, long ts, byte [] value) {
175 if (ts < 0) {
176 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
177 }
178 List<Cell> list = getCellList(family);
179 KeyValue kv = createPutKeyValue(family, qualifier, ts, value);
180 list.add(kv);
181 familyMap.put(CellUtil.cloneFamily(kv), list);
182 return this;
183 }
184
185
186
187
188
189
190 public Put addImmutable(byte [] family, byte [] qualifier, long ts, byte [] value) {
191 if (ts < 0) {
192 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
193 }
194 List<Cell> list = getCellList(family);
195 KeyValue kv = createPutKeyValue(family, qualifier, ts, value);
196 list.add(kv);
197 familyMap.put(family, list);
198 return this;
199 }
200
201
202
203
204
205
206
207 @InterfaceAudience.Private
208 public Put addImmutable(byte[] family, byte[] qualifier, long ts, byte[] value, Tag[] tag) {
209 List<Cell> list = getCellList(family);
210 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, tag);
211 list.add(kv);
212 familyMap.put(family, list);
213 return this;
214 }
215
216
217
218
219
220
221
222 @InterfaceAudience.Private
223 public Put addImmutable(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value,
224 Tag[] tag) {
225 if (ts < 0) {
226 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
227 }
228 List<Cell> list = getCellList(family);
229 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, tag);
230 list.add(kv);
231 familyMap.put(family, list);
232 return this;
233 }
234
235
236
237
238
239
240
241
242
243
244
245 public Put addColumn(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) {
246 if (ts < 0) {
247 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
248 }
249 List<Cell> list = getCellList(family);
250 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, null);
251 list.add(kv);
252 familyMap.put(CellUtil.cloneFamily(kv), list);
253 return this;
254 }
255
256
257
258
259
260
261 public Put addImmutable(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) {
262 if (ts < 0) {
263 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
264 }
265 List<Cell> list = getCellList(family);
266 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, null);
267 list.add(kv);
268 familyMap.put(family, list);
269 return this;
270 }
271
272
273
274
275
276
277
278
279
280 public Put add(Cell kv) throws IOException{
281 byte [] family = CellUtil.cloneFamily(kv);
282 List<Cell> list = getCellList(family);
283
284 int res = Bytes.compareTo(this.row, 0, row.length,
285 kv.getRowArray(), kv.getRowOffset(), kv.getRowLength());
286 if (res != 0) {
287 throw new WrongRowIOException("The row in " + kv.toString() +
288 " doesn't match the original one " + Bytes.toStringBinary(this.row));
289 }
290 list.add(kv);
291 familyMap.put(family, list);
292 return this;
293 }
294
295
296
297
298
299
300
301
302
303
304
305 public boolean has(byte [] family, byte [] qualifier) {
306 return has(family, qualifier, this.ts, new byte[0], true, true);
307 }
308
309
310
311
312
313
314
315
316
317
318
319
320 public boolean has(byte [] family, byte [] qualifier, long ts) {
321 return has(family, qualifier, ts, new byte[0], false, true);
322 }
323
324
325
326
327
328
329
330
331
332
333
334
335 public boolean has(byte [] family, byte [] qualifier, byte [] value) {
336 return has(family, qualifier, this.ts, value, true, false);
337 }
338
339
340
341
342
343
344
345
346
347
348
349
350
351 public boolean has(byte [] family, byte [] qualifier, long ts, byte [] value) {
352 return has(family, qualifier, ts, value, false, false);
353 }
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369 private boolean has(byte[] family, byte[] qualifier, long ts, byte[] value,
370 boolean ignoreTS, boolean ignoreValue) {
371 List<Cell> list = getCellList(family);
372 if (list.size() == 0) {
373 return false;
374 }
375
376
377
378
379
380 if (!ignoreTS && !ignoreValue) {
381 for (Cell cell : list) {
382 if (CellUtil.matchingFamily(cell, family) &&
383 CellUtil.matchingQualifier(cell, qualifier) &&
384 CellUtil.matchingValue(cell, value) &&
385 cell.getTimestamp() == ts) {
386 return true;
387 }
388 }
389 } else if (ignoreValue && !ignoreTS) {
390 for (Cell cell : list) {
391 if (CellUtil.matchingFamily(cell, family) && CellUtil.matchingQualifier(cell, qualifier)
392 && cell.getTimestamp() == ts) {
393 return true;
394 }
395 }
396 } else if (!ignoreValue && ignoreTS) {
397 for (Cell cell : list) {
398 if (CellUtil.matchingFamily(cell, family) && CellUtil.matchingQualifier(cell, qualifier)
399 && CellUtil.matchingValue(cell, value)) {
400 return true;
401 }
402 }
403 } else {
404 for (Cell cell : list) {
405 if (CellUtil.matchingFamily(cell, family) &&
406 CellUtil.matchingQualifier(cell, qualifier)) {
407 return true;
408 }
409 }
410 }
411 return false;
412 }
413
414
415
416
417
418
419
420
421
422 public List<Cell> get(byte[] family, byte[] qualifier) {
423 List<Cell> filteredList = new ArrayList<Cell>();
424 for (Cell cell: getCellList(family)) {
425 if (CellUtil.matchingQualifier(cell, qualifier)) {
426 filteredList.add(cell);
427 }
428 }
429 return filteredList;
430 }
431
432 @Override
433 public Put setAttribute(String name, byte[] value) {
434 return (Put) super.setAttribute(name, value);
435 }
436
437 @Override
438 public Put setId(String id) {
439 return (Put) super.setId(id);
440 }
441
442 @Override
443 public Put setDurability(Durability d) {
444 return (Put) super.setDurability(d);
445 }
446
447 @Override
448 public Put setFamilyCellMap(NavigableMap<byte[], List<Cell>> map) {
449 return (Put) super.setFamilyCellMap(map);
450 }
451
452 @Override
453 public Put setClusterIds(List<UUID> clusterIds) {
454 return (Put) super.setClusterIds(clusterIds);
455 }
456
457 @Override
458 public Put setCellVisibility(CellVisibility expression) {
459 return (Put) super.setCellVisibility(expression);
460 }
461
462 @Override
463 public Put setACL(String user, Permission perms) {
464 return (Put) super.setACL(user, perms);
465 }
466
467 @Override
468 public Put setACL(Map<String, Permission> perms) {
469 return (Put) super.setACL(perms);
470 }
471
472 @Override
473 public Put setTTL(long ttl) {
474 return (Put) super.setTTL(ttl);
475 }
476 }