/** * @return Comparator that ignores timestamps; useful counting versions. */ public KVComparator getComparatorIgnoringTimestamps() { KVComparator c = null; try { c = (KVComparator)this.clone(); c.getRawComparator().ignoreTimestamp = true; } catch (CloneNotSupportedException e) { LOG.error("Not supported", e); } return c; }
/** * @return Comparator that ignores key type; useful checking deletes */ public KVComparator getComparatorIgnoringType() { KVComparator c = null; try { c = (KVComparator)this.clone(); c.getRawComparator().ignoreType = true; } catch (CloneNotSupportedException e) { LOG.error("Not supported", e); } return c; } }
.withCompression(compress) .withDataBlockEncoder(dataBlockEncoder) .withComparator(comparator.getRawComparator()) .withChecksumType(checksumType) .withBytesPerChecksum(bytesPerChecksum)
long readPointToUse, long earliestPutTs, long oldestUnexpiredTS) { this.tr = scan.getTimeRange(); this.rowComparator = scanInfo.getComparator().getRawComparator(); this.deletes = new ScanDeleteTracker(); this.stopRow = scan.getStopRow();
/** * Get the appropriate row comparator for the specified table. * * Hopefully we can get rid of this, I added this here because it's replacing * something in HSK. We should move completely off of that. * * @param tableName The table name. * @return The comparator. */ public static KeyComparator getRowComparator(byte [] tableName) { if(Bytes.equals(HTableDescriptor.ROOT_TABLEDESC.getName(),tableName)) { return ROOT_COMPARATOR.getRawComparator(); } if(Bytes.equals(HTableDescriptor.META_TABLEDESC.getName(), tableName)) { return META_COMPARATOR.getRawComparator(); } return COMPARATOR.getRawComparator(); }
/** * @param left * @param lrowlength Length of left row. * @param right * @param rrowlength Length of right row. * @return Result comparing rows. */ public int compareRows(final KeyValue left, final short lrowlength, final KeyValue right, final short rrowlength) { return getRawComparator().compareRows(left.getBuffer(), left.getRowOffset(), lrowlength, right.getBuffer(), right.getRowOffset(), rrowlength); }
/** * @param left * @param row - row key (arbitrary byte array) * @return RawComparator */ public int compareRows(final KeyValue left, final byte [] row) { return getRawComparator().compareRows(left.getBuffer(), left.getRowOffset(), left.getRowLength(), row, 0, row.length); }
public int compare(final KeyValue left, final KeyValue right) { int ret = getRawComparator().compare(left.getBuffer(), left.getOffset() + ROW_OFFSET, left.getKeyLength(), right.getBuffer(), right.getOffset() + ROW_OFFSET, right.getKeyLength()); if (ret != 0) return ret; // Negate this comparison so later edits show up first return -Longs.compare(left.getMemstoreTS(), right.getMemstoreTS()); }
int compareColumns(final KeyValue left, final short lrowlength, final KeyValue right, final short rrowlength) { int lfoffset = left.getFamilyOffset(lrowlength); int rfoffset = right.getFamilyOffset(rrowlength); int lclength = left.getTotalColumnLength(lrowlength,lfoffset); int rclength = right.getTotalColumnLength(rrowlength, rfoffset); int lfamilylength = left.getFamilyLength(lfoffset); int rfamilylength = right.getFamilyLength(rfoffset); return getRawComparator().compareColumns(left.getBuffer(), lfoffset, lclength, lfamilylength, right.getBuffer(), rfoffset, rclength, rfamilylength); }
public int compareRows(byte [] left, int loffset, int llength, byte [] right, int roffset, int rlength) { return getRawComparator().compareRows(left, loffset, llength, right, roffset, rlength); }
public int compareColumns(final KeyValue left, final byte [] right, final int roffset, final int rlength, final int rfamilyoffset) { int offset = left.getFamilyOffset(); int length = left.getFamilyLength() + left.getQualifierLength(); return getRawComparator().compareColumns(left.getBuffer(), offset, length, left.getFamilyLength(offset), right, roffset, rlength, rfamilyoffset); }
int compareTimestamps(final KeyValue left, final int lkeylength, final KeyValue right, final int rkeylength) { // Compare timestamps long ltimestamp = left.getTimestamp(lkeylength); long rtimestamp = right.getTimestamp(rkeylength); return getRawComparator().compareTimestamps(ltimestamp, rtimestamp); }