org.apache.cassandra.db.marshal

## Class UserType

- java.lang.Object
- - org.apache.cassandra.db.marshal.AbstractType<java.nio.ByteBuffer>
  - - org.apache.cassandra.db.marshal.TupleType
    - - org.apache.cassandra.db.marshal.UserType

All Implemented Interfaces:
  java.util.Comparator<java.nio.ByteBuffer>, AssignmentTestable

    public class UserType
    extends TupleType

A user defined type. A user type is really just a tuple type on steroids.

### Nested Class Summary

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

`AbstractType.ComparisonType`

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

`AssignmentTestable.TestResult`

### Field Summary

Fields
`java.lang.String` `keyspace`
`java.nio.ByteBuffer` `name`

### Fields inherited from class org.apache.cassandra.db.marshal.TupleType

`types`

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

`comparisonType, isByteOrderComparable, reverseComparator`

### Constructor Summary

Constructors
Constructor and Description
`UserType(java.lang.String keyspace, java.nio.ByteBuffer name, java.util.List<FieldIdentifier> fieldNames, java.util.List<AbstractType<?>> fieldTypes, boolean isMultiCell)`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`CQL3Type` `asCQL3Type()`
`CellPath` `cellPathForField(FieldIdentifier fieldName)`
`boolean` `equals(java.lang.Object o)`
`boolean` `equals(java.lang.Object o, boolean ignoreFreezing)` Checks to see if two types are equal when ignoring or not ignoring differences in being frozen, depending on the value of the ignoreFreezing parameter.
`FieldIdentifier` `fieldName(int i)`
`java.lang.String` `fieldNameAsString(int i)`
`java.util.List<FieldIdentifier>` `fieldNames()`
`int` `fieldPosition(FieldIdentifier fieldName)`
`AbstractType<?>` `fieldType(int i)`
`java.util.List<AbstractType<?>>` `fieldTypes()`
`UserType` `freeze()`
`AbstractType<?>` `freezeNestedMulticellTypes()` Returns an AbstractType instance that is equivalent to this one, but with all nested UDTs and collections explicitly frozen.
`Term` `fromJSONObject(java.lang.Object parsed)` Given a parsed JSON string, return a byte representation of the object.
`static UserType` `getInstance(TypeParser parser)`
`java.lang.String` `getNameAsString()`
`TypeSerializer<java.nio.ByteBuffer>` `getSerializer()`
`int` `hashCode()`
`boolean` `isFreezable()`
`boolean` `isMultiCell()`
`boolean` `isTuple()`
`boolean` `isUDT()`
`boolean` `isValueCompatibleWith(AbstractType<?> previous)` Returns true if values of the other AbstractType can be read and "reasonably" interpreted by the this AbstractType.
`ShortType` `nameComparator()`
`boolean` `referencesDuration()`
`boolean` `referencesUserType(java.lang.String userTypeName)`
`java.nio.ByteBuffer` `serializeForNativeProtocol(java.util.Iterator<Cell> cells, ProtocolVersion protocolVersion)`
`java.lang.String` `toJSONString(java.nio.ByteBuffer buffer, ProtocolVersion protocolVersion)` Converts the specified value into its JSON representation.
`java.lang.String` `toString()` This must be overriden by subclasses if necessary so that for any AbstractType, this == TypeParser.parse(toString()).
`java.lang.String` `toString(boolean ignoreFreezing)`
`void` `validateCell(Cell cell)`

### Methods inherited from class org.apache.cassandra.db.marshal.TupleType

`allTypes, buildValue, compareCustom, fromString, getString, isCompatibleWith, isValueCompatibleWithInternal, size, split, type`

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

`asCQLTypeStringList, checkComparable, compare, compareCollectionMembers, compareForCQL, componentsCount, compose, decompose, getComponents, getString, isCollection, isCounter, isEmptyValueMeaningless, isFrozenCollection, isReversed, parseDefaultParameters, readValue, readValue, skipValue, testAssignment, validate, validateCellValue, validateCollectionMember, valueLengthIfFixed, writeValue, writtenLength`

### Methods inherited from class java.lang.Object

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

### Methods inherited from interface java.util.Comparator

`comparing, comparing, comparingDouble, comparingInt, comparingLong, naturalOrder, nullsFirst, nullsLast, reversed, reverseOrder, thenComparing, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong`

### Field Detail

#### keyspace

    public final java.lang.String keyspace

#### name

    public final java.nio.ByteBuffer name

### Constructor Detail

#### UserType

    public UserType(java.lang.String keyspace,
                    java.nio.ByteBuffer name,
                    java.util.List<FieldIdentifier> fieldNames,
                    java.util.List<AbstractType<?>> fieldTypes,
                    boolean isMultiCell)

### Method Detail

#### getInstance

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

Throws:
  `ConfigurationException`
  `SyntaxException`

#### isUDT

    public boolean isUDT()

Overrides:
  `isUDT` in class `AbstractType<java.nio.ByteBuffer>`

#### isMultiCell

    public boolean isMultiCell()

Overrides:
  `isMultiCell` in class `AbstractType<java.nio.ByteBuffer>`

#### isFreezable

    public boolean isFreezable()

Overrides:
  `isFreezable` in class `AbstractType<java.nio.ByteBuffer>`

#### fieldType

    public AbstractType<?> fieldType(int i)

#### fieldTypes

    public java.util.List<AbstractType<?>> fieldTypes()

#### fieldName

    public FieldIdentifier fieldName(int i)

#### fieldNameAsString

    public java.lang.String fieldNameAsString(int i)

#### fieldNames

    public java.util.List<FieldIdentifier> fieldNames()

#### getNameAsString

    public java.lang.String getNameAsString()

#### fieldPosition

    public int fieldPosition(FieldIdentifier fieldName)

#### cellPathForField

    public CellPath cellPathForField(FieldIdentifier fieldName)

#### nameComparator

    public ShortType nameComparator()

#### serializeForNativeProtocol

    public java.nio.ByteBuffer serializeForNativeProtocol(java.util.Iterator<Cell> cells,
                                                          ProtocolVersion protocolVersion)

#### validateCell

    public void validateCell(Cell cell)
                      throws MarshalException

Throws:
  `MarshalException`

#### fromJSONObject

    public Term fromJSONObject(java.lang.Object parsed)
                        throws MarshalException

Description copied from class: `AbstractType`
Given a parsed JSON string, return a byte representation of the object.

Overrides:
  `fromJSONObject` in class `TupleType`
Parameters:
  `parsed` - the result of parsing a json string
Throws:
  `MarshalException`

#### toJSONString

    public java.lang.String toJSONString(java.nio.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 `TupleType`
Parameters:
  `buffer` - the value to convert
  `protocolVersion` - the protocol version to use for the conversion
Returns:
  a JSON string representing the specified value

#### freeze

    public UserType freeze()

Overrides:
  `freeze` in class `AbstractType<java.nio.ByteBuffer>`

#### freezeNestedMulticellTypes

    public AbstractType<?> freezeNestedMulticellTypes()

Description copied from class: `AbstractType`
Returns an AbstractType instance that is equivalent to this one, but with all nested UDTs and collections explicitly frozen. This is only necessary for `2.x -> 3.x` schema migrations, and can be removed in Cassandra 4.0. See CASSANDRA-11609 and CASSANDRA-11613.

Overrides:
  `freezeNestedMulticellTypes` in class `AbstractType<java.nio.ByteBuffer>`

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `TupleType`

#### isValueCompatibleWith

    public boolean isValueCompatibleWith(AbstractType<?> previous)

Description copied from class: `AbstractType`
Returns true if values of the other AbstractType can be read and "reasonably" interpreted by the this AbstractType. Note that this is a weaker version of isCompatibleWith, as it does not require that both type compare values the same way. The restriction on the other type being "reasonably" interpreted is to prevent, for example, IntegerType from being compatible with all other types. Even though any byte string is a valid IntegerType value, it doesn't necessarily make sense to interpret a UUID or a UTF8 string as an integer. Note that a type should be compatible with at least itself.

Overrides:
  `isValueCompatibleWith` in class `AbstractType<java.nio.ByteBuffer>`

#### equals

    public boolean equals(java.lang.Object o)

Specified by:
  `equals` in interface `java.util.Comparator<java.nio.ByteBuffer>`
Overrides:
  `equals` in class `TupleType`

#### equals

    public boolean equals(java.lang.Object o,
                          boolean ignoreFreezing)

Description copied from class: `AbstractType`
Checks to see if two types are equal when ignoring or not ignoring differences in being frozen, depending on the value of the ignoreFreezing parameter.

Overrides:
  `equals` in class `AbstractType<java.nio.ByteBuffer>`
Parameters:
  `o` - type to compare
  `ignoreFreezing` - if true, differences in the types being frozen will be ignored

#### asCQL3Type

    public CQL3Type asCQL3Type()

Overrides:
  `asCQL3Type` in class `TupleType`

#### referencesUserType

    public boolean referencesUserType(java.lang.String userTypeName)

Overrides:
  `referencesUserType` in class `TupleType`

#### referencesDuration

    public boolean referencesDuration()

Overrides:
  `referencesDuration` in class `TupleType`

#### toString

    public java.lang.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 `TupleType`

#### isTuple

    public boolean isTuple()

Overrides:
  `isTuple` in class `TupleType`

#### toString

    public java.lang.String toString(boolean ignoreFreezing)

Overrides:
  `toString` in class `AbstractType<java.nio.ByteBuffer>`
Parameters:
  `ignoreFreezing` - if true, the type string will not be wrapped with FrozenType(...), even if this type is frozen.

#### getSerializer

    public TypeSerializer<java.nio.ByteBuffer> getSerializer()

Overrides:
  `getSerializer` in class `TupleType`