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.classification.InterfaceAudience;
32 import org.apache.hadoop.hbase.classification.InterfaceStability;
33 import org.apache.hadoop.hbase.Cell;
34 import org.apache.hadoop.hbase.CellUtil;
35 import org.apache.hadoop.hbase.HConstants;
36 import org.apache.hadoop.hbase.KeyValue;
37 import org.apache.hadoop.hbase.Tag;
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
142 @Deprecated
143 public Put add(byte [] family, byte [] qualifier, byte [] value) {
144 return addColumn(family, qualifier, value);
145 }
146
147
148
149
150
151
152
153
154 public Put addColumn(byte [] family, byte [] qualifier, byte [] value) {
155 return addColumn(family, qualifier, this.ts, value);
156 }
157
158
159
160
161
162
163 public Put addImmutable(byte [] family, byte [] qualifier, byte [] value) {
164 return addImmutable(family, qualifier, this.ts, value);
165 }
166
167
168
169
170
171 public Put addImmutable(byte[] family, byte [] qualifier, byte [] value, Tag[] tag) {
172 return addImmutable(family, qualifier, this.ts, value, tag);
173 }
174
175
176
177
178
179
180
181
182
183
184
185 @Deprecated
186 public Put add(byte [] family, byte [] qualifier, long ts, byte [] value) {
187 return addColumn(family, qualifier, ts, value);
188 }
189
190
191
192
193
194
195
196
197
198
199 public Put addColumn(byte [] family, byte [] qualifier, long ts, byte [] value) {
200 if (ts < 0) {
201 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
202 }
203 List<Cell> list = getCellList(family);
204 KeyValue kv = createPutKeyValue(family, qualifier, ts, value);
205 list.add(kv);
206 familyMap.put(CellUtil.cloneFamily(kv), list);
207 return this;
208 }
209
210
211
212
213
214
215 public Put addImmutable(byte [] family, byte [] qualifier, long ts, byte [] value) {
216 if (ts < 0) {
217 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
218 }
219 List<Cell> list = getCellList(family);
220 KeyValue kv = createPutKeyValue(family, qualifier, ts, value);
221 list.add(kv);
222 familyMap.put(family, list);
223 return this;
224 }
225
226
227
228
229
230 public Put addImmutable(byte[] family, byte[] qualifier, long ts, byte[] value, Tag[] tag) {
231 List<Cell> list = getCellList(family);
232 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, tag);
233 list.add(kv);
234 familyMap.put(family, list);
235 return this;
236 }
237
238
239
240
241
242 public Put addImmutable(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value,
243 Tag[] tag) {
244 if (ts < 0) {
245 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
246 }
247 List<Cell> list = getCellList(family);
248 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, tag);
249 list.add(kv);
250 familyMap.put(family, list);
251 return this;
252 }
253
254
255
256
257
258
259
260
261
262
263
264
265 @Deprecated
266 public Put add(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) {
267 return addColumn(family, qualifier, ts, value);
268 }
269
270
271
272
273
274
275
276
277
278
279 public Put addColumn(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) {
280 if (ts < 0) {
281 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
282 }
283 List<Cell> list = getCellList(family);
284 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, null);
285 list.add(kv);
286 familyMap.put(CellUtil.cloneFamily(kv), list);
287 return this;
288 }
289
290
291
292
293
294
295 public Put addImmutable(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value) {
296 if (ts < 0) {
297 throw new IllegalArgumentException("Timestamp cannot be negative. ts=" + ts);
298 }
299 List<Cell> list = getCellList(family);
300 KeyValue kv = createPutKeyValue(family, qualifier, ts, value, null);
301 list.add(kv);
302 familyMap.put(family, list);
303 return this;
304 }
305
306
307
308
309
310
311
312
313
314 public Put add(Cell kv) throws IOException{
315 byte [] family = CellUtil.cloneFamily(kv);
316 List<Cell> list = getCellList(family);
317
318 int res = Bytes.compareTo(this.row, 0, row.length,
319 kv.getRowArray(), kv.getRowOffset(), kv.getRowLength());
320 if (res != 0) {
321 throw new WrongRowIOException("The row in " + kv.toString() +
322 " doesn't match the original one " + Bytes.toStringBinary(this.row));
323 }
324 list.add(kv);
325 familyMap.put(family, list);
326 return this;
327 }
328
329
330
331
332
333
334
335
336
337
338
339 public boolean has(byte [] family, byte [] qualifier) {
340 return has(family, qualifier, this.ts, new byte[0], true, true);
341 }
342
343
344
345
346
347
348
349
350
351
352
353
354 public boolean has(byte [] family, byte [] qualifier, long ts) {
355 return has(family, qualifier, ts, new byte[0], false, true);
356 }
357
358
359
360
361
362
363
364
365
366
367
368
369 public boolean has(byte [] family, byte [] qualifier, byte [] value) {
370 return has(family, qualifier, this.ts, value, true, false);
371 }
372
373
374
375
376
377
378
379
380
381
382
383
384
385 public boolean has(byte [] family, byte [] qualifier, long ts, byte [] value) {
386 return has(family, qualifier, ts, value, false, false);
387 }
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403 private boolean has(byte[] family, byte[] qualifier, long ts, byte[] value,
404 boolean ignoreTS, boolean ignoreValue) {
405 List<Cell> list = getCellList(family);
406 if (list.size() == 0) {
407 return false;
408 }
409
410
411
412
413
414 if (!ignoreTS && !ignoreValue) {
415 for (Cell cell : list) {
416 if (CellUtil.matchingFamily(cell, family) &&
417 CellUtil.matchingQualifier(cell, qualifier) &&
418 CellUtil.matchingValue(cell, value) &&
419 cell.getTimestamp() == ts) {
420 return true;
421 }
422 }
423 } else if (ignoreValue && !ignoreTS) {
424 for (Cell cell : list) {
425 if (CellUtil.matchingFamily(cell, family) && CellUtil.matchingQualifier(cell, qualifier)
426 && cell.getTimestamp() == ts) {
427 return true;
428 }
429 }
430 } else if (!ignoreValue && ignoreTS) {
431 for (Cell cell : list) {
432 if (CellUtil.matchingFamily(cell, family) && CellUtil.matchingQualifier(cell, qualifier)
433 && CellUtil.matchingValue(cell, value)) {
434 return true;
435 }
436 }
437 } else {
438 for (Cell cell : list) {
439 if (CellUtil.matchingFamily(cell, family) &&
440 CellUtil.matchingQualifier(cell, qualifier)) {
441 return true;
442 }
443 }
444 }
445 return false;
446 }
447
448
449
450
451
452
453
454
455
456 public List<Cell> get(byte[] family, byte[] qualifier) {
457 List<Cell> filteredList = new ArrayList<Cell>();
458 for (Cell cell: getCellList(family)) {
459 if (CellUtil.matchingQualifier(cell, qualifier)) {
460 filteredList.add(cell);
461 }
462 }
463 return filteredList;
464 }
465
466 @Override
467 public Put setAttribute(String name, byte[] value) {
468 return (Put) super.setAttribute(name, value);
469 }
470
471 @Override
472 public Put setId(String id) {
473 return (Put) super.setId(id);
474 }
475
476 @Override
477 @Deprecated
478 public Put setWriteToWAL(boolean write) {
479 return (Put) super.setWriteToWAL(write);
480 }
481
482 @Override
483 public Put setDurability(Durability d) {
484 return (Put) super.setDurability(d);
485 }
486
487 @Override
488 public Put setFamilyCellMap(NavigableMap<byte[], List<Cell>> map) {
489 return (Put) super.setFamilyCellMap(map);
490 }
491
492 @Override
493 @Deprecated
494 public Put setFamilyMap(NavigableMap<byte[], List<KeyValue>> map) {
495 return (Put) super.setFamilyMap(map);
496 }
497
498 @Override
499 public Put setClusterIds(List<UUID> clusterIds) {
500 return (Put) super.setClusterIds(clusterIds);
501 }
502
503 @Override
504 public Put setCellVisibility(CellVisibility expression) {
505 return (Put) super.setCellVisibility(expression);
506 }
507
508 @Override
509 public Put setACL(String user, Permission perms) {
510 return (Put) super.setACL(user, perms);
511 }
512
513 @Override
514 public Put setACL(Map<String, Permission> perms) {
515 return (Put) super.setACL(perms);
516 }
517
518 @Override
519 public Put setTTL(long ttl) {
520 return (Put) super.setTTL(ttl);
521 }
522 }