1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the 7 * "License"); you may not use this file except in compliance 8 * with the License. You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 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.hbase.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 * Information about the block. Stored at the beginning of the byte[]. Contains things 34 * like minimum timestamp and width of FInts in the row tree. 35 * 36 * Most fields stored in VInts that get decoded on the first access of each new block. 37 */ 38 @InterfaceAudience.Private 39 public class PrefixTreeBlockMeta { 40 41 /******************* static fields ********************/ 42 43 public static final int VERSION = 0; 44 45 public static final int MAX_FAMILY_LENGTH = Byte.MAX_VALUE;// hard-coded in KeyValue 46 47 public static final int 48 NUM_LONGS = 2, 49 NUM_INTS = 28, 50 NUM_SHORTS = 0,//keyValueTypeWidth not persisted 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 /**************** transient fields *********************/ 59 60 protected int arrayOffset; 61 protected int bufferOffset; 62 63 64 /**************** persisted fields **********************/ 65 66 // PrefixTree version to allow future format modifications 67 protected int version; 68 protected int numMetaBytes; 69 protected int numKeyValueBytes; 70 protected boolean includesMvccVersion;//probably don't need this explicitly, but only 1 byte 71 72 // split the byte[] into 6 sections for the different data types 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 protected int numTagsBytes; 80 81 // number of bytes in each section of fixed width FInts 82 protected int nextNodeOffsetWidth; 83 protected int familyOffsetWidth; 84 protected int qualifierOffsetWidth; 85 protected int timestampIndexWidth; 86 protected int mvccVersionIndexWidth; 87 protected int valueOffsetWidth; 88 protected int valueLengthWidth; 89 protected int tagsOffsetWidth; 90 91 // used to pre-allocate structures for reading 92 protected int rowTreeDepth; 93 protected int maxRowLength; 94 protected int maxQualifierLength; 95 protected int maxTagsLength; 96 97 // the timestamp from which the deltas are calculated 98 protected long minTimestamp; 99 protected int timestampDeltaWidth; 100 protected long minMvccVersion; 101 protected int mvccVersionDeltaWidth; 102 103 protected boolean allSameType; 104 protected byte allTypes; 105 106 protected int numUniqueRows; 107 protected int numUniqueFamilies; 108 protected int numUniqueQualifiers; 109 protected int numUniqueTags; 110 111 112 /***************** constructors ********************/ 113 PrefixTreeBlockMeta()114 public PrefixTreeBlockMeta() { 115 } 116 PrefixTreeBlockMeta(InputStream is)117 public PrefixTreeBlockMeta(InputStream is) throws IOException{ 118 this.version = VERSION; 119 this.arrayOffset = 0; 120 this.bufferOffset = 0; 121 readVariableBytesFromInputStream(is); 122 } 123 124 /** 125 * @param buffer positioned at start of PtBlockMeta 126 */ PrefixTreeBlockMeta(ByteBuffer buffer)127 public PrefixTreeBlockMeta(ByteBuffer buffer) { 128 initOnBlock(buffer); 129 } 130 initOnBlock(ByteBuffer buffer)131 public void initOnBlock(ByteBuffer buffer) { 132 arrayOffset = buffer.arrayOffset(); 133 bufferOffset = buffer.position(); 134 readVariableBytesFromArray(buffer.array(), arrayOffset + bufferOffset); 135 } 136 137 138 /**************** operate on each field **********************/ 139 calculateNumMetaBytes()140 public int calculateNumMetaBytes(){ 141 int numBytes = 0; 142 numBytes += UVIntTool.numBytes(version); 143 numBytes += UVLongTool.numBytes(numMetaBytes); 144 numBytes += UVIntTool.numBytes(numKeyValueBytes); 145 ++numBytes;//os.write(getIncludesMvccVersion()); 146 147 numBytes += UVIntTool.numBytes(numRowBytes); 148 numBytes += UVIntTool.numBytes(numFamilyBytes); 149 numBytes += UVIntTool.numBytes(numQualifierBytes); 150 numBytes += UVIntTool.numBytes(numTagsBytes); 151 numBytes += UVIntTool.numBytes(numTimestampBytes); 152 numBytes += UVIntTool.numBytes(numMvccVersionBytes); 153 numBytes += UVIntTool.numBytes(numValueBytes); 154 155 numBytes += UVIntTool.numBytes(nextNodeOffsetWidth); 156 numBytes += UVIntTool.numBytes(familyOffsetWidth); 157 numBytes += UVIntTool.numBytes(qualifierOffsetWidth); 158 numBytes += UVIntTool.numBytes(tagsOffsetWidth); 159 numBytes += UVIntTool.numBytes(timestampIndexWidth); 160 numBytes += UVIntTool.numBytes(mvccVersionIndexWidth); 161 numBytes += UVIntTool.numBytes(valueOffsetWidth); 162 numBytes += UVIntTool.numBytes(valueLengthWidth); 163 164 numBytes += UVIntTool.numBytes(rowTreeDepth); 165 numBytes += UVIntTool.numBytes(maxRowLength); 166 numBytes += UVIntTool.numBytes(maxQualifierLength); 167 numBytes += UVIntTool.numBytes(maxTagsLength); 168 169 numBytes += UVLongTool.numBytes(minTimestamp); 170 numBytes += UVIntTool.numBytes(timestampDeltaWidth); 171 numBytes += UVLongTool.numBytes(minMvccVersion); 172 numBytes += UVIntTool.numBytes(mvccVersionDeltaWidth); 173 ++numBytes;//os.write(getAllSameTypeByte()); 174 ++numBytes;//os.write(allTypes); 175 176 numBytes += UVIntTool.numBytes(numUniqueRows); 177 numBytes += UVIntTool.numBytes(numUniqueFamilies); 178 numBytes += UVIntTool.numBytes(numUniqueQualifiers); 179 numBytes += UVIntTool.numBytes(numUniqueTags); 180 return numBytes; 181 } 182 writeVariableBytesToOutputStream(OutputStream os)183 public void writeVariableBytesToOutputStream(OutputStream os) throws IOException{ 184 UVIntTool.writeBytes(version, os); 185 UVIntTool.writeBytes(numMetaBytes, os); 186 UVIntTool.writeBytes(numKeyValueBytes, os); 187 os.write(getIncludesMvccVersionByte()); 188 189 UVIntTool.writeBytes(numRowBytes, os); 190 UVIntTool.writeBytes(numFamilyBytes, os); 191 UVIntTool.writeBytes(numQualifierBytes, os); 192 UVIntTool.writeBytes(numTagsBytes, os); 193 UVIntTool.writeBytes(numTimestampBytes, os); 194 UVIntTool.writeBytes(numMvccVersionBytes, os); 195 UVIntTool.writeBytes(numValueBytes, os); 196 197 UVIntTool.writeBytes(nextNodeOffsetWidth, os); 198 UVIntTool.writeBytes(familyOffsetWidth, os); 199 UVIntTool.writeBytes(qualifierOffsetWidth, os); 200 UVIntTool.writeBytes(tagsOffsetWidth, os); 201 UVIntTool.writeBytes(timestampIndexWidth, os); 202 UVIntTool.writeBytes(mvccVersionIndexWidth, os); 203 UVIntTool.writeBytes(valueOffsetWidth, os); 204 UVIntTool.writeBytes(valueLengthWidth, os); 205 206 UVIntTool.writeBytes(rowTreeDepth, os); 207 UVIntTool.writeBytes(maxRowLength, os); 208 UVIntTool.writeBytes(maxQualifierLength, os); 209 UVIntTool.writeBytes(maxTagsLength, os); 210 211 UVLongTool.writeBytes(minTimestamp, os); 212 UVIntTool.writeBytes(timestampDeltaWidth, os); 213 UVLongTool.writeBytes(minMvccVersion, os); 214 UVIntTool.writeBytes(mvccVersionDeltaWidth, os); 215 os.write(getAllSameTypeByte()); 216 os.write(allTypes); 217 218 UVIntTool.writeBytes(numUniqueRows, os); 219 UVIntTool.writeBytes(numUniqueFamilies, os); 220 UVIntTool.writeBytes(numUniqueQualifiers, os); 221 UVIntTool.writeBytes(numUniqueTags, os); 222 } 223 readVariableBytesFromInputStream(InputStream is)224 public void readVariableBytesFromInputStream(InputStream is) throws IOException{ 225 version = UVIntTool.getInt(is); 226 numMetaBytes = UVIntTool.getInt(is); 227 numKeyValueBytes = UVIntTool.getInt(is); 228 setIncludesMvccVersion((byte) is.read()); 229 230 numRowBytes = UVIntTool.getInt(is); 231 numFamilyBytes = UVIntTool.getInt(is); 232 numQualifierBytes = UVIntTool.getInt(is); 233 numTagsBytes = UVIntTool.getInt(is); 234 numTimestampBytes = UVIntTool.getInt(is); 235 numMvccVersionBytes = UVIntTool.getInt(is); 236 numValueBytes = UVIntTool.getInt(is); 237 238 nextNodeOffsetWidth = UVIntTool.getInt(is); 239 familyOffsetWidth = UVIntTool.getInt(is); 240 qualifierOffsetWidth = UVIntTool.getInt(is); 241 tagsOffsetWidth = UVIntTool.getInt(is); 242 timestampIndexWidth = UVIntTool.getInt(is); 243 mvccVersionIndexWidth = UVIntTool.getInt(is); 244 valueOffsetWidth = UVIntTool.getInt(is); 245 valueLengthWidth = UVIntTool.getInt(is); 246 247 rowTreeDepth = UVIntTool.getInt(is); 248 maxRowLength = UVIntTool.getInt(is); 249 maxQualifierLength = UVIntTool.getInt(is); 250 maxTagsLength = UVIntTool.getInt(is); 251 252 minTimestamp = UVLongTool.getLong(is); 253 timestampDeltaWidth = UVIntTool.getInt(is); 254 minMvccVersion = UVLongTool.getLong(is); 255 mvccVersionDeltaWidth = UVIntTool.getInt(is); 256 257 setAllSameType((byte) is.read()); 258 allTypes = (byte) is.read(); 259 260 numUniqueRows = UVIntTool.getInt(is); 261 numUniqueFamilies = UVIntTool.getInt(is); 262 numUniqueQualifiers = UVIntTool.getInt(is); 263 numUniqueTags = UVIntTool.getInt(is); 264 } 265 readVariableBytesFromArray(byte[] bytes, int offset)266 public void readVariableBytesFromArray(byte[] bytes, int offset) { 267 int position = offset; 268 269 version = UVIntTool.getInt(bytes, position); 270 position += UVIntTool.numBytes(version); 271 numMetaBytes = UVIntTool.getInt(bytes, position); 272 position += UVIntTool.numBytes(numMetaBytes); 273 numKeyValueBytes = UVIntTool.getInt(bytes, position); 274 position += UVIntTool.numBytes(numKeyValueBytes); 275 setIncludesMvccVersion(bytes[position]); 276 ++position; 277 278 numRowBytes = UVIntTool.getInt(bytes, position); 279 position += UVIntTool.numBytes(numRowBytes); 280 numFamilyBytes = UVIntTool.getInt(bytes, position); 281 position += UVIntTool.numBytes(numFamilyBytes); 282 numQualifierBytes = UVIntTool.getInt(bytes, position); 283 position += UVIntTool.numBytes(numQualifierBytes); 284 numTagsBytes = UVIntTool.getInt(bytes, position); 285 position += UVIntTool.numBytes(numTagsBytes); 286 numTimestampBytes = UVIntTool.getInt(bytes, position); 287 position += UVIntTool.numBytes(numTimestampBytes); 288 numMvccVersionBytes = UVIntTool.getInt(bytes, position); 289 position += UVIntTool.numBytes(numMvccVersionBytes); 290 numValueBytes = UVIntTool.getInt(bytes, position); 291 position += UVIntTool.numBytes(numValueBytes); 292 293 nextNodeOffsetWidth = UVIntTool.getInt(bytes, position); 294 position += UVIntTool.numBytes(nextNodeOffsetWidth); 295 familyOffsetWidth = UVIntTool.getInt(bytes, position); 296 position += UVIntTool.numBytes(familyOffsetWidth); 297 qualifierOffsetWidth = UVIntTool.getInt(bytes, position); 298 position += UVIntTool.numBytes(qualifierOffsetWidth); 299 tagsOffsetWidth = UVIntTool.getInt(bytes, position); 300 position += UVIntTool.numBytes(tagsOffsetWidth); 301 timestampIndexWidth = UVIntTool.getInt(bytes, position); 302 position += UVIntTool.numBytes(timestampIndexWidth); 303 mvccVersionIndexWidth = UVIntTool.getInt(bytes, position); 304 position += UVIntTool.numBytes(mvccVersionIndexWidth); 305 valueOffsetWidth = UVIntTool.getInt(bytes, position); 306 position += UVIntTool.numBytes(valueOffsetWidth); 307 valueLengthWidth = UVIntTool.getInt(bytes, position); 308 position += UVIntTool.numBytes(valueLengthWidth); 309 310 rowTreeDepth = UVIntTool.getInt(bytes, position); 311 position += UVIntTool.numBytes(rowTreeDepth); 312 maxRowLength = UVIntTool.getInt(bytes, position); 313 position += UVIntTool.numBytes(maxRowLength); 314 maxQualifierLength = UVIntTool.getInt(bytes, position); 315 position += UVIntTool.numBytes(maxQualifierLength); 316 maxTagsLength = UVIntTool.getInt(bytes, position); 317 position += UVIntTool.numBytes(maxTagsLength); 318 minTimestamp = UVLongTool.getLong(bytes, position); 319 position += UVLongTool.numBytes(minTimestamp); 320 timestampDeltaWidth = UVIntTool.getInt(bytes, position); 321 position += UVIntTool.numBytes(timestampDeltaWidth); 322 minMvccVersion = UVLongTool.getLong(bytes, position); 323 position += UVLongTool.numBytes(minMvccVersion); 324 mvccVersionDeltaWidth = UVIntTool.getInt(bytes, position); 325 position += UVIntTool.numBytes(mvccVersionDeltaWidth); 326 327 setAllSameType(bytes[position]); 328 ++position; 329 allTypes = bytes[position]; 330 ++position; 331 332 numUniqueRows = UVIntTool.getInt(bytes, position); 333 position += UVIntTool.numBytes(numUniqueRows); 334 numUniqueFamilies = UVIntTool.getInt(bytes, position); 335 position += UVIntTool.numBytes(numUniqueFamilies); 336 numUniqueQualifiers = UVIntTool.getInt(bytes, position); 337 position += UVIntTool.numBytes(numUniqueQualifiers); 338 numUniqueTags = UVIntTool.getInt(bytes, position); 339 position += UVIntTool.numBytes(numUniqueTags); 340 } 341 342 //TODO method that can read directly from ByteBuffer instead of InputStream 343 344 345 /*************** methods *************************/ 346 getKeyValueTypeWidth()347 public int getKeyValueTypeWidth() { 348 return allSameType ? 0 : 1; 349 } 350 getIncludesMvccVersionByte()351 public byte getIncludesMvccVersionByte() { 352 return includesMvccVersion ? (byte) 1 : (byte) 0; 353 } 354 setIncludesMvccVersion(byte includesMvccVersionByte)355 public void setIncludesMvccVersion(byte includesMvccVersionByte) { 356 includesMvccVersion = includesMvccVersionByte != 0; 357 } 358 getAllSameTypeByte()359 public byte getAllSameTypeByte() { 360 return allSameType ? (byte) 1 : (byte) 0; 361 } 362 setAllSameType(byte allSameTypeByte)363 public void setAllSameType(byte allSameTypeByte) { 364 allSameType = allSameTypeByte != 0; 365 } 366 isAllSameTimestamp()367 public boolean isAllSameTimestamp() { 368 return timestampIndexWidth == 0; 369 } 370 isAllSameMvccVersion()371 public boolean isAllSameMvccVersion() { 372 return mvccVersionIndexWidth == 0; 373 } 374 setTimestampFields(LongEncoder encoder)375 public void setTimestampFields(LongEncoder encoder){ 376 this.minTimestamp = encoder.getMin(); 377 this.timestampIndexWidth = encoder.getBytesPerIndex(); 378 this.timestampDeltaWidth = encoder.getBytesPerDelta(); 379 this.numTimestampBytes = encoder.getTotalCompressedBytes(); 380 } 381 setMvccVersionFields(LongEncoder encoder)382 public void setMvccVersionFields(LongEncoder encoder){ 383 this.minMvccVersion = encoder.getMin(); 384 this.mvccVersionIndexWidth = encoder.getBytesPerIndex(); 385 this.mvccVersionDeltaWidth = encoder.getBytesPerDelta(); 386 this.numMvccVersionBytes = encoder.getTotalCompressedBytes(); 387 } 388 389 390 /*************** Object methods *************************/ 391 392 /** 393 * Generated by Eclipse 394 */ 395 @Override equals(Object obj)396 public boolean equals(Object obj) { 397 if (this == obj) 398 return true; 399 if (obj == null) 400 return false; 401 if (getClass() != obj.getClass()) 402 return false; 403 PrefixTreeBlockMeta other = (PrefixTreeBlockMeta) obj; 404 if (allSameType != other.allSameType) 405 return false; 406 if (allTypes != other.allTypes) 407 return false; 408 if (arrayOffset != other.arrayOffset) 409 return false; 410 if (bufferOffset != other.bufferOffset) 411 return false; 412 if (valueLengthWidth != other.valueLengthWidth) 413 return false; 414 if (valueOffsetWidth != other.valueOffsetWidth) 415 return false; 416 if (familyOffsetWidth != other.familyOffsetWidth) 417 return false; 418 if (includesMvccVersion != other.includesMvccVersion) 419 return false; 420 if (maxQualifierLength != other.maxQualifierLength) 421 return false; 422 if (maxTagsLength != other.maxTagsLength) 423 return false; 424 if (maxRowLength != other.maxRowLength) 425 return false; 426 if (mvccVersionDeltaWidth != other.mvccVersionDeltaWidth) 427 return false; 428 if (mvccVersionIndexWidth != other.mvccVersionIndexWidth) 429 return false; 430 if (minMvccVersion != other.minMvccVersion) 431 return false; 432 if (minTimestamp != other.minTimestamp) 433 return false; 434 if (nextNodeOffsetWidth != other.nextNodeOffsetWidth) 435 return false; 436 if (numValueBytes != other.numValueBytes) 437 return false; 438 if (numFamilyBytes != other.numFamilyBytes) 439 return false; 440 if (numMvccVersionBytes != other.numMvccVersionBytes) 441 return false; 442 if (numMetaBytes != other.numMetaBytes) 443 return false; 444 if (numQualifierBytes != other.numQualifierBytes) 445 return false; 446 if (numTagsBytes != other.numTagsBytes) 447 return false; 448 if (numRowBytes != other.numRowBytes) 449 return false; 450 if (numTimestampBytes != other.numTimestampBytes) 451 return false; 452 if (numUniqueFamilies != other.numUniqueFamilies) 453 return false; 454 if (numUniqueQualifiers != other.numUniqueQualifiers) 455 return false; 456 if (numUniqueTags != other.numUniqueTags) 457 return false; 458 if (numUniqueRows != other.numUniqueRows) 459 return false; 460 if (numKeyValueBytes != other.numKeyValueBytes) 461 return false; 462 if (qualifierOffsetWidth != other.qualifierOffsetWidth) 463 return false; 464 if(tagsOffsetWidth != other.tagsOffsetWidth) 465 return false; 466 if (rowTreeDepth != other.rowTreeDepth) 467 return false; 468 if (timestampDeltaWidth != other.timestampDeltaWidth) 469 return false; 470 if (timestampIndexWidth != other.timestampIndexWidth) 471 return false; 472 if (version != other.version) 473 return false; 474 return true; 475 } 476 477 /** 478 * Generated by Eclipse 479 */ 480 @Override hashCode()481 public int hashCode() { 482 final int prime = 31; 483 int result = 1; 484 result = prime * result + (allSameType ? 1231 : 1237); 485 result = prime * result + allTypes; 486 result = prime * result + arrayOffset; 487 result = prime * result + bufferOffset; 488 result = prime * result + valueLengthWidth; 489 result = prime * result + valueOffsetWidth; 490 result = prime * result + familyOffsetWidth; 491 result = prime * result + (includesMvccVersion ? 1231 : 1237); 492 result = prime * result + maxQualifierLength; 493 result = prime * result + maxTagsLength; 494 result = prime * result + maxRowLength; 495 result = prime * result + mvccVersionDeltaWidth; 496 result = prime * result + mvccVersionIndexWidth; 497 result = prime * result + (int) (minMvccVersion ^ (minMvccVersion >>> 32)); 498 result = prime * result + (int) (minTimestamp ^ (minTimestamp >>> 32)); 499 result = prime * result + nextNodeOffsetWidth; 500 result = prime * result + numValueBytes; 501 result = prime * result + numFamilyBytes; 502 result = prime * result + numMvccVersionBytes; 503 result = prime * result + numMetaBytes; 504 result = prime * result + numQualifierBytes; 505 result = prime * result + numTagsBytes; 506 result = prime * result + numRowBytes; 507 result = prime * result + numTimestampBytes; 508 result = prime * result + numUniqueFamilies; 509 result = prime * result + numUniqueQualifiers; 510 result = prime * result + numUniqueTags; 511 result = prime * result + numUniqueRows; 512 result = prime * result + numKeyValueBytes; 513 result = prime * result + qualifierOffsetWidth; 514 result = prime * result + tagsOffsetWidth; 515 result = prime * result + rowTreeDepth; 516 result = prime * result + timestampDeltaWidth; 517 result = prime * result + timestampIndexWidth; 518 result = prime * result + version; 519 return result; 520 } 521 522 /** 523 * Generated by Eclipse 524 */ 525 @Override toString()526 public String toString() { 527 StringBuilder builder = new StringBuilder(); 528 builder.append("PtBlockMeta [arrayOffset="); 529 builder.append(arrayOffset); 530 builder.append(", bufferOffset="); 531 builder.append(bufferOffset); 532 builder.append(", version="); 533 builder.append(version); 534 builder.append(", numMetaBytes="); 535 builder.append(numMetaBytes); 536 builder.append(", numKeyValueBytes="); 537 builder.append(numKeyValueBytes); 538 builder.append(", includesMvccVersion="); 539 builder.append(includesMvccVersion); 540 builder.append(", numRowBytes="); 541 builder.append(numRowBytes); 542 builder.append(", numFamilyBytes="); 543 builder.append(numFamilyBytes); 544 builder.append(", numQualifierBytes="); 545 builder.append(numQualifierBytes); 546 builder.append(", numTimestampBytes="); 547 builder.append(numTimestampBytes); 548 builder.append(", numMvccVersionBytes="); 549 builder.append(numMvccVersionBytes); 550 builder.append(", numValueBytes="); 551 builder.append(numValueBytes); 552 builder.append(", numTagBytes="); 553 builder.append(numTagsBytes); 554 builder.append(", nextNodeOffsetWidth="); 555 builder.append(nextNodeOffsetWidth); 556 builder.append(", familyOffsetWidth="); 557 builder.append(familyOffsetWidth); 558 builder.append(", qualifierOffsetWidth="); 559 builder.append(qualifierOffsetWidth); 560 builder.append(", tagOffsetWidth="); 561 builder.append(tagsOffsetWidth); 562 builder.append(", timestampIndexWidth="); 563 builder.append(timestampIndexWidth); 564 builder.append(", mvccVersionIndexWidth="); 565 builder.append(mvccVersionIndexWidth); 566 builder.append(", valueOffsetWidth="); 567 builder.append(valueOffsetWidth); 568 builder.append(", valueLengthWidth="); 569 builder.append(valueLengthWidth); 570 builder.append(", rowTreeDepth="); 571 builder.append(rowTreeDepth); 572 builder.append(", maxRowLength="); 573 builder.append(maxRowLength); 574 builder.append(", maxQualifierLength="); 575 builder.append(maxQualifierLength); 576 builder.append(", maxTagLength="); 577 builder.append(maxTagsLength); 578 builder.append(", minTimestamp="); 579 builder.append(minTimestamp); 580 builder.append(", timestampDeltaWidth="); 581 builder.append(timestampDeltaWidth); 582 builder.append(", minMvccVersion="); 583 builder.append(minMvccVersion); 584 builder.append(", mvccVersionDeltaWidth="); 585 builder.append(mvccVersionDeltaWidth); 586 builder.append(", allSameType="); 587 builder.append(allSameType); 588 builder.append(", allTypes="); 589 builder.append(allTypes); 590 builder.append(", numUniqueRows="); 591 builder.append(numUniqueRows); 592 builder.append(", numUniqueFamilies="); 593 builder.append(numUniqueFamilies); 594 builder.append(", numUniqueQualifiers="); 595 builder.append(numUniqueQualifiers); 596 builder.append(", numUniqueTags="); 597 builder.append(numUniqueTags); 598 builder.append("]"); 599 return builder.toString(); 600 } 601 602 603 /************** absolute getters *******************/ 604 getAbsoluteMetaOffset()605 public int getAbsoluteMetaOffset() { 606 return arrayOffset + bufferOffset; 607 } 608 getAbsoluteRowOffset()609 public int getAbsoluteRowOffset() { 610 return getAbsoluteMetaOffset() + numMetaBytes; 611 } 612 getAbsoluteFamilyOffset()613 public int getAbsoluteFamilyOffset() { 614 return getAbsoluteRowOffset() + numRowBytes; 615 } 616 getAbsoluteQualifierOffset()617 public int getAbsoluteQualifierOffset() { 618 return getAbsoluteFamilyOffset() + numFamilyBytes; 619 } 620 getAbsoluteTagsOffset()621 public int getAbsoluteTagsOffset() { 622 return getAbsoluteQualifierOffset() + numQualifierBytes; 623 } 624 getAbsoluteTimestampOffset()625 public int getAbsoluteTimestampOffset() { 626 return getAbsoluteTagsOffset() + numTagsBytes; 627 } 628 getAbsoluteMvccVersionOffset()629 public int getAbsoluteMvccVersionOffset() { 630 return getAbsoluteTimestampOffset() + numTimestampBytes; 631 } 632 getAbsoluteValueOffset()633 public int getAbsoluteValueOffset() { 634 return getAbsoluteMvccVersionOffset() + numMvccVersionBytes; 635 } 636 637 638 /*************** get/set ***************************/ 639 getTimestampDeltaWidth()640 public int getTimestampDeltaWidth() { 641 return timestampDeltaWidth; 642 } 643 setTimestampDeltaWidth(int timestampDeltaWidth)644 public void setTimestampDeltaWidth(int timestampDeltaWidth) { 645 this.timestampDeltaWidth = timestampDeltaWidth; 646 } 647 getValueOffsetWidth()648 public int getValueOffsetWidth() { 649 return valueOffsetWidth; 650 } 651 getTagsOffsetWidth()652 public int getTagsOffsetWidth() { 653 return tagsOffsetWidth; 654 } 655 setValueOffsetWidth(int dataOffsetWidth)656 public void setValueOffsetWidth(int dataOffsetWidth) { 657 this.valueOffsetWidth = dataOffsetWidth; 658 } 659 setTagsOffsetWidth(int dataOffsetWidth)660 public void setTagsOffsetWidth(int dataOffsetWidth) { 661 this.tagsOffsetWidth = dataOffsetWidth; 662 } 663 getValueLengthWidth()664 public int getValueLengthWidth() { 665 return valueLengthWidth; 666 } 667 setValueLengthWidth(int dataLengthWidth)668 public void setValueLengthWidth(int dataLengthWidth) { 669 this.valueLengthWidth = dataLengthWidth; 670 } 671 getMaxRowLength()672 public int getMaxRowLength() { 673 return maxRowLength; 674 } 675 setMaxRowLength(int maxRowLength)676 public void setMaxRowLength(int maxRowLength) { 677 this.maxRowLength = maxRowLength; 678 } 679 getMinTimestamp()680 public long getMinTimestamp() { 681 return minTimestamp; 682 } 683 setMinTimestamp(long minTimestamp)684 public void setMinTimestamp(long minTimestamp) { 685 this.minTimestamp = minTimestamp; 686 } 687 getAllTypes()688 public byte getAllTypes() { 689 return allTypes; 690 } 691 setAllTypes(byte allTypes)692 public void setAllTypes(byte allTypes) { 693 this.allTypes = allTypes; 694 } 695 isAllSameType()696 public boolean isAllSameType() { 697 return allSameType; 698 } 699 setAllSameType(boolean allSameType)700 public void setAllSameType(boolean allSameType) { 701 this.allSameType = allSameType; 702 } 703 getNextNodeOffsetWidth()704 public int getNextNodeOffsetWidth() { 705 return nextNodeOffsetWidth; 706 } 707 setNextNodeOffsetWidth(int nextNodeOffsetWidth)708 public void setNextNodeOffsetWidth(int nextNodeOffsetWidth) { 709 this.nextNodeOffsetWidth = nextNodeOffsetWidth; 710 } 711 getNumRowBytes()712 public int getNumRowBytes() { 713 return numRowBytes; 714 } 715 setNumRowBytes(int numRowBytes)716 public void setNumRowBytes(int numRowBytes) { 717 this.numRowBytes = numRowBytes; 718 } 719 getNumTimestampBytes()720 public int getNumTimestampBytes() { 721 return numTimestampBytes; 722 } 723 setNumTimestampBytes(int numTimestampBytes)724 public void setNumTimestampBytes(int numTimestampBytes) { 725 this.numTimestampBytes = numTimestampBytes; 726 } 727 getNumValueBytes()728 public int getNumValueBytes() { 729 return numValueBytes; 730 } 731 getNumTagsBytes()732 public int getNumTagsBytes() { 733 return numTagsBytes; 734 } 735 setNumTagsBytes(int numTagBytes)736 public void setNumTagsBytes(int numTagBytes){ 737 this.numTagsBytes = numTagBytes; 738 } 739 setNumValueBytes(int numValueBytes)740 public void setNumValueBytes(int numValueBytes) { 741 this.numValueBytes = numValueBytes; 742 } 743 getNumMetaBytes()744 public int getNumMetaBytes() { 745 return numMetaBytes; 746 } 747 setNumMetaBytes(int numMetaBytes)748 public void setNumMetaBytes(int numMetaBytes) { 749 this.numMetaBytes = numMetaBytes; 750 } 751 getArrayOffset()752 public int getArrayOffset() { 753 return arrayOffset; 754 } 755 setArrayOffset(int arrayOffset)756 public void setArrayOffset(int arrayOffset) { 757 this.arrayOffset = arrayOffset; 758 } 759 getBufferOffset()760 public int getBufferOffset() { 761 return bufferOffset; 762 } 763 setBufferOffset(int bufferOffset)764 public void setBufferOffset(int bufferOffset) { 765 this.bufferOffset = bufferOffset; 766 } 767 getNumKeyValueBytes()768 public int getNumKeyValueBytes() { 769 return numKeyValueBytes; 770 } 771 setNumKeyValueBytes(int numKeyValueBytes)772 public void setNumKeyValueBytes(int numKeyValueBytes) { 773 this.numKeyValueBytes = numKeyValueBytes; 774 } 775 getRowTreeDepth()776 public int getRowTreeDepth() { 777 return rowTreeDepth; 778 } 779 setRowTreeDepth(int rowTreeDepth)780 public void setRowTreeDepth(int rowTreeDepth) { 781 this.rowTreeDepth = rowTreeDepth; 782 } 783 getNumMvccVersionBytes()784 public int getNumMvccVersionBytes() { 785 return numMvccVersionBytes; 786 } 787 setNumMvccVersionBytes(int numMvccVersionBytes)788 public void setNumMvccVersionBytes(int numMvccVersionBytes) { 789 this.numMvccVersionBytes = numMvccVersionBytes; 790 } 791 getMvccVersionDeltaWidth()792 public int getMvccVersionDeltaWidth() { 793 return mvccVersionDeltaWidth; 794 } 795 setMvccVersionDeltaWidth(int mvccVersionDeltaWidth)796 public void setMvccVersionDeltaWidth(int mvccVersionDeltaWidth) { 797 this.mvccVersionDeltaWidth = mvccVersionDeltaWidth; 798 } 799 getMinMvccVersion()800 public long getMinMvccVersion() { 801 return minMvccVersion; 802 } 803 setMinMvccVersion(long minMvccVersion)804 public void setMinMvccVersion(long minMvccVersion) { 805 this.minMvccVersion = minMvccVersion; 806 } 807 getNumFamilyBytes()808 public int getNumFamilyBytes() { 809 return numFamilyBytes; 810 } 811 setNumFamilyBytes(int numFamilyBytes)812 public void setNumFamilyBytes(int numFamilyBytes) { 813 this.numFamilyBytes = numFamilyBytes; 814 } 815 getFamilyOffsetWidth()816 public int getFamilyOffsetWidth() { 817 return familyOffsetWidth; 818 } 819 setFamilyOffsetWidth(int familyOffsetWidth)820 public void setFamilyOffsetWidth(int familyOffsetWidth) { 821 this.familyOffsetWidth = familyOffsetWidth; 822 } 823 getNumUniqueRows()824 public int getNumUniqueRows() { 825 return numUniqueRows; 826 } 827 setNumUniqueRows(int numUniqueRows)828 public void setNumUniqueRows(int numUniqueRows) { 829 this.numUniqueRows = numUniqueRows; 830 } 831 getNumUniqueFamilies()832 public int getNumUniqueFamilies() { 833 return numUniqueFamilies; 834 } 835 setNumUniqueFamilies(int numUniqueFamilies)836 public void setNumUniqueFamilies(int numUniqueFamilies) { 837 this.numUniqueFamilies = numUniqueFamilies; 838 } 839 getNumUniqueQualifiers()840 public int getNumUniqueQualifiers() { 841 return numUniqueQualifiers; 842 } 843 setNumUniqueQualifiers(int numUniqueQualifiers)844 public void setNumUniqueQualifiers(int numUniqueQualifiers) { 845 this.numUniqueQualifiers = numUniqueQualifiers; 846 } 847 setNumUniqueTags(int numUniqueTags)848 public void setNumUniqueTags(int numUniqueTags) { 849 this.numUniqueTags = numUniqueTags; 850 } 851 getNumUniqueTags()852 public int getNumUniqueTags() { 853 return numUniqueTags; 854 } getNumQualifierBytes()855 public int getNumQualifierBytes() { 856 return numQualifierBytes; 857 } 858 setNumQualifierBytes(int numQualifierBytes)859 public void setNumQualifierBytes(int numQualifierBytes) { 860 this.numQualifierBytes = numQualifierBytes; 861 } 862 getQualifierOffsetWidth()863 public int getQualifierOffsetWidth() { 864 return qualifierOffsetWidth; 865 } 866 setQualifierOffsetWidth(int qualifierOffsetWidth)867 public void setQualifierOffsetWidth(int qualifierOffsetWidth) { 868 this.qualifierOffsetWidth = qualifierOffsetWidth; 869 } 870 getMaxQualifierLength()871 public int getMaxQualifierLength() { 872 return maxQualifierLength; 873 } 874 875 // TODO : decide on some max value for this ? INTEGER_MAX? setMaxQualifierLength(int maxQualifierLength)876 public void setMaxQualifierLength(int maxQualifierLength) { 877 this.maxQualifierLength = maxQualifierLength; 878 } 879 getMaxTagsLength()880 public int getMaxTagsLength() { 881 return this.maxTagsLength; 882 } 883 setMaxTagsLength(int maxTagLength)884 public void setMaxTagsLength(int maxTagLength) { 885 this.maxTagsLength = maxTagLength; 886 } 887 getTimestampIndexWidth()888 public int getTimestampIndexWidth() { 889 return timestampIndexWidth; 890 } 891 setTimestampIndexWidth(int timestampIndexWidth)892 public void setTimestampIndexWidth(int timestampIndexWidth) { 893 this.timestampIndexWidth = timestampIndexWidth; 894 } 895 getMvccVersionIndexWidth()896 public int getMvccVersionIndexWidth() { 897 return mvccVersionIndexWidth; 898 } 899 setMvccVersionIndexWidth(int mvccVersionIndexWidth)900 public void setMvccVersionIndexWidth(int mvccVersionIndexWidth) { 901 this.mvccVersionIndexWidth = mvccVersionIndexWidth; 902 } 903 getVersion()904 public int getVersion() { 905 return version; 906 } 907 setVersion(int version)908 public void setVersion(int version) { 909 this.version = version; 910 } 911 isIncludesMvccVersion()912 public boolean isIncludesMvccVersion() { 913 return includesMvccVersion; 914 } 915 setIncludesMvccVersion(boolean includesMvccVersion)916 public void setIncludesMvccVersion(boolean includesMvccVersion) { 917 this.includesMvccVersion = includesMvccVersion; 918 } 919 920 } 921