import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public void validateCell(Cell cell)
{
    if (cell.isTombstone())
    {
        if (cell.value().hasRemaining())
            throw new MarshalException("A tombstone should not have a value");
        if (cell.path() != null)
            validateCellPath(cell.path());
    }
    else if(type.isUDT())
    {
        // To validate a non-frozen UDT field, both the path and the value
        // are needed, the path being an index into an array of value types.
        ((UserType)type).validateCell(cell);
    }
    else
    {
        type.validateCellValue(cell.value());
        if (cell.path() != null)
            validateCellPath(cell.path());
    }
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof UserType))
        throw new InvalidRequestException(String.format("Invalid user type literal for %s of type %s", receiver, receiver.type.asCQL3Type()));

    UserType ut = (UserType)receiver.type;
    for (int i = 0; i < ut.size(); i++)
    {
        ColumnIdentifier field = new ColumnIdentifier(ut.fieldName(i), UTF8Type.instance);
        Term.Raw value = entries.get(field);
        if (value == null)
            continue;

        ColumnSpecification fieldSpec = fieldSpecOf(receiver, i);
        if (!value.isAssignableTo(keyspace, fieldSpec))
            throw new InvalidRequestException(String.format("Invalid user type literal for %s: field %s is not of type %s", receiver, field, fieldSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public Selector.Factory newSelectorFactory(CFMetaData cfm,
                                           List<ColumnDefinition> defs) throws InvalidRequestException
{
    Selector.Factory factory = selected.newSelectorFactory(cfm, defs);
    AbstractType<?> type = factory.newInstance().getType();
    if (!(type instanceof UserType))
        throw new InvalidRequestException(
                String.format("Invalid field selection: %s of type %s is not a user type",
                              selected,
                              type.asCQL3Type()));

    UserType ut = (UserType) type;
    for (int i = 0; i < ut.size(); i++)
    {
        if (!ut.fieldName(i).equals(field.bytes))
            continue;
        return FieldSelector.newFactory(ut, i, factory);
    }
    throw new InvalidRequestException(String.format("%s of type %s has no field %s",
                                                    selected,
                                                    type.asCQL3Type(),
                                                    field));
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof UserType))
        throw new InvalidRequestException(String.format("Invalid user type literal for %s of type %s", receiver, receiver.type.asCQL3Type()));

    UserType ut = (UserType)receiver.type;
    for (int i = 0; i < ut.size(); i++)
    {
        ColumnIdentifier field = new ColumnIdentifier(ut.fieldName(i), UTF8Type.instance);
        Term.Raw value = entries.get(field);
        if (value == null)
            continue;

        ColumnSpecification fieldSpec = fieldSpecOf(receiver, i);
        if (!value.testAssignment(keyspace, fieldSpec).isAssignable())
            throw new InvalidRequestException(String.format("Invalid user type literal for %s: field %s is not of type %s", receiver, field, fieldSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof UserType))
        throw new InvalidRequestException(String.format("Invalid user type literal for %s of type %s", receiver, receiver.type.asCQL3Type()));

    UserType ut = (UserType)receiver.type;
    for (int i = 0; i < ut.types.size(); i++)
    {
        ColumnIdentifier field = new ColumnIdentifier(ut.columnNames.get(i), UTF8Type.instance);
        Term.Raw value = entries.get(field);
        if (value == null)
            throw new InvalidRequestException(String.format("Invalid user type literal for %s: missing field %s", receiver, field));

        ColumnSpecification fieldSpec = fieldSpecOf(receiver, i);
        if (!value.isAssignableTo(keyspace, fieldSpec))
            throw new InvalidRequestException(String.format("Invalid user type literal for %s: field %s is not of type %s", receiver, field, fieldSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
/**
 * Create a Types instance with the provided type added
 */
public Types with(UserType type)
{
    if (get(type.name).isPresent())
        throw new IllegalStateException(format("Type %s already exists", type.name));

    return builder().add(this).add(type).build();
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
/**
 * Creates a Types instance with the type with the provided name removed
 */
public Types without(ByteBuffer name)
{
    UserType type =
        get(name).orElseThrow(() -> new IllegalStateException(format("Type %s doesn't exists", name)));

    return builder().add(filter(this, t -> t != type)).build();
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
@Override
public boolean equals(Object o)
{
    if (this == o)
        return true;

    if (!(o instanceof Types))
        return false;

    Types other = (Types) o;

    if (types.size() != other.types.size())
        return false;

    Iterator<Map.Entry<ByteBuffer, UserType>> thisIter = this.types.entrySet().iterator();
    Iterator<Map.Entry<ByteBuffer, UserType>> otherIter = other.types.entrySet().iterator();
    while (thisIter.hasNext())
    {
        Map.Entry<ByteBuffer, UserType> thisNext = thisIter.next();
        Map.Entry<ByteBuffer, UserType> otherNext = otherIter.next();
        if (!thisNext.getKey().equals(otherNext.getKey()))
            return false;

        if (!thisNext.getValue().equals(otherNext.getValue(), true))  // ignore freezing
            return false;
    }
    return true;
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
UserType prepare(String keyspace, Types types)
{
    List<FieldIdentifier> preparedFieldNames =
        fieldNames.stream()
                  .map(t -> FieldIdentifier.forInternalString(t))
                  .collect(toList());

    List<AbstractType<?>> preparedFieldTypes =
        fieldTypes.stream()
                  .map(t -> t.prepareInternal(keyspace, types).getType())
                  .collect(toList());

    return new UserType(keyspace, bytes(name), preparedFieldNames, preparedFieldTypes, true);
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public static AbstractType<?> parse(String keyspace, String unparsed, Types userTypes)
{
    String lowercased = unparsed.toLowerCase();

    // fast path for the common case of a primitive type
    if (PRIMITIVE_TYPES.contains(lowercased))
        return CQL3Type.Native.valueOf(unparsed.toUpperCase()).getType();

    // special-case top-level UDTs
    UserType udt = userTypes.getNullable(bytes(lowercased));
    if (udt != null)
        return udt;

    return parseRaw(unparsed).prepareInternal(keyspace, userTypes).getType();
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private static Types getTypes() {
    if (knownTypes.isEmpty()) {
        return Types.none();
    } else {
        return Types.of(knownTypes.values().toArray(new UserType[0]));
    }
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public static ColumnSpecification fieldSpecOf(ColumnSpecification column, int field)
{
    UserType ut = (UserType)column.type;
    return new ColumnSpecification(column.ksName,
                                   column.cfName,
                                   new ColumnIdentifier(column.name + "." + UTF8Type.instance.compose(ut.fieldName(field)), true),
                                   ut.fieldType(field));
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public static void checkForDuplicateNames(UserType type) throws InvalidRequestException
{
    for (int i = 0; i < type.size() - 1; i++)
    {
        ByteBuffer fieldName = type.fieldName(i);
        for (int j = i+1; j < type.size(); j++)
        {
            if (fieldName.equals(type.fieldName(j)))
                throw new InvalidRequestException(String.format("Duplicate field name %s in type %s",
                                                                UTF8Type.instance.getString(fieldName),
                                                                UTF8Type.instance.getString(type.name)));
        }
    }
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private UserType createType() throws InvalidRequestException
{
    List<ByteBuffer> names = new ArrayList<>(columnNames.size());
    for (ColumnIdentifier name : columnNames)
        names.add(name.bytes);

    List<AbstractType<?>> types = new ArrayList<>(columnTypes.size());
    for (CQL3Type.Raw type : columnTypes)
        types.add(type.prepare(keyspace()).getType());

    return new UserType(name.getKeyspace(), name.getUserTypeName(), names, types);
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private static void addType(UserType ut)
{
    KSMetaData ksm = Schema.instance.getKSMetaData(ut.keyspace);
    assert ksm != null;

    logger.info("Loading {}", ut);

    ksm.userTypes.addType(ut);

    if (!StorageService.instance.isClientMode())
        MigrationManager.instance.notifyCreateUserType(ut);
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private static void updateType(UserType ut)
{
    KSMetaData ksm = Schema.instance.getKSMetaData(ut.keyspace);
    assert ksm != null;

    logger.info("Updating {}", ut);

    ksm.userTypes.addType(ut);

    if (!StorageService.instance.isClientMode())
        MigrationManager.instance.notifyUpdateUserType(ut);
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
private static void dropType(UserType ut)
{
    KSMetaData ksm = Schema.instance.getKSMetaData(ut.keyspace);
    assert ksm != null;

    ksm.userTypes.removeType(ut);

    if (!StorageService.instance.isClientMode())
        MigrationManager.instance.notifyDropUserType(ut);
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public static Factory newFactory(final UserType type, final int field, final Selector.Factory factory)
{
    return new Factory()
    {
        protected String getColumnName()
        {
            return String.format("%s.%s",
                                 factory.getColumnName(),
                                 UTF8Type.instance.getString(type.fieldName(field)));
        }

        protected AbstractType<?> getReturnType()
        {
            return type.fieldType(field);
        }

        protected void addColumnMapping(SelectionColumnMapping mapping, ColumnSpecification resultsColumn)
        {
            factory.addColumnMapping(mapping, resultsColumn);
        }

        public Selector newInstance() throws InvalidRequestException
        {
            return new FieldSelector(type, field, factory.newInstance());
        }

        public boolean isAggregateSelectorFactory()
        {
            return factory.isAggregateSelectorFactory();
        }
    };
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
public void notifyUpdateUserType(UserType ut)
{
    for (MigrationListener listener : listeners)
        listener.onUpdateUserType(ut.keyspace, ut.getNameAsString());

    // FIXME: remove when we get rid of AbstractType in metadata. Doesn't really belong anywhere.
    Schema.instance.getKSMetaData(ut.keyspace).functions.udfs().forEach(f -> f.userTypeUpdated(ut.keyspace, ut.getNameAsString()));
}
 

import org.apache.cassandra.db.marshal.UserType; //导入依赖的package包/类
UserType prepare(String keyspace, Types types)
{
    List<ByteBuffer> preparedFieldNames =
        fieldNames.stream()
                  .map(ByteBufferUtil::bytes)
                  .collect(toList());

    List<AbstractType<?>> preparedFieldTypes =
        fieldTypes.stream()
                  .map(t -> t.prepareInternal(keyspace, types).getType())
                  .collect(toList());

    return new UserType(keyspace, bytes(name), preparedFieldNames, preparedFieldTypes);
}