Package org.apache.cassandra.db.marshal

Class TupleType

java.lang.Object
org.apache.cassandra.db.marshal.AbstractType<ByteBuffer>
org.apache.cassandra.db.marshal.TupleType
All Implemented Interfaces:
Comparator<ByteBuffer>, AssignmentTestable
Direct Known Subclasses:
UserType
public class TupleType extends AbstractType<ByteBuffer>
This is essentially like a CompositeType, but it's not primarily meant for comparison, just to pack multiple values together so has a more friendly encoding.

  • Field Details

  • Constructor Details

  • Method Details

    • allowsEmpty

      public boolean allowsEmpty()
      Description copied from class: AbstractType
      Defines if the type allows an empty set of bytes (new byte[0]) as valid input. The AbstractType.validate(Object, ValueAccessor) and AbstractType.compose(Object, ValueAccessor) methods must allow empty bytes when this returns true, and must reject empty bytes when this is false.

      As of this writing, the main user of this API is for testing to know what types allow empty values and what types don't, so that the data that gets generated understands when ByteBufferUtil.EMPTY_BYTE_BUFFER is allowed as valid data.

      Overrides:
      allowsEmpty in class AbstractType<ByteBuffer>

    • getInstance

      public static TupleType getInstance(TypeParser parser) throws ConfigurationException, SyntaxException
      Throws:
      ConfigurationException
      SyntaxException

    • referencesUserType

      public <V> boolean referencesUserType(V name, ValueAccessor<V> accessor)
      Overrides:
      referencesUserType in class AbstractType<ByteBuffer>

    • withUpdatedUserType

      public TupleType withUpdatedUserType(UserType udt)
      Description copied from class: AbstractType
      Returns an instance of this type with all references to the provided user type recursively replaced with its new definition.
      Overrides:
      withUpdatedUserType in class AbstractType<ByteBuffer>

    • expandUserTypes

      public AbstractType<?> expandUserTypes()
      Description copied from class: AbstractType
      Replace any instances of UserType with equivalent TupleType-s. We need it for dropped_columns, to allow safely dropping unused user types later without retaining any references to them in system_schema.dropped_columns.
      Overrides:
      expandUserTypes in class AbstractType<ByteBuffer>

    • referencesDuration

      public boolean referencesDuration()
      Overrides:
      referencesDuration in class AbstractType<ByteBuffer>

    • type

      public AbstractType<?> type(int i)

    • size

      public int size()

    • subTypes

      public List<AbstractType<?>> subTypes()
      Overrides:
      subTypes in class AbstractType<ByteBuffer>

    • allTypes

      public List<AbstractType<?>> allTypes()

    • isTuple

      public boolean isTuple()
      Overrides:
      isTuple in class AbstractType<ByteBuffer>

    • compareCustom

      public <VL, VR> int compareCustom(VL left, ValueAccessor<VL> accessorL, VR right, ValueAccessor<VR> accessorR)
      Description copied from class: AbstractType
      Implement IFF ComparisonType is CUSTOM Compares the byte representation of two instances of this class, for types where this cannot be done by simple in-order comparison of the unsigned bytes Standard Java compare semantics
      Overrides:
      compareCustom in class AbstractType<ByteBuffer>

    • asComparableBytes

      public <V> ByteSource asComparableBytes(ValueAccessor<V> accessor, V data, ByteComparable.Version version)
      Description copied from class: AbstractType
      Produce a byte-comparable representation of the given value, i.e. a sequence of bytes that compares the same way using lexicographical unsigned byte comparison as the original value using the type's comparator. We use a slightly stronger requirement to be able to use the types in tuples. Precisely, for any pair x, y of non-equal valid values of this type and any bytes b1, b2 between 0x10 and 0xEF, (+ stands for concatenation) compare(x, y) == compareLexicographicallyUnsigned(asByteComparable(x)+b1, asByteComparable(y)+b2) (i.e. the values compare like the original type, and an added 0x10-0xEF byte at the end does not change that) and: asByteComparable(x)+b1 is not a prefix of asByteComparable(y) (weakly prefix free) (i.e. a valid representation of a value may be a prefix of another valid representation of a value only if the following byte in the latter is smaller than 0x10 or larger than 0xEF). These properties are trivially true if the encoding compares correctly and is prefix free, but also permits a little more freedom that enables somewhat more efficient encoding of arbitrary-length byte-comparable blobs. Depending on the type, this method can be called for null or empty input, in which case the output is allowed to be null (the clustering/tuple encoding will accept and handle it).
      Overrides:
      asComparableBytes in class AbstractType<ByteBuffer>

    • fromComparableBytes

      public <V> V fromComparableBytes(ValueAccessor<V> accessor, ByteSource.Peekable comparableBytes, ByteComparable.Version version)
      Description copied from class: AbstractType
      Translates the given byte-ordered representation to the common, non-byte-ordered binary representation of a payload for this abstract type (the latter, common binary representation is what we mostly work with in the storage engine internals). If the given bytes don't correspond to the encoding of some payload value for this abstract type, an IllegalArgumentException may be thrown.
      Overrides:
      fromComparableBytes in class AbstractType<ByteBuffer>
      Parameters:
      accessor - value accessor used to construct the value.
      comparableBytes - A byte-ordered representation (presumably of a payload for this abstract type).
      version - The byte-comparable version used to construct the representation.
      Returns:
      A of a payload for this abstract type, corresponding to the given byte-ordered representation, constructed using the supplied value accessor.
      See Also:

    • split

      public <V> V[] split(ValueAccessor<V> accessor, V value)
      Split a tuple value into its component values.

    • split

      public static <V> V[] split(ValueAccessor<V> accessor, V value, int numberOfElements, TupleType type)
      Split a tuple value into its component values.

    • buildValue

      @SafeVarargs public static <V> V buildValue(ValueAccessor<V> accessor, V... components)

    • buildValue

      public static ByteBuffer buildValue(ByteBuffer... components)

    • getString

      public <V> String getString(V input, ValueAccessor<V> accessor)
      Description copied from class: AbstractType
      get a string representation of the bytes used for various identifier (NOT just for log messages)
      Overrides:
      getString in class AbstractType<ByteBuffer>

    • fromString

      public ByteBuffer fromString(String source)
      Description copied from class: AbstractType
      get a byte representation of the given string.
      Specified by:
      fromString in class AbstractType<ByteBuffer>

    • fromJSONObject

      public Term fromJSONObject(Object parsed) throws MarshalException
      Description copied from class: AbstractType
      Given a parsed JSON string, return a byte representation of the object.
      Specified by:
      fromJSONObject in class AbstractType<ByteBuffer>
      Parameters:
      parsed - the result of parsing a json string
      Throws:
      MarshalException

    • toJSONString

      public String toJSONString(ByteBuffer buffer, ProtocolVersion protocolVersion)
      Description copied from class: AbstractType
      Converts the specified value into its JSON representation.

      The buffer position will stay the same.

      Overrides:
      toJSONString in class AbstractType<ByteBuffer>
      Parameters:
      buffer - the value to convert
      protocolVersion - the protocol version to use for the conversion
      Returns:
      a JSON string representing the specified value

    • getSerializer

      public TypeSerializer<ByteBuffer> getSerializer()
      Specified by:
      getSerializer in class AbstractType<ByteBuffer>

    • isCompatibleWith

      public boolean isCompatibleWith(AbstractType<?> previous)
      Description copied from class: AbstractType
      Returns true if this comparator is compatible with the provided previous comparator, that is if previous can safely be replaced by this. A comparator cn should be compatible with a previous one cp if forall columns c1 and c2, if cn.validate(c1) and cn.validate(c2) and cn.compare(c1, c2) == v, then cp.validate(c1) and cp.validate(c2) and cp.compare(c1, c2) == v. Note that a type should be compatible with at least itself and when in doubt, keep the default behavior of not being compatible with any other comparator!
      Overrides:
      isCompatibleWith in class AbstractType<ByteBuffer>

    • isValueCompatibleWithInternal

      public boolean isValueCompatibleWithInternal(AbstractType<?> otherType)
      Description copied from class: AbstractType
      Needed to handle ReversedType in value-compatibility checks. Subclasses should implement this instead of isValueCompatibleWith().
      Overrides:
      isValueCompatibleWithInternal in class AbstractType<ByteBuffer>

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object o)
      Specified by:
      equals in interface Comparator<ByteBuffer>
      Overrides:
      equals in class Object

    • asCQL3Type

      public CQL3Type asCQL3Type()
      Overrides:
      asCQL3Type in class AbstractType<ByteBuffer>

    • toString

      public String toString()
      Description copied from class: AbstractType
      This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()). Note that for backwards compatibility this includes the full classname. For CQL purposes the short name is fine.
      Overrides:
      toString in class AbstractType<ByteBuffer>

    • getMaskedValue

      public ByteBuffer getMaskedValue()
      Overrides:
      getMaskedValue in class AbstractType<ByteBuffer>
      Returns:
      A fixed, serialized value to be used when the column is masked, to be returned instead of the real value.