1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.client;
20
21 import java.nio.ByteBuffer;
22 import java.util.ArrayList;
23 import java.util.Arrays;
24 import java.util.HashMap;
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.CellScannable;
35 import org.apache.hadoop.hbase.CellScanner;
36 import org.apache.hadoop.hbase.CellUtil;
37 import org.apache.hadoop.hbase.HConstants;
38 import org.apache.hadoop.hbase.KeyValue;
39 import org.apache.hadoop.hbase.KeyValueUtil;
40 import org.apache.hadoop.hbase.Tag;
41 import org.apache.hadoop.hbase.exceptions.DeserializationException;
42 import org.apache.hadoop.hbase.io.HeapSize;
43 import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
44 import org.apache.hadoop.hbase.security.access.AccessControlConstants;
45 import org.apache.hadoop.hbase.security.access.Permission;
46 import org.apache.hadoop.hbase.security.visibility.CellVisibility;
47 import org.apache.hadoop.hbase.security.visibility.VisibilityConstants;
48 import org.apache.hadoop.hbase.util.Bytes;
49 import org.apache.hadoop.hbase.util.ClassSize;
50
51 import com.google.common.collect.ArrayListMultimap;
52 import com.google.common.collect.ListMultimap;
53 import com.google.common.collect.Lists;
54 import com.google.common.io.ByteArrayDataInput;
55 import com.google.common.io.ByteArrayDataOutput;
56 import com.google.common.io.ByteStreams;
57
58 @InterfaceAudience.Public
59 @InterfaceStability.Evolving
60 public abstract class Mutation extends OperationWithAttributes implements Row, CellScannable,
61 HeapSize {
62 public static final long MUTATION_OVERHEAD = ClassSize.align(
63
64 ClassSize.OBJECT +
65
66 2 * ClassSize.REFERENCE +
67
68 1 * Bytes.SIZEOF_LONG +
69
70 ClassSize.REFERENCE +
71
72 ClassSize.REFERENCE +
73
74 ClassSize.TREEMAP);
75
76
77
78
79 private static final String CONSUMED_CLUSTER_IDS = "_cs.id";
80
81
82
83
84 private static final String OP_ATTRIBUTE_TTL = "_ttl";
85
86 protected byte [] row = null;
87 protected long ts = HConstants.LATEST_TIMESTAMP;
88 protected Durability durability = Durability.USE_DEFAULT;
89
90
91 protected NavigableMap<byte [], List<Cell>> familyMap =
92 new TreeMap<byte [], List<Cell>>(Bytes.BYTES_COMPARATOR);
93
94 @Override
95 public CellScanner cellScanner() {
96 return CellUtil.createCellScanner(getFamilyCellMap());
97 }
98
99
100
101
102
103
104
105
106 List<Cell> getCellList(byte[] family) {
107 List<Cell> list = this.familyMap.get(family);
108 if (list == null) {
109 list = new ArrayList<Cell>();
110 }
111 return list;
112 }
113
114
115
116
117
118
119 KeyValue createPutKeyValue(byte[] family, byte[] qualifier, long ts, byte[] value) {
120 return new KeyValue(this.row, family, qualifier, ts, KeyValue.Type.Put, value);
121 }
122
123
124
125
126
127
128
129
130
131
132 KeyValue createPutKeyValue(byte[] family, byte[] qualifier, long ts, byte[] value, Tag[] tags) {
133 KeyValue kvWithTag = new KeyValue(this.row, family, qualifier, ts, value, tags);
134 return kvWithTag;
135 }
136
137
138
139
140
141
142 KeyValue createPutKeyValue(byte[] family, ByteBuffer qualifier, long ts, ByteBuffer value,
143 Tag[] tags) {
144 return new KeyValue(this.row, 0, this.row == null ? 0 : this.row.length,
145 family, 0, family == null ? 0 : family.length,
146 qualifier, ts, KeyValue.Type.Put, value, tags != null ? Arrays.asList(tags) : null);
147 }
148
149
150
151
152
153
154
155 @Override
156 public Map<String, Object> getFingerprint() {
157 Map<String, Object> map = new HashMap<String, Object>();
158 List<String> families = new ArrayList<String>();
159
160
161 map.put("families", families);
162 for (Map.Entry<byte [], List<Cell>> entry : this.familyMap.entrySet()) {
163 families.add(Bytes.toStringBinary(entry.getKey()));
164 }
165 return map;
166 }
167
168
169
170
171
172
173
174
175 @Override
176 public Map<String, Object> toMap(int maxCols) {
177
178 Map<String, Object> map = getFingerprint();
179
180
181 Map<String, List<Map<String, Object>>> columns =
182 new HashMap<String, List<Map<String, Object>>>();
183 map.put("families", columns);
184 map.put("row", Bytes.toStringBinary(this.row));
185 int colCount = 0;
186
187 for (Map.Entry<byte [], List<Cell>> entry : this.familyMap.entrySet()) {
188
189 List<Map<String, Object>> qualifierDetails = new ArrayList<Map<String, Object>>();
190 columns.put(Bytes.toStringBinary(entry.getKey()), qualifierDetails);
191 colCount += entry.getValue().size();
192 if (maxCols <= 0) {
193 continue;
194 }
195
196 for (Cell cell: entry.getValue()) {
197 if (--maxCols <= 0 ) {
198 continue;
199 }
200
201 KeyValue kv = KeyValueUtil.ensureKeyValue(cell);
202 Map<String, Object> kvMap = kv.toStringMap();
203
204 kvMap.remove("row");
205 kvMap.remove("family");
206 qualifierDetails.add(kvMap);
207 }
208 }
209 map.put("totalColumns", colCount);
210
211 if (getId() != null) {
212 map.put("id", getId());
213 }
214
215
216
217 if (getTTL() != Long.MAX_VALUE) {
218 map.put("ttl", getTTL());
219 }
220 return map;
221 }
222
223
224
225
226
227 @Deprecated
228 public boolean getWriteToWAL() {
229 return this.durability == Durability.SKIP_WAL;
230 }
231
232
233
234
235
236
237
238
239 @Deprecated
240 public void setWriteToWAL(boolean write) {
241 setDurability(write ? Durability.USE_DEFAULT : Durability.SKIP_WAL);
242 }
243
244
245
246
247
248 public void setDurability(Durability d) {
249 this.durability = d;
250 }
251
252
253 public Durability getDurability() {
254 return this.durability;
255 }
256
257
258
259
260
261 public NavigableMap<byte [], List<Cell>> getFamilyCellMap() {
262 return this.familyMap;
263 }
264
265
266
267
268 public void setFamilyCellMap(NavigableMap<byte [], List<Cell>> map) {
269
270
271 this.familyMap = map;
272 }
273
274
275
276
277
278
279 @Deprecated
280 public NavigableMap<byte [], List<KeyValue>> getFamilyMap() {
281 TreeMap<byte[], List<KeyValue>> fm =
282 new TreeMap<byte[], List<KeyValue>>(Bytes.BYTES_COMPARATOR);
283 for (Map.Entry<byte[], List<Cell>> e : familyMap.entrySet()) {
284 List<KeyValue> kvl = new ArrayList<KeyValue>(e.getValue().size());
285 for (Cell c : e.getValue()) {
286 kvl.add(KeyValueUtil.ensureKeyValue(c));
287 }
288 fm.put(e.getKey(), kvl);
289 }
290 return fm;
291 }
292
293
294
295
296
297 @Deprecated
298 public void setFamilyMap(NavigableMap<byte [], List<KeyValue>> map) {
299 TreeMap<byte[], List<Cell>> fm = new TreeMap<byte[], List<Cell>>(Bytes.BYTES_COMPARATOR);
300 for (Map.Entry<byte[], List<KeyValue>> e : map.entrySet()) {
301 fm.put(e.getKey(), Lists.<Cell>newArrayList(e.getValue()));
302 }
303 this.familyMap = fm;
304 }
305
306
307
308
309
310 public boolean isEmpty() {
311 return familyMap.isEmpty();
312 }
313
314
315
316
317
318 @Override
319 public byte [] getRow() {
320 return this.row;
321 }
322
323 @Override
324 public int compareTo(final Row d) {
325 return Bytes.compareTo(this.getRow(), d.getRow());
326 }
327
328
329
330
331
332 public long getTimeStamp() {
333 return this.ts;
334 }
335
336
337
338
339
340 public void setClusterIds(List<UUID> clusterIds) {
341 ByteArrayDataOutput out = ByteStreams.newDataOutput();
342 out.writeInt(clusterIds.size());
343 for (UUID clusterId : clusterIds) {
344 out.writeLong(clusterId.getMostSignificantBits());
345 out.writeLong(clusterId.getLeastSignificantBits());
346 }
347 setAttribute(CONSUMED_CLUSTER_IDS, out.toByteArray());
348 }
349
350
351
352
353 public List<UUID> getClusterIds() {
354 List<UUID> clusterIds = new ArrayList<UUID>();
355 byte[] bytes = getAttribute(CONSUMED_CLUSTER_IDS);
356 if(bytes != null) {
357 ByteArrayDataInput in = ByteStreams.newDataInput(bytes);
358 int numClusters = in.readInt();
359 for(int i=0; i<numClusters; i++){
360 clusterIds.add(new UUID(in.readLong(), in.readLong()));
361 }
362 }
363 return clusterIds;
364 }
365
366
367
368
369
370
371 public void setCellVisibility(CellVisibility expression) {
372 this.setAttribute(VisibilityConstants.VISIBILITY_LABELS_ATTR_KEY, ProtobufUtil
373 .toCellVisibility(expression).toByteArray());
374 }
375
376
377
378
379
380 public CellVisibility getCellVisibility() throws DeserializationException {
381 byte[] cellVisibilityBytes = this.getAttribute(VisibilityConstants.VISIBILITY_LABELS_ATTR_KEY);
382 if (cellVisibilityBytes == null) return null;
383 return ProtobufUtil.toCellVisibility(cellVisibilityBytes);
384 }
385
386
387
388
389
390 public int size() {
391 int size = 0;
392 for (List<Cell> cells : this.familyMap.values()) {
393 size += cells.size();
394 }
395 return size;
396 }
397
398
399
400
401 public int numFamilies() {
402 return familyMap.size();
403 }
404
405
406
407
408 @Override
409 public long heapSize() {
410 long heapsize = MUTATION_OVERHEAD;
411
412 heapsize += ClassSize.align(ClassSize.ARRAY + this.row.length);
413
414
415 heapsize +=
416 ClassSize.align(this.familyMap.size() * ClassSize.MAP_ENTRY);
417 for(Map.Entry<byte [], List<Cell>> entry : this.familyMap.entrySet()) {
418
419 heapsize +=
420 ClassSize.align(ClassSize.ARRAY + entry.getKey().length);
421
422
423
424
425 heapsize += ClassSize.align(ClassSize.ARRAYLIST);
426 int size = entry.getValue().size();
427 heapsize += ClassSize.align(ClassSize.ARRAY +
428 size * ClassSize.REFERENCE);
429
430 for(Cell cell : entry.getValue()) {
431 KeyValue kv = KeyValueUtil.ensureKeyValue(cell);
432 heapsize += kv.heapSize();
433 }
434 }
435 heapsize += getAttributeSize();
436 heapsize += extraHeapSize();
437 return ClassSize.align(heapsize);
438 }
439
440
441
442
443 public byte[] getACL() {
444 return getAttribute(AccessControlConstants.OP_ATTRIBUTE_ACL);
445 }
446
447
448
449
450
451 public void setACL(String user, Permission perms) {
452 setAttribute(AccessControlConstants.OP_ATTRIBUTE_ACL,
453 ProtobufUtil.toUsersAndPermissions(user, perms).toByteArray());
454 }
455
456
457
458
459 public void setACL(Map<String, Permission> perms) {
460 ListMultimap<String, Permission> permMap = ArrayListMultimap.create();
461 for (Map.Entry<String, Permission> entry : perms.entrySet()) {
462 permMap.put(entry.getKey(), entry.getValue());
463 }
464 setAttribute(AccessControlConstants.OP_ATTRIBUTE_ACL,
465 ProtobufUtil.toUsersAndPermissions(permMap).toByteArray());
466 }
467
468
469
470
471 @Deprecated
472 public boolean getACLStrategy() {
473 return false;
474 }
475
476
477
478
479 @Deprecated
480 public void setACLStrategy(boolean cellFirstStrategy) {
481 }
482
483
484
485
486
487
488 public long getTTL() {
489 byte[] ttlBytes = getAttribute(OP_ATTRIBUTE_TTL);
490 if (ttlBytes != null) {
491 return Bytes.toLong(ttlBytes);
492 }
493 return Long.MAX_VALUE;
494 }
495
496
497
498
499
500
501 public Mutation setTTL(long ttl) {
502 setAttribute(OP_ATTRIBUTE_TTL, Bytes.toBytes(ttl));
503 return this;
504 }
505
506
507
508
509
510 protected long extraHeapSize(){
511 return 0L;
512 }
513
514
515
516
517
518
519
520 static byte [] checkRow(final byte [] row) {
521 return checkRow(row, 0, row == null? 0: row.length);
522 }
523
524
525
526
527
528
529
530
531
532 static byte [] checkRow(final byte [] row, final int offset, final int length) {
533 if (row == null) {
534 throw new IllegalArgumentException("Row buffer is null");
535 }
536 if (length == 0) {
537 throw new IllegalArgumentException("Row length is 0");
538 }
539 if (length > HConstants.MAX_ROW_LENGTH) {
540 throw new IllegalArgumentException("Row length " + length + " is > " +
541 HConstants.MAX_ROW_LENGTH);
542 }
543 return row;
544 }
545
546 static void checkRow(ByteBuffer row) {
547 if (row == null) {
548 throw new IllegalArgumentException("Row buffer is null");
549 }
550 if (row.remaining() == 0) {
551 throw new IllegalArgumentException("Row length is 0");
552 }
553 if (row.remaining() > HConstants.MAX_ROW_LENGTH) {
554 throw new IllegalArgumentException("Row length " + row.remaining() + " is > " +
555 HConstants.MAX_ROW_LENGTH);
556 }
557 }
558 }