1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.hadoop.hbase.codec.prefixtree;
20
21 import java.io.IOException;
22 import java.io.InputStream;
23 import java.io.OutputStream;
24 import java.nio.ByteBuffer;
25
26 import org.apache.hadoop.classification.InterfaceAudience;
27 import org.apache.hadoop.hbase.codec.prefixtree.encode.other.LongEncoder;
28 import org.apache.hadoop.hbase.util.Bytes;
29 import org.apache.hadoop.hbase.util.vint.UVIntTool;
30 import org.apache.hadoop.hbase.util.vint.UVLongTool;
31
32
33
34
35
36
37
38 @InterfaceAudience.Private
39 public class PrefixTreeBlockMeta {
40
41
42
43 public static final int VERSION = 0;
44
45 public static final int MAX_FAMILY_LENGTH = Byte.MAX_VALUE;
46
47 public static final int
48 NUM_LONGS = 2,
49 NUM_INTS = 22,
50 NUM_SHORTS = 0,
51 NUM_SINGLE_BYTES = 2,
52 MAX_BYTES = Bytes.SIZEOF_LONG * NUM_LONGS
53 + Bytes.SIZEOF_SHORT * NUM_SHORTS
54 + Bytes.SIZEOF_INT * NUM_INTS
55 + NUM_SINGLE_BYTES;
56
57
58
59
60 protected int arrayOffset;
61 protected int bufferOffset;
62
63
64
65
66
67 protected int version;
68 protected int numMetaBytes;
69 protected int numKeyValueBytes;
70 protected boolean includesMvccVersion;
71
72
73 protected int numRowBytes;
74 protected int numFamilyBytes;
75 protected int numQualifierBytes;
76 protected int numTimestampBytes;
77 protected int numMvccVersionBytes;
78 protected int numValueBytes;
79
80
81 protected int nextNodeOffsetWidth;
82 protected int familyOffsetWidth;
83 protected int qualifierOffsetWidth;
84 protected int timestampIndexWidth;
85 protected int mvccVersionIndexWidth;
86 protected int valueOffsetWidth;
87 protected int valueLengthWidth;
88
89
90 protected int rowTreeDepth;
91 protected int maxRowLength;
92 protected int maxQualifierLength;
93
94
95 protected long minTimestamp;
96 protected int timestampDeltaWidth;
97 protected long minMvccVersion;
98 protected int mvccVersionDeltaWidth;
99
100 protected boolean allSameType;
101 protected byte allTypes;
102
103 protected int numUniqueRows;
104 protected int numUniqueFamilies;
105 protected int numUniqueQualifiers;
106
107
108
109
110 public PrefixTreeBlockMeta() {
111 }
112
113 public PrefixTreeBlockMeta(InputStream is) throws IOException{
114 this.version = VERSION;
115 this.arrayOffset = 0;
116 this.bufferOffset = 0;
117 readVariableBytesFromInputStream(is);
118 }
119
120
121
122
123 public PrefixTreeBlockMeta(ByteBuffer buffer) {
124 initOnBlock(buffer);
125 }
126
127 public void initOnBlock(ByteBuffer buffer) {
128 arrayOffset = buffer.arrayOffset();
129 bufferOffset = buffer.position();
130 readVariableBytesFromArray(buffer.array(), arrayOffset + bufferOffset);
131 }
132
133
134
135
136 public int calculateNumMetaBytes(){
137 int numBytes = 0;
138 numBytes += UVIntTool.numBytes(version);
139 numBytes += UVLongTool.numBytes(numMetaBytes);
140 numBytes += UVIntTool.numBytes(numKeyValueBytes);
141 ++numBytes;
142
143 numBytes += UVIntTool.numBytes(numRowBytes);
144 numBytes += UVIntTool.numBytes(numFamilyBytes);
145 numBytes += UVIntTool.numBytes(numQualifierBytes);
146 numBytes += UVIntTool.numBytes(numTimestampBytes);
147 numBytes += UVIntTool.numBytes(numMvccVersionBytes);
148 numBytes += UVIntTool.numBytes(numValueBytes);
149
150 numBytes += UVIntTool.numBytes(nextNodeOffsetWidth);
151 numBytes += UVIntTool.numBytes(familyOffsetWidth);
152 numBytes += UVIntTool.numBytes(qualifierOffsetWidth);
153 numBytes += UVIntTool.numBytes(timestampIndexWidth);
154 numBytes += UVIntTool.numBytes(mvccVersionIndexWidth);
155 numBytes += UVIntTool.numBytes(valueOffsetWidth);
156 numBytes += UVIntTool.numBytes(valueLengthWidth);
157
158 numBytes += UVIntTool.numBytes(rowTreeDepth);
159 numBytes += UVIntTool.numBytes(maxRowLength);
160 numBytes += UVIntTool.numBytes(maxQualifierLength);
161
162 numBytes += UVLongTool.numBytes(minTimestamp);
163 numBytes += UVIntTool.numBytes(timestampDeltaWidth);
164 numBytes += UVLongTool.numBytes(minMvccVersion);
165 numBytes += UVIntTool.numBytes(mvccVersionDeltaWidth);
166 ++numBytes;
167 ++numBytes;
168
169 numBytes += UVIntTool.numBytes(numUniqueRows);
170 numBytes += UVIntTool.numBytes(numUniqueFamilies);
171 numBytes += UVIntTool.numBytes(numUniqueQualifiers);
172 return numBytes;
173 }
174
175 public void writeVariableBytesToOutputStream(OutputStream os) throws IOException{
176 UVIntTool.writeBytes(version, os);
177 UVIntTool.writeBytes(numMetaBytes, os);
178 UVIntTool.writeBytes(numKeyValueBytes, os);
179 os.write(getIncludesMvccVersionByte());
180
181 UVIntTool.writeBytes(numRowBytes, os);
182 UVIntTool.writeBytes(numFamilyBytes, os);
183 UVIntTool.writeBytes(numQualifierBytes, os);
184 UVIntTool.writeBytes(numTimestampBytes, os);
185 UVIntTool.writeBytes(numMvccVersionBytes, os);
186 UVIntTool.writeBytes(numValueBytes, os);
187
188 UVIntTool.writeBytes(nextNodeOffsetWidth, os);
189 UVIntTool.writeBytes(familyOffsetWidth, os);
190 UVIntTool.writeBytes(qualifierOffsetWidth, os);
191 UVIntTool.writeBytes(timestampIndexWidth, os);
192 UVIntTool.writeBytes(mvccVersionIndexWidth, os);
193 UVIntTool.writeBytes(valueOffsetWidth, os);
194 UVIntTool.writeBytes(valueLengthWidth, os);
195
196 UVIntTool.writeBytes(rowTreeDepth, os);
197 UVIntTool.writeBytes(maxRowLength, os);
198 UVIntTool.writeBytes(maxQualifierLength, os);
199
200 UVLongTool.writeBytes(minTimestamp, os);
201 UVIntTool.writeBytes(timestampDeltaWidth, os);
202 UVLongTool.writeBytes(minMvccVersion, os);
203 UVIntTool.writeBytes(mvccVersionDeltaWidth, os);
204 os.write(getAllSameTypeByte());
205 os.write(allTypes);
206
207 UVIntTool.writeBytes(numUniqueRows, os);
208 UVIntTool.writeBytes(numUniqueFamilies, os);
209 UVIntTool.writeBytes(numUniqueQualifiers, os);
210 }
211
212 public void readVariableBytesFromInputStream(InputStream is) throws IOException{
213 version = UVIntTool.getInt(is);
214 numMetaBytes = UVIntTool.getInt(is);
215 numKeyValueBytes = UVIntTool.getInt(is);
216 setIncludesMvccVersion((byte) is.read());
217
218 numRowBytes = UVIntTool.getInt(is);
219 numFamilyBytes = UVIntTool.getInt(is);
220 numQualifierBytes = UVIntTool.getInt(is);
221 numTimestampBytes = UVIntTool.getInt(is);
222 numMvccVersionBytes = UVIntTool.getInt(is);
223 numValueBytes = UVIntTool.getInt(is);
224
225 nextNodeOffsetWidth = UVIntTool.getInt(is);
226 familyOffsetWidth = UVIntTool.getInt(is);
227 qualifierOffsetWidth = UVIntTool.getInt(is);
228 timestampIndexWidth = UVIntTool.getInt(is);
229 mvccVersionIndexWidth = UVIntTool.getInt(is);
230 valueOffsetWidth = UVIntTool.getInt(is);
231 valueLengthWidth = UVIntTool.getInt(is);
232
233 rowTreeDepth = UVIntTool.getInt(is);
234 maxRowLength = UVIntTool.getInt(is);
235 maxQualifierLength = UVIntTool.getInt(is);
236
237 minTimestamp = UVLongTool.getLong(is);
238 timestampDeltaWidth = UVIntTool.getInt(is);
239 minMvccVersion = UVLongTool.getLong(is);
240 mvccVersionDeltaWidth = UVIntTool.getInt(is);
241
242 setAllSameType((byte) is.read());
243 allTypes = (byte) is.read();
244
245 numUniqueRows = UVIntTool.getInt(is);
246 numUniqueFamilies = UVIntTool.getInt(is);
247 numUniqueQualifiers = UVIntTool.getInt(is);
248 }
249
250 public void readVariableBytesFromArray(byte[] bytes, int offset) {
251 int position = offset;
252
253 version = UVIntTool.getInt(bytes, position);
254 position += UVIntTool.numBytes(version);
255 numMetaBytes = UVIntTool.getInt(bytes, position);
256 position += UVIntTool.numBytes(numMetaBytes);
257 numKeyValueBytes = UVIntTool.getInt(bytes, position);
258 position += UVIntTool.numBytes(numKeyValueBytes);
259 setIncludesMvccVersion(bytes[position]);
260 ++position;
261
262 numRowBytes = UVIntTool.getInt(bytes, position);
263 position += UVIntTool.numBytes(numRowBytes);
264 numFamilyBytes = UVIntTool.getInt(bytes, position);
265 position += UVIntTool.numBytes(numFamilyBytes);
266 numQualifierBytes = UVIntTool.getInt(bytes, position);
267 position += UVIntTool.numBytes(numQualifierBytes);
268 numTimestampBytes = UVIntTool.getInt(bytes, position);
269 position += UVIntTool.numBytes(numTimestampBytes);
270 numMvccVersionBytes = UVIntTool.getInt(bytes, position);
271 position += UVIntTool.numBytes(numMvccVersionBytes);
272 numValueBytes = UVIntTool.getInt(bytes, position);
273 position += UVIntTool.numBytes(numValueBytes);
274
275 nextNodeOffsetWidth = UVIntTool.getInt(bytes, position);
276 position += UVIntTool.numBytes(nextNodeOffsetWidth);
277 familyOffsetWidth = UVIntTool.getInt(bytes, position);
278 position += UVIntTool.numBytes(familyOffsetWidth);
279 qualifierOffsetWidth = UVIntTool.getInt(bytes, position);
280 position += UVIntTool.numBytes(qualifierOffsetWidth);
281 timestampIndexWidth = UVIntTool.getInt(bytes, position);
282 position += UVIntTool.numBytes(timestampIndexWidth);
283 mvccVersionIndexWidth = UVIntTool.getInt(bytes, position);
284 position += UVIntTool.numBytes(mvccVersionIndexWidth);
285 valueOffsetWidth = UVIntTool.getInt(bytes, position);
286 position += UVIntTool.numBytes(valueOffsetWidth);
287 valueLengthWidth = UVIntTool.getInt(bytes, position);
288 position += UVIntTool.numBytes(valueLengthWidth);
289
290 rowTreeDepth = UVIntTool.getInt(bytes, position);
291 position += UVIntTool.numBytes(rowTreeDepth);
292 maxRowLength = UVIntTool.getInt(bytes, position);
293 position += UVIntTool.numBytes(maxRowLength);
294 maxQualifierLength = UVIntTool.getInt(bytes, position);
295 position += UVIntTool.numBytes(maxQualifierLength);
296
297 minTimestamp = UVLongTool.getLong(bytes, position);
298 position += UVLongTool.numBytes(minTimestamp);
299 timestampDeltaWidth = UVIntTool.getInt(bytes, position);
300 position += UVIntTool.numBytes(timestampDeltaWidth);
301 minMvccVersion = UVLongTool.getLong(bytes, position);
302 position += UVLongTool.numBytes(minMvccVersion);
303 mvccVersionDeltaWidth = UVIntTool.getInt(bytes, position);
304 position += UVIntTool.numBytes(mvccVersionDeltaWidth);
305
306 setAllSameType(bytes[position]);
307 ++position;
308 allTypes = bytes[position];
309 ++position;
310
311 numUniqueRows = UVIntTool.getInt(bytes, position);
312 position += UVIntTool.numBytes(numUniqueRows);
313 numUniqueFamilies = UVIntTool.getInt(bytes, position);
314 position += UVIntTool.numBytes(numUniqueFamilies);
315 numUniqueQualifiers = UVIntTool.getInt(bytes, position);
316 position += UVIntTool.numBytes(numUniqueQualifiers);
317 }
318
319
320
321
322
323
324 public int getKeyValueTypeWidth() {
325 return allSameType ? 0 : 1;
326 }
327
328 public byte getIncludesMvccVersionByte() {
329 return includesMvccVersion ? (byte) 1 : (byte) 0;
330 }
331
332 public void setIncludesMvccVersion(byte includesMvccVersionByte) {
333 includesMvccVersion = includesMvccVersionByte != 0;
334 }
335
336 public byte getAllSameTypeByte() {
337 return allSameType ? (byte) 1 : (byte) 0;
338 }
339
340 public void setAllSameType(byte allSameTypeByte) {
341 allSameType = allSameTypeByte != 0;
342 }
343
344 public boolean isAllSameTimestamp() {
345 return timestampIndexWidth == 0;
346 }
347
348 public boolean isAllSameMvccVersion() {
349 return mvccVersionIndexWidth == 0;
350 }
351
352 public void setTimestampFields(LongEncoder encoder){
353 this.minTimestamp = encoder.getMin();
354 this.timestampIndexWidth = encoder.getBytesPerIndex();
355 this.timestampDeltaWidth = encoder.getBytesPerDelta();
356 this.numTimestampBytes = encoder.getTotalCompressedBytes();
357 }
358
359 public void setMvccVersionFields(LongEncoder encoder){
360 this.minMvccVersion = encoder.getMin();
361 this.mvccVersionIndexWidth = encoder.getBytesPerIndex();
362 this.mvccVersionDeltaWidth = encoder.getBytesPerDelta();
363 this.numMvccVersionBytes = encoder.getTotalCompressedBytes();
364 }
365
366
367
368
369
370
371
372 @Override
373 public boolean equals(Object obj) {
374 if (this == obj)
375 return true;
376 if (obj == null)
377 return false;
378 if (getClass() != obj.getClass())
379 return false;
380 PrefixTreeBlockMeta other = (PrefixTreeBlockMeta) obj;
381 if (allSameType != other.allSameType)
382 return false;
383 if (allTypes != other.allTypes)
384 return false;
385 if (arrayOffset != other.arrayOffset)
386 return false;
387 if (bufferOffset != other.bufferOffset)
388 return false;
389 if (valueLengthWidth != other.valueLengthWidth)
390 return false;
391 if (valueOffsetWidth != other.valueOffsetWidth)
392 return false;
393 if (familyOffsetWidth != other.familyOffsetWidth)
394 return false;
395 if (includesMvccVersion != other.includesMvccVersion)
396 return false;
397 if (maxQualifierLength != other.maxQualifierLength)
398 return false;
399 if (maxRowLength != other.maxRowLength)
400 return false;
401 if (mvccVersionDeltaWidth != other.mvccVersionDeltaWidth)
402 return false;
403 if (mvccVersionIndexWidth != other.mvccVersionIndexWidth)
404 return false;
405 if (minMvccVersion != other.minMvccVersion)
406 return false;
407 if (minTimestamp != other.minTimestamp)
408 return false;
409 if (nextNodeOffsetWidth != other.nextNodeOffsetWidth)
410 return false;
411 if (numValueBytes != other.numValueBytes)
412 return false;
413 if (numFamilyBytes != other.numFamilyBytes)
414 return false;
415 if (numMvccVersionBytes != other.numMvccVersionBytes)
416 return false;
417 if (numMetaBytes != other.numMetaBytes)
418 return false;
419 if (numQualifierBytes != other.numQualifierBytes)
420 return false;
421 if (numRowBytes != other.numRowBytes)
422 return false;
423 if (numTimestampBytes != other.numTimestampBytes)
424 return false;
425 if (numUniqueFamilies != other.numUniqueFamilies)
426 return false;
427 if (numUniqueQualifiers != other.numUniqueQualifiers)
428 return false;
429 if (numUniqueRows != other.numUniqueRows)
430 return false;
431 if (numKeyValueBytes != other.numKeyValueBytes)
432 return false;
433 if (qualifierOffsetWidth != other.qualifierOffsetWidth)
434 return false;
435 if (rowTreeDepth != other.rowTreeDepth)
436 return false;
437 if (timestampDeltaWidth != other.timestampDeltaWidth)
438 return false;
439 if (timestampIndexWidth != other.timestampIndexWidth)
440 return false;
441 if (version != other.version)
442 return false;
443 return true;
444 }
445
446
447
448
449 @Override
450 public int hashCode() {
451 final int prime = 31;
452 int result = 1;
453 result = prime * result + (allSameType ? 1231 : 1237);
454 result = prime * result + allTypes;
455 result = prime * result + arrayOffset;
456 result = prime * result + bufferOffset;
457 result = prime * result + valueLengthWidth;
458 result = prime * result + valueOffsetWidth;
459 result = prime * result + familyOffsetWidth;
460 result = prime * result + (includesMvccVersion ? 1231 : 1237);
461 result = prime * result + maxQualifierLength;
462 result = prime * result + maxRowLength;
463 result = prime * result + mvccVersionDeltaWidth;
464 result = prime * result + mvccVersionIndexWidth;
465 result = prime * result + (int) (minMvccVersion ^ (minMvccVersion >>> 32));
466 result = prime * result + (int) (minTimestamp ^ (minTimestamp >>> 32));
467 result = prime * result + nextNodeOffsetWidth;
468 result = prime * result + numValueBytes;
469 result = prime * result + numFamilyBytes;
470 result = prime * result + numMvccVersionBytes;
471 result = prime * result + numMetaBytes;
472 result = prime * result + numQualifierBytes;
473 result = prime * result + numRowBytes;
474 result = prime * result + numTimestampBytes;
475 result = prime * result + numUniqueFamilies;
476 result = prime * result + numUniqueQualifiers;
477 result = prime * result + numUniqueRows;
478 result = prime * result + numKeyValueBytes;
479 result = prime * result + qualifierOffsetWidth;
480 result = prime * result + rowTreeDepth;
481 result = prime * result + timestampDeltaWidth;
482 result = prime * result + timestampIndexWidth;
483 result = prime * result + version;
484 return result;
485 }
486
487
488
489
490 @Override
491 public String toString() {
492 StringBuilder builder = new StringBuilder();
493 builder.append("PtBlockMeta [arrayOffset=");
494 builder.append(arrayOffset);
495 builder.append(", bufferOffset=");
496 builder.append(bufferOffset);
497 builder.append(", version=");
498 builder.append(version);
499 builder.append(", numMetaBytes=");
500 builder.append(numMetaBytes);
501 builder.append(", numKeyValueBytes=");
502 builder.append(numKeyValueBytes);
503 builder.append(", includesMvccVersion=");
504 builder.append(includesMvccVersion);
505 builder.append(", numRowBytes=");
506 builder.append(numRowBytes);
507 builder.append(", numFamilyBytes=");
508 builder.append(numFamilyBytes);
509 builder.append(", numQualifierBytes=");
510 builder.append(numQualifierBytes);
511 builder.append(", numTimestampBytes=");
512 builder.append(numTimestampBytes);
513 builder.append(", numMvccVersionBytes=");
514 builder.append(numMvccVersionBytes);
515 builder.append(", numValueBytes=");
516 builder.append(numValueBytes);
517 builder.append(", nextNodeOffsetWidth=");
518 builder.append(nextNodeOffsetWidth);
519 builder.append(", familyOffsetWidth=");
520 builder.append(familyOffsetWidth);
521 builder.append(", qualifierOffsetWidth=");
522 builder.append(qualifierOffsetWidth);
523 builder.append(", timestampIndexWidth=");
524 builder.append(timestampIndexWidth);
525 builder.append(", mvccVersionIndexWidth=");
526 builder.append(mvccVersionIndexWidth);
527 builder.append(", valueOffsetWidth=");
528 builder.append(valueOffsetWidth);
529 builder.append(", valueLengthWidth=");
530 builder.append(valueLengthWidth);
531 builder.append(", rowTreeDepth=");
532 builder.append(rowTreeDepth);
533 builder.append(", maxRowLength=");
534 builder.append(maxRowLength);
535 builder.append(", maxQualifierLength=");
536 builder.append(maxQualifierLength);
537 builder.append(", minTimestamp=");
538 builder.append(minTimestamp);
539 builder.append(", timestampDeltaWidth=");
540 builder.append(timestampDeltaWidth);
541 builder.append(", minMvccVersion=");
542 builder.append(minMvccVersion);
543 builder.append(", mvccVersionDeltaWidth=");
544 builder.append(mvccVersionDeltaWidth);
545 builder.append(", allSameType=");
546 builder.append(allSameType);
547 builder.append(", allTypes=");
548 builder.append(allTypes);
549 builder.append(", numUniqueRows=");
550 builder.append(numUniqueRows);
551 builder.append(", numUniqueFamilies=");
552 builder.append(numUniqueFamilies);
553 builder.append(", numUniqueQualifiers=");
554 builder.append(numUniqueQualifiers);
555 builder.append("]");
556 return builder.toString();
557 }
558
559
560
561
562 public int getAbsoluteMetaOffset() {
563 return arrayOffset + bufferOffset;
564 }
565
566 public int getAbsoluteRowOffset() {
567 return getAbsoluteMetaOffset() + numMetaBytes;
568 }
569
570 public int getAbsoluteFamilyOffset() {
571 return getAbsoluteRowOffset() + numRowBytes;
572 }
573
574 public int getAbsoluteQualifierOffset() {
575 return getAbsoluteFamilyOffset() + numFamilyBytes;
576 }
577
578 public int getAbsoluteTimestampOffset() {
579 return getAbsoluteQualifierOffset() + numQualifierBytes;
580 }
581
582 public int getAbsoluteMvccVersionOffset() {
583 return getAbsoluteTimestampOffset() + numTimestampBytes;
584 }
585
586 public int getAbsoluteValueOffset() {
587 return getAbsoluteMvccVersionOffset() + numMvccVersionBytes;
588 }
589
590
591
592
593 public int getTimestampDeltaWidth() {
594 return timestampDeltaWidth;
595 }
596
597 public void setTimestampDeltaWidth(int timestampDeltaWidth) {
598 this.timestampDeltaWidth = timestampDeltaWidth;
599 }
600
601 public int getValueOffsetWidth() {
602 return valueOffsetWidth;
603 }
604
605 public void setValueOffsetWidth(int dataOffsetWidth) {
606 this.valueOffsetWidth = dataOffsetWidth;
607 }
608
609 public int getValueLengthWidth() {
610 return valueLengthWidth;
611 }
612
613 public void setValueLengthWidth(int dataLengthWidth) {
614 this.valueLengthWidth = dataLengthWidth;
615 }
616
617 public int getMaxRowLength() {
618 return maxRowLength;
619 }
620
621 public void setMaxRowLength(int maxRowLength) {
622 this.maxRowLength = maxRowLength;
623 }
624
625 public long getMinTimestamp() {
626 return minTimestamp;
627 }
628
629 public void setMinTimestamp(long minTimestamp) {
630 this.minTimestamp = minTimestamp;
631 }
632
633 public byte getAllTypes() {
634 return allTypes;
635 }
636
637 public void setAllTypes(byte allTypes) {
638 this.allTypes = allTypes;
639 }
640
641 public boolean isAllSameType() {
642 return allSameType;
643 }
644
645 public void setAllSameType(boolean allSameType) {
646 this.allSameType = allSameType;
647 }
648
649 public int getNextNodeOffsetWidth() {
650 return nextNodeOffsetWidth;
651 }
652
653 public void setNextNodeOffsetWidth(int nextNodeOffsetWidth) {
654 this.nextNodeOffsetWidth = nextNodeOffsetWidth;
655 }
656
657 public int getNumRowBytes() {
658 return numRowBytes;
659 }
660
661 public void setNumRowBytes(int numRowBytes) {
662 this.numRowBytes = numRowBytes;
663 }
664
665 public int getNumTimestampBytes() {
666 return numTimestampBytes;
667 }
668
669 public void setNumTimestampBytes(int numTimestampBytes) {
670 this.numTimestampBytes = numTimestampBytes;
671 }
672
673 public int getNumValueBytes() {
674 return numValueBytes;
675 }
676
677 public void setNumValueBytes(int numValueBytes) {
678 this.numValueBytes = numValueBytes;
679 }
680
681 public int getNumMetaBytes() {
682 return numMetaBytes;
683 }
684
685 public void setNumMetaBytes(int numMetaBytes) {
686 this.numMetaBytes = numMetaBytes;
687 }
688
689 public int getArrayOffset() {
690 return arrayOffset;
691 }
692
693 public void setArrayOffset(int arrayOffset) {
694 this.arrayOffset = arrayOffset;
695 }
696
697 public int getBufferOffset() {
698 return bufferOffset;
699 }
700
701 public void setBufferOffset(int bufferOffset) {
702 this.bufferOffset = bufferOffset;
703 }
704
705 public int getNumKeyValueBytes() {
706 return numKeyValueBytes;
707 }
708
709 public void setNumKeyValueBytes(int numKeyValueBytes) {
710 this.numKeyValueBytes = numKeyValueBytes;
711 }
712
713 public int getRowTreeDepth() {
714 return rowTreeDepth;
715 }
716
717 public void setRowTreeDepth(int rowTreeDepth) {
718 this.rowTreeDepth = rowTreeDepth;
719 }
720
721 public int getNumMvccVersionBytes() {
722 return numMvccVersionBytes;
723 }
724
725 public void setNumMvccVersionBytes(int numMvccVersionBytes) {
726 this.numMvccVersionBytes = numMvccVersionBytes;
727 }
728
729 public int getMvccVersionDeltaWidth() {
730 return mvccVersionDeltaWidth;
731 }
732
733 public void setMvccVersionDeltaWidth(int mvccVersionDeltaWidth) {
734 this.mvccVersionDeltaWidth = mvccVersionDeltaWidth;
735 }
736
737 public long getMinMvccVersion() {
738 return minMvccVersion;
739 }
740
741 public void setMinMvccVersion(long minMvccVersion) {
742 this.minMvccVersion = minMvccVersion;
743 }
744
745 public int getNumFamilyBytes() {
746 return numFamilyBytes;
747 }
748
749 public void setNumFamilyBytes(int numFamilyBytes) {
750 this.numFamilyBytes = numFamilyBytes;
751 }
752
753 public int getFamilyOffsetWidth() {
754 return familyOffsetWidth;
755 }
756
757 public void setFamilyOffsetWidth(int familyOffsetWidth) {
758 this.familyOffsetWidth = familyOffsetWidth;
759 }
760
761 public int getNumUniqueRows() {
762 return numUniqueRows;
763 }
764
765 public void setNumUniqueRows(int numUniqueRows) {
766 this.numUniqueRows = numUniqueRows;
767 }
768
769 public int getNumUniqueFamilies() {
770 return numUniqueFamilies;
771 }
772
773 public void setNumUniqueFamilies(int numUniqueFamilies) {
774 this.numUniqueFamilies = numUniqueFamilies;
775 }
776
777 public int getNumUniqueQualifiers() {
778 return numUniqueQualifiers;
779 }
780
781 public void setNumUniqueQualifiers(int numUniqueQualifiers) {
782 this.numUniqueQualifiers = numUniqueQualifiers;
783 }
784
785 public int getNumQualifierBytes() {
786 return numQualifierBytes;
787 }
788
789 public void setNumQualifierBytes(int numQualifierBytes) {
790 this.numQualifierBytes = numQualifierBytes;
791 }
792
793 public int getQualifierOffsetWidth() {
794 return qualifierOffsetWidth;
795 }
796
797 public void setQualifierOffsetWidth(int qualifierOffsetWidth) {
798 this.qualifierOffsetWidth = qualifierOffsetWidth;
799 }
800
801 public int getMaxQualifierLength() {
802 return maxQualifierLength;
803 }
804
805 public void setMaxQualifierLength(int maxQualifierLength) {
806 this.maxQualifierLength = maxQualifierLength;
807 }
808
809 public int getTimestampIndexWidth() {
810 return timestampIndexWidth;
811 }
812
813 public void setTimestampIndexWidth(int timestampIndexWidth) {
814 this.timestampIndexWidth = timestampIndexWidth;
815 }
816
817 public int getMvccVersionIndexWidth() {
818 return mvccVersionIndexWidth;
819 }
820
821 public void setMvccVersionIndexWidth(int mvccVersionIndexWidth) {
822 this.mvccVersionIndexWidth = mvccVersionIndexWidth;
823 }
824
825 public int getVersion() {
826 return version;
827 }
828
829 public void setVersion(int version) {
830 this.version = version;
831 }
832
833 public boolean isIncludesMvccVersion() {
834 return includesMvccVersion;
835 }
836
837 public void setIncludesMvccVersion(boolean includesMvccVersion) {
838 this.includesMvccVersion = includesMvccVersion;
839 }
840
841 }