Package org.apache.cassandra.db.marshal

Class CompositeType

java.lang.Object

org.apache.cassandra.db.marshal.AbstractType<ByteBuffer>

org.apache.cassandra.db.marshal.AbstractCompositeType

org.apache.cassandra.db.marshal.CompositeType

All Implemented Interfaces:

Comparator<ByteBuffer>, AssignmentTestable

public class CompositeType
extends AbstractCompositeType

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	CompositeType.Serializer

Nested classes/interfaces inherited from class org.apache.cassandra.db.marshal.AbstractCompositeType

AbstractCompositeType.ParsedComparator

Nested classes/interfaces inherited from class org.apache.cassandra.db.marshal.AbstractType

AbstractType.ComparisonType, AbstractType.DefaultArgumentDeserializer

Nested classes/interfaces inherited from interface org.apache.cassandra.cql3.AssignmentTestable

AssignmentTestable.TestResult

Field Summary

Fields

Modifier and Type	Field	Description
final List<AbstractType<?>>	types

Fields inherited from class org.apache.cassandra.db.marshal.AbstractType

comparatorSet, comparisonType, isByteOrderComparable, reverseComparator

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	CompositeType(List<AbstractType<?>> types)

Method Summary

Modifier and Type	Method	Description
<V> ByteSource	asComparableBytes(ValueAccessor<V> accessor, V data, ByteComparable.Version version)	Produce a byte-comparable representation of the given value, i.e.
static <V> V	build(ValueAccessor<V> accessor, boolean isStatic, V... values)
static <V> V	build(ValueAccessor<V> accessor, boolean isStatic, V[] values, byte lastEoc)
static <V> V	build(ValueAccessor<V> accessor, V... values)
ByteBuffer	decompose(Object... objects)
boolean	equals(Object o)
AbstractType<?>	expandUserTypes()	Replace any instances of UserType with equivalent TupleType-s.
static ByteBuffer	extractComponent(ByteBuffer bb, int idx)
<V> V	fromComparableBytes(ValueAccessor<V> accessor, ByteSource.Peekable comparableBytes, ByteComparable.Version version)	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).
protected <V> AbstractType<?>	getAndAppendComparator(int i, V value, ValueAccessor<V> accessor, StringBuilder sb, int offset)	Adds type information from @param bb to @param sb.
protected <VL, VR> AbstractType<?>	getComparator(int i, VL left, ValueAccessor<VL> accessorL, VR right, ValueAccessor<VR> accessorR, int offsetL, int offsetR)	Adds DynamicCompositeType type information from @param bb1 to @param bb2.
protected <V> AbstractType<?>	getComparator(int i, V value, ValueAccessor<V> accessor, int offset)
protected <V> int	getComparatorSize(int i, V value, ValueAccessor<V> accessor, int offset)
List<AbstractType<?>>	getComponents()	Return a list of the "subcomponents" this type has.
static CompositeType	getInstance(Iterable<AbstractType<?>> types)
static CompositeType	getInstance(List<AbstractType<?>> types)
static CompositeType	getInstance(AbstractType... types)
static CompositeType	getInstance(TypeParser parser)
TypeSerializer<ByteBuffer>	getSerializer()
int	hashCode()
boolean	isCompatibleWith(AbstractType<?> previous)	Returns true if this comparator is compatible with the provided previous comparator, that is if previous can safely be replaced by this.
static <V> boolean	isStaticName(V value, ValueAccessor<V> accessor)
boolean	isValueCompatibleWithInternal(AbstractType<?> otherType)	Needed to handle ReversedType in value-compatibility checks.
protected AbstractCompositeType.ParsedComparator	parseComparator(int i, String part)	Used by fromString
protected <V> boolean	readIsStatic(V value, ValueAccessor<V> accessor)
protected static <V> boolean	readIsStaticInternal(V value, ValueAccessor<V> accessor)
<V> boolean	referencesUserType(V name, ValueAccessor<V> accessor)
ByteBuffer[]	split(ByteBuffer name)	Split a composite column names into it's components.
static <V> List<V>	splitName(V name, ValueAccessor<V> accessor)
protected int	startingOffset(boolean isStatic)
protected static int	startingOffsetInternal(boolean isStatic)
List<AbstractType<?>>	subTypes()
String	toString()	This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()).
protected <V> AbstractType<?>	validateComparator(int i, V value, ValueAccessor<V> accessor, int offset)	Like getComparator, but validates that @param i does not exceed the defined range
CompositeType	withUpdatedUserType(UserType udt)	Returns an instance of this type with all references to the provided user type recursively replaced with its new definition.

Methods inherited from class org.apache.cassandra.db.marshal.AbstractCompositeType

allowsEmpty, compareCustom, escape, fromJSONObject, fromString, getString, toJSONString, validate, validate

Methods inherited from class org.apache.cassandra.db.marshal.AbstractType

asComparableBytes, asCQL3Type, asCQLTypeStringList, checkComparable, compare, compare, compareCollectionMembers, compareForCQL, compose, compose, decompose, decomposeUntyped, freeze, freezeNestedMulticellTypes, fromComparableBytes, getArgumentDeserializer, getCompatibleTypeIfKnown, getMaskedValue, getString, getString, isCollection, isCounter, isEmptyValueMeaningless, isFreezable, isFrozenCollection, isMultiCell, isNull, isNull, isReversed, isSerializationCompatibleWith, isTuple, isUDT, isValueCompatibleWith, isValueLengthFixed, isVector, parseDefaultParameters, read, readArray, readBuffer, readBuffer, referencesDuration, referencesUserType, skipValue, testAssignment, testAssignment, toCQLString, toJSONString, toString, udfType, unfreeze, unwrap, validateCellValue, validateCollectionMember, valueLengthIfFixed, writeValue, writeValue, writtenLength, writtenLength

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.Comparator

reversed, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

Field Details

types

public final List<AbstractType<?>> types

Constructor Details

CompositeType

protected CompositeType(List<AbstractType<?>> types)

Method Details

getInstance

public static CompositeType getInstance(TypeParser parser)
                                 throws ConfigurationException,
SyntaxException

Throws:

ConfigurationException

SyntaxException

getInstance

public static CompositeType getInstance(Iterable<AbstractType<?>> types)

getInstance

public static CompositeType getInstance(AbstractType... types)

startingOffsetInternal

protected static int startingOffsetInternal(boolean isStatic)

startingOffset

protected int startingOffset(boolean isStatic)

Specified by:

startingOffset in class AbstractCompositeType

readIsStaticInternal

protected static <V> boolean readIsStaticInternal(V value,
 ValueAccessor<V> accessor)

readIsStatic

protected <V> boolean readIsStatic(V value,
 ValueAccessor<V> accessor)

Specified by:

readIsStatic in class AbstractCompositeType

getInstance

public static CompositeType getInstance(List<AbstractType<?>> types)

subTypes

public List<AbstractType<?>> subTypes()

Overrides:

subTypes in class AbstractType<ByteBuffer>

getSerializer

public TypeSerializer<ByteBuffer> getSerializer()

Specified by:

getSerializer in class AbstractType<ByteBuffer>

getComparator

protected <V> AbstractType<?> getComparator(int i,
 V value,
 ValueAccessor<V> accessor,
 int offset)

Specified by:

getComparator in class AbstractCompositeType

Parameters:

i - DynamicCompositeType will read the type information from @param bb

value - name of type definition

Returns:

the comparator for the given component. static CompositeType will consult

getComparator

protected <VL,
VR> AbstractType<?> getComparator(int i,
 VL left,
 ValueAccessor<VL> accessorL,
 VR right,
 ValueAccessor<VR> accessorR,
 int offsetL,
 int offsetR)

Description copied from class: AbstractCompositeType

Adds DynamicCompositeType type information from @param bb1 to @param bb2.

Specified by:

getComparator in class AbstractCompositeType

Parameters:

i - is ignored.

getAndAppendComparator

protected <V> AbstractType<?> getAndAppendComparator(int i,
 V value,
 ValueAccessor<V> accessor,
 StringBuilder sb,
 int offset)

Description copied from class: AbstractCompositeType

Adds type information from @param bb to @param sb. @param i is ignored.

Specified by:

getAndAppendComparator in class AbstractCompositeType

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:

• AbstractType.asComparableBytes(org.apache.cassandra.db.marshal.ValueAccessor<V>, V, org.apache.cassandra.utils.bytecomparable.ByteComparable.Version)

parseComparator

protected AbstractCompositeType.ParsedComparator parseComparator(int i,
 String part)

Description copied from class: AbstractCompositeType

Used by fromString

Specified by:

parseComparator in class AbstractCompositeType

validateComparator

protected <V> AbstractType<?> validateComparator(int i,
 V value,
 ValueAccessor<V> accessor,
 int offset)
                                          throws MarshalException

Description copied from class: AbstractCompositeType

Like getComparator, but validates that @param i does not exceed the defined range

Specified by:

validateComparator in class AbstractCompositeType

Throws:

MarshalException

getComparatorSize

protected <V> int getComparatorSize(int i,
 V value,
 ValueAccessor<V> accessor,
 int offset)

Specified by:

getComparatorSize in class AbstractCompositeType

decompose

public ByteBuffer decompose(Object... objects)

Specified by:

decompose in class AbstractCompositeType

split

public ByteBuffer[] split(ByteBuffer name)

Description copied from class: AbstractCompositeType

Split a composite column names into it's components.

Overrides:

split in class AbstractCompositeType

splitName

public static <V> List<V> splitName(V name,
 ValueAccessor<V> accessor)

extractComponent

public static ByteBuffer extractComponent(ByteBuffer bb,
 int idx)

isStaticName

public static <V> boolean isStaticName(V value,
 ValueAccessor<V> accessor)

getComponents

public List<AbstractType<?>> getComponents()

Description copied from class: AbstractType

Return a list of the "subcomponents" this type has. This always return a singleton list with the type itself except for CompositeType.

Overrides:

getComponents 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>

referencesUserType

public <V> boolean referencesUserType(V name,
 ValueAccessor<V> accessor)

Overrides:

referencesUserType in class AbstractType<ByteBuffer>

withUpdatedUserType

public CompositeType 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>

equals

public boolean equals(Object o)

Specified by:

equals in interface Comparator<ByteBuffer>

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

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>

build

@SafeVarargs
public static <V> V build(ValueAccessor<V> accessor,
 V... values)

build

@SafeVarargs
public static <V> V build(ValueAccessor<V> accessor,
 boolean isStatic,
 V... values)

build

public static <V> V build(ValueAccessor<V> accessor,
 boolean isStatic,
 V[] values,
 byte lastEoc)