@Internal public final class TupleComparator<T extends Tuple> extends TupleComparatorBase<T>
comparators, deserializedFields1, deserializedFields2, HASH_SALT, invertNormKey, keyPositions, normalizableKeyPrefixLen, normalizedKeyLengths, numLeadingNormalizableKeys, serializers| Constructor and Description |
|---|
TupleComparator(int[] keyPositions,
TypeComparator<?>[] comparators,
TypeSerializer<?>[] serializers) |
| Modifier and Type | Method and Description |
|---|---|
int |
compare(T first,
T second)
Compares two records in object form.
|
TypeComparator<T> |
duplicate()
Creates a copy of this class.
|
boolean |
equalToReference(T candidate)
Checks, whether the given element is equal to the element that has been set as the comparison
reference in this comparator instance.
|
int |
extractKeys(Object record,
Object[] target,
int index)
Extracts the key fields from a record.
|
int |
hash(T value)
Computes a hash value for the given record.
|
void |
putNormalizedKey(T value,
MemorySegment target,
int offset,
int numBytes)
Writes a normalized key for the given record into the target byte array, starting at the
specified position and writing exactly the given number of bytes.
|
void |
setReference(T toCompare)
Sets the given element as the comparison reference for future calls to
TypeComparator.equalToReference(Object) and TypeComparator.compareToReference(TypeComparator). |
compareSerialized, compareToReference, getFlatComparator, getKeyPositions, getNormalizeKeyLen, instantiateDeserializationUtils, invertNormalizedKey, isNormalizedKeyPrefixOnly, privateDuplicate, readWithKeyDenormalization, supportsNormalizedKey, supportsSerializationWithKeyNormalization, writeWithKeyNormalizationgetFlatComparatorscompareAgainstReference, supportsCompareAgainstReferencepublic TupleComparator(int[] keyPositions,
TypeComparator<?>[] comparators,
TypeSerializer<?>[] serializers)
public int hash(T value)
TypeComparatorThe hash code is typically not used as it is in hash tables and for partitioning, but it is further scrambled to make sure that a projection of the hash values to a lower cardinality space is as results in a rather uniform value distribution. However, any collisions produced by this method cannot be undone. While it is NOT important to create hash codes that cover the full spectrum of bits in the integer, it IS important to avoid collisions when combining two value as much as possible.
hash in class TypeComparator<T extends Tuple>value - The record to be hashed.Object.hashCode()public void setReference(T toCompare)
TypeComparatorTypeComparator.equalToReference(Object) and TypeComparator.compareToReference(TypeComparator). This method must
set the given element into this comparator instance's state. If the comparison happens on a
subset of the fields from the record, this method may extract those fields.
A typical example for checking the equality of two elements is the following:
E e1 = ...;
E e2 = ...;
TypeComparator<E> acc = ...;
acc.setReference(e1);
boolean equal = acc.equalToReference(e2);
setReference in class TypeComparator<T extends Tuple>toCompare - The element to set as the comparison reference.public boolean equalToReference(T candidate)
TypeComparatorequalToReference in class TypeComparator<T extends Tuple>candidate - The candidate to check.TypeComparator.setReference(Object)public int compare(T first, T second)
TypeComparatorComparator.compare(Object, Object).compare in class TypeComparator<T extends Tuple>first - The first record.second - The second record.Comparator.compare(Object, Object).Comparator.compare(Object, Object)public void putNormalizedKey(T value, MemorySegment target, int offset, int numBytes)
TypeComparatorint byteI = bytes[i] & 0xFF;
If the meaningful part of the normalized key takes less than the given number of bytes,
then it must be padded. Padding is typically required for variable length data types, such as
strings. The padding uses a special character, either 0 or 0xff, depending on
whether shorter values are sorted to the beginning or the end.
This method is similar to NormalizableKey.copyNormalizedKey(MemorySegment, int, int). In the
case that multiple fields of a record contribute to the normalized key, it is crucial that
the fields align on the byte field, i.e. that every field always takes up the exact same
number of bytes.
putNormalizedKey in class TypeComparator<T extends Tuple>value - The record for which to create the normalized key.target - The byte array into which to write the normalized key bytes.offset - The offset in the byte array, where to start writing the normalized key bytes.numBytes - The number of bytes to be written exactly.NormalizableKey.copyNormalizedKey(MemorySegment, int, int)public int extractKeys(Object record, Object[] target, int index)
TypeComparatorextractKeys in class TypeComparator<T extends Tuple>record - The record that contains the key(s)target - The array to write the key(s) into.index - The offset of the target array to start writing into.public TypeComparator<T> duplicate()
TypeComparatorduplicate in class TypeComparator<T extends Tuple>Copyright © 2014–2024 The Apache Software Foundation. All rights reserved.