import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof SetType))
    {
        // We've parsed empty maps as a set literal to break the ambiguity so
        // handle that case now
        if ((receiver.type instanceof MapType) && elements.isEmpty())
            return;

        throw new InvalidRequestException(String.format("Invalid set literal for %s of type %s", receiver.name, receiver.type.asCQL3Type()));
    }

    ColumnSpecification valueSpec = Sets.valueSpecOf(receiver);
    for (Term.Raw rt : elements)
    {
        if (!rt.isAssignableTo(keyspace, valueSpec))
            throw new InvalidRequestException(String.format("Invalid set literal for %s: value %s is not of type %s", receiver.name, rt, valueSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public Term prepare(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    validateAssignableTo(keyspace, receiver);

    ColumnSpecification keySpec = Maps.keySpecOf(receiver);
    ColumnSpecification valueSpec = Maps.valueSpecOf(receiver);
    Map<Term, Term> values = new HashMap<Term, Term>(entries.size());
    boolean allTerminal = true;
    for (Pair<Term.Raw, Term.Raw> entry : entries)
    {
        Term k = entry.left.prepare(keyspace, keySpec);
        Term v = entry.right.prepare(keyspace, valueSpec);

        if (k.containsBindMarker() || v.containsBindMarker())
            throw new InvalidRequestException(String.format("Invalid map literal for %s: bind variables are not supported inside collection literals", receiver.name));

        if (k instanceof Term.NonTerminal || v instanceof Term.NonTerminal)
            allTerminal = false;

        values.put(k, v);
    }
    DelayedValue value = new DelayedValue(((MapType)receiver.type).getKeysType(), values);
    return allTerminal ? value.bind(QueryOptions.DEFAULT) : value;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public static Value fromSerialized(ByteBuffer value, MapType type, int version) throws InvalidRequestException
{
    try
    {
        // Collections have this small hack that validate cannot be called on a serialized object,
        // but compose does the validation (so we're fine).
        Map<?, ?> m = (Map<?, ?>)type.getSerializer().deserializeForNativeProtocol(value, version);
        Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<ByteBuffer, ByteBuffer>(m.size());
        for (Map.Entry<?, ?> entry : m.entrySet())
            map.put(type.getKeysType().decompose(entry.getKey()), type.getValuesType().decompose(entry.getValue()));
        return new Value(map);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException(e.getMessage());
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public boolean equals(MapType mt, Value v)
{
    if (map.size() != v.map.size())
        return false;

    // We use the fact that we know the maps iteration will both be in comparator order
    Iterator<Map.Entry<ByteBuffer, ByteBuffer>> thisIter = map.entrySet().iterator();
    Iterator<Map.Entry<ByteBuffer, ByteBuffer>> thatIter = v.map.entrySet().iterator();
    while (thisIter.hasNext())
    {
        Map.Entry<ByteBuffer, ByteBuffer> thisEntry = thisIter.next();
        Map.Entry<ByteBuffer, ByteBuffer> thatEntry = thatIter.next();
        if (mt.getKeysType().compare(thisEntry.getKey(), thatEntry.getKey()) != 0 || mt.getValuesType().compare(thisEntry.getValue(), thatEntry.getValue()) != 0)
            return false;
    }

    return true;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
private void validateAssignableTo(ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof SetType))
    {
        // We've parsed empty maps as a set literal to break the ambiguity so
        // handle that case now
        if (receiver.type instanceof MapType && elements.isEmpty())
            return;

        throw new InvalidRequestException(String.format("Invalid set literal for %s of type %s", receiver, receiver.type.asCQL3Type()));
    }

    ColumnSpecification valueSpec = Sets.valueSpecOf(receiver);
    for (Term.Raw rt : elements)
    {
        if (!rt.isAssignableTo(valueSpec))
            throw new InvalidRequestException(String.format("Invalid set literal for %s: value %s is not of type %s", receiver, rt, valueSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public Term prepare(ColumnSpecification receiver) throws InvalidRequestException
{
    validateAssignableTo(receiver);

    ColumnSpecification keySpec = Maps.keySpecOf(receiver);
    ColumnSpecification valueSpec = Maps.valueSpecOf(receiver);
    Map<Term, Term> values = new HashMap<Term, Term>(entries.size());
    boolean allTerminal = true;
    for (Pair<Term.Raw, Term.Raw> entry : entries)
    {
        Term k = entry.left.prepare(keySpec);
        Term v = entry.right.prepare(valueSpec);

        if (k.containsBindMarker() || v.containsBindMarker())
            throw new InvalidRequestException(String.format("Invalid map literal for %s: bind variables are not supported inside collection literals", receiver));

        if (k instanceof Term.NonTerminal || v instanceof Term.NonTerminal)
            allTerminal = false;

        values.put(k, v);
    }
    DelayedValue value = new DelayedValue(((MapType)receiver.type).keys, values);
    return allTerminal ? value.bind(Collections.<ByteBuffer>emptyList()) : value;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public static Value fromSerialized(ByteBuffer value, MapType type) throws InvalidRequestException
{
    try
    {
        // Collections have this small hack that validate cannot be called on a serialized object,
        // but compose does the validation (so we're fine).
        Map<?, ?> m = (Map<?, ?>)type.compose(value);
        Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<ByteBuffer, ByteBuffer>(m.size());
        for (Map.Entry<?, ?> entry : m.entrySet())
            map.put(type.keys.decompose(entry.getKey()), type.values.decompose(entry.getValue()));
        return new Value(map);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException(e.getMessage());
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public Term prepare(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    validateAssignableTo(keyspace, receiver);

    ColumnSpecification keySpec = Maps.keySpecOf(receiver);
    ColumnSpecification valueSpec = Maps.valueSpecOf(receiver);
    Map<Term, Term> values = new HashMap<>(entries.size());
    boolean allTerminal = true;
    for (Pair<Term.Raw, Term.Raw> entry : entries)
    {
        Term k = entry.left.prepare(keyspace, keySpec);
        Term v = entry.right.prepare(keyspace, valueSpec);

        if (k.containsBindMarker() || v.containsBindMarker())
            throw new InvalidRequestException(String.format("Invalid map literal for %s: bind variables are not supported inside collection literals", receiver.name));

        if (k instanceof Term.NonTerminal || v instanceof Term.NonTerminal)
            allTerminal = false;

        values.put(k, v);
    }
    DelayedValue value = new DelayedValue(((MapType)receiver.type).getKeysType(), values);
    return allTerminal ? value.bind(QueryOptions.DEFAULT) : value;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public AssignmentTestable.TestResult testAssignment(String keyspace, ColumnSpecification receiver)
{
    if (!(receiver.type instanceof MapType))
        return AssignmentTestable.TestResult.NOT_ASSIGNABLE;

    // If there is no elements, we can't say it's an exact match (an empty map if fundamentally polymorphic).
    if (entries.isEmpty())
        return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;

    ColumnSpecification keySpec = Maps.keySpecOf(receiver);
    ColumnSpecification valueSpec = Maps.valueSpecOf(receiver);
    // It's an exact match if all are exact match, but is not assignable as soon as any is non assignable.
    AssignmentTestable.TestResult res = AssignmentTestable.TestResult.EXACT_MATCH;
    for (Pair<Term.Raw, Term.Raw> entry : entries)
    {
        AssignmentTestable.TestResult t1 = entry.left.testAssignment(keyspace, keySpec);
        AssignmentTestable.TestResult t2 = entry.right.testAssignment(keyspace, valueSpec);
        if (t1 == AssignmentTestable.TestResult.NOT_ASSIGNABLE || t2 == AssignmentTestable.TestResult.NOT_ASSIGNABLE)
            return AssignmentTestable.TestResult.NOT_ASSIGNABLE;
        if (t1 != AssignmentTestable.TestResult.EXACT_MATCH || t2 != AssignmentTestable.TestResult.EXACT_MATCH)
            res = AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;
    }
    return res;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public static Value fromSerialized(ByteBuffer value, MapType type, int version) throws InvalidRequestException
{
    try
    {
        // Collections have this small hack that validate cannot be called on a serialized object,
        // but compose does the validation (so we're fine).
        Map<?, ?> m = type.getSerializer().deserializeForNativeProtocol(value, version);
        Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<>(m.size());
        for (Map.Entry<?, ?> entry : m.entrySet())
            map.put(type.getKeysType().decompose(entry.getKey()), type.getValuesType().decompose(entry.getValue()));
        return new Value(map);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException(e.getMessage());
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
@BeforeClass
public static void defineSchema() throws ConfigurationException
{
    CFMetaData cfMetadata = CFMetaData.Builder.create(KEYSPACE1, CF_STANDARD)
                                              .addPartitionKey("key", BytesType.instance)
                                              .addClusteringColumn("col1", AsciiType.instance)
                                              .addRegularColumn("c1", AsciiType.instance)
                                              .addRegularColumn("c2", AsciiType.instance)
                                              .addRegularColumn("one", AsciiType.instance)
                                              .addRegularColumn("two", AsciiType.instance)
                                              .build();

    CFMetaData cfMetaData2 = CFMetaData.Builder.create(KEYSPACE1, CF_COLLECTION)
                                               .addPartitionKey("k", ByteType.instance)
                                               .addRegularColumn("m", MapType.getInstance(IntegerType.instance, IntegerType.instance, true))
                                               .build();
    SchemaLoader.prepareServer();
    SchemaLoader.createKeyspace(KEYSPACE1,
                                KeyspaceParams.simple(1),
                                cfMetadata, cfMetaData2);
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
private void validateAssignableTo(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    if (!(receiver.type instanceof SetType))
    {
        // We've parsed empty maps as a set literal to break the ambiguity so
        // handle that case now
        if (receiver.type instanceof MapType && elements.isEmpty())
            return;

        throw new InvalidRequestException(String.format("Invalid set literal for %s of type %s", receiver.name, receiver.type.asCQL3Type()));
    }

    ColumnSpecification valueSpec = Sets.valueSpecOf(receiver);
    for (Term.Raw rt : elements)
    {
        if (!rt.testAssignment(keyspace, valueSpec).isAssignable())
            throw new InvalidRequestException(String.format("Invalid set literal for %s: value %s is not of type %s", receiver.name, rt, valueSpec.type.asCQL3Type()));
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public AssignmentTestable.TestResult testAssignment(String keyspace, ColumnSpecification receiver)
{
    if (!(receiver.type instanceof SetType))
    {
        // We've parsed empty maps as a set literal to break the ambiguity so handle that case now
        if (receiver.type instanceof MapType && elements.isEmpty())
            return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;

        return AssignmentTestable.TestResult.NOT_ASSIGNABLE;
    }

    // If there is no elements, we can't say it's an exact match (an empty set if fundamentally polymorphic).
    if (elements.isEmpty())
        return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;

    ColumnSpecification valueSpec = Sets.valueSpecOf(receiver);
    return AssignmentTestable.TestResult.testAll(keyspace, valueSpec, elements);
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public Term prepare(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
    validateAssignableTo(keyspace, receiver);

    ColumnSpecification keySpec = Maps.keySpecOf(receiver);
    ColumnSpecification valueSpec = Maps.valueSpecOf(receiver);
    Map<Term, Term> values = new HashMap<Term, Term>(entries.size());
    boolean allTerminal = true;
    for (Pair<Term.Raw, Term.Raw> entry : entries)
    {
        Term k = entry.left.prepare(keyspace, keySpec);
        Term v = entry.right.prepare(keyspace, valueSpec);

        if (k.containsBindMarker() || v.containsBindMarker())
            throw new InvalidRequestException(String.format("Invalid map literal for %s: bind variables are not supported inside collection literals", receiver.name));

        if (k instanceof Term.NonTerminal || v instanceof Term.NonTerminal)
            allTerminal = false;

        values.put(k, v);
    }
    DelayedValue value = new DelayedValue(((MapType)receiver.type).keys, values);
    return allTerminal ? value.bind(QueryOptions.DEFAULT) : value;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public static Value fromSerialized(ByteBuffer value, MapType type, int version) throws InvalidRequestException
{
    try
    {
        // Collections have this small hack that validate cannot be called on a serialized object,
        // but compose does the validation (so we're fine).
        Map<?, ?> m = (Map<?, ?>)type.getSerializer().deserializeForNativeProtocol(value, version);
        Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<ByteBuffer, ByteBuffer>(m.size());
        for (Map.Entry<?, ?> entry : m.entrySet())
            map.put(type.keys.decompose(entry.getKey()), type.values.decompose(entry.getValue()));
        return new Value(map);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException(e.getMessage());
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public boolean equals(MapType mt, Value v)
{
    if (map.size() != v.map.size())
        return false;

    // We use the fact that we know the maps iteration will both be in comparator order
    Iterator<Map.Entry<ByteBuffer, ByteBuffer>> thisIter = map.entrySet().iterator();
    Iterator<Map.Entry<ByteBuffer, ByteBuffer>> thatIter = v.map.entrySet().iterator();
    while (thisIter.hasNext())
    {
        Map.Entry<ByteBuffer, ByteBuffer> thisEntry = thisIter.next();
        Map.Entry<ByteBuffer, ByteBuffer> thatEntry = thatIter.next();
        if (mt.keys.compare(thisEntry.getKey(), thatEntry.getKey()) != 0 || mt.values.compare(thisEntry.getValue(), thatEntry.getValue()) != 0)
            return false;
    }

    return true;
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public void testDataTypeMapInstantiation() {
    DataType type = DataType.map(DataType.text(), DataType.bigint());

    CellValidator cv = cellValidator(type);
    assertNotNull(cv);
    assertEquals(cv.getValidatorClassName(), MapType.class.getName());
    assertNotNull(cv.getValidatorTypes());
    assertEquals(cv.validatorKind(), Kind.MAP);
    assertEquals(cv.getValidatorTypes().size(), 2);
    Iterator<String> types = cv.getValidatorTypes().iterator();
    assertEquals(types.next(), "text");
    assertEquals(types.next(), "bigint");
    assertEquals(DataType.Name.MAP, cv.getCqlTypeName());

    try {
        Collection<String> ctypes = cv.getValidatorTypes();
        ctypes.add("test");
        fail("Validator types collection must be inmutable");
    } catch (Exception ex) {
        // ok
    }

    //        assertNotNull(cv.getAbstractType());
    //        assertEquals(cv.getAbstractType(), MapType.getInstance(UTF8Type.instance, LongType.instance));
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public void testValidatorClassToKind() {
    assertEquals(Kind.validatorClassToKind(null), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(TimeUUIDType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(UTF8Type.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(Int32Type.class), Kind.NOT_A_COLLECTION);

    assertEquals(Kind.validatorClassToKind(BooleanType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(TimestampType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(DecimalType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(LongType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(DoubleType.class), Kind.NOT_A_COLLECTION);

    assertEquals(Kind.validatorClassToKind(FloatType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(InetAddressType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(IntegerType.class), Kind.NOT_A_COLLECTION);
    assertEquals(Kind.validatorClassToKind(UUIDType.class), Kind.NOT_A_COLLECTION);

    assertEquals(Kind.validatorClassToKind(SetType.class), Kind.SET);
    assertEquals(Kind.validatorClassToKind(ListType.class), Kind.LIST);
    assertEquals(Kind.validatorClassToKind(MapType.class), Kind.MAP);
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
public static Value fromSerialized(ByteBuffer value, MapType type) throws InvalidRequestException
{
    try
    {
        // Collections have this small hack that validate cannot be called on a serialized object,
        // but compose does the validation (so we're fine).
        Map<?, ?> m = type.compose(value);
        Map<ByteBuffer, ByteBuffer> map = new LinkedHashMap<ByteBuffer, ByteBuffer>(m.size());
        for (Map.Entry<?, ?> entry : m.entrySet())
            map.put(type.keys.decompose(entry.getKey()), type.values.decompose(entry.getValue()));
        return new Value(map);
    }
    catch (MarshalException e)
    {
        throw new InvalidRequestException(e.getMessage());
    }
}
 

import org.apache.cassandra.db.marshal.MapType; //导入依赖的package包/类
/**
 * Returns {@code true} if the specified Cassandra type/marshaller is supported, {@code false} otherwise.
 *
 * @param type A Cassandra type/marshaller.
 * @return {@code true} if the specified Cassandra type/marshaller is supported, {@code false} otherwise.
 */
public boolean supports(final AbstractType<?> type) {
    AbstractType<?> checkedType = type;
    if (type.isCollection()) {
        if (type instanceof MapType<?, ?>) {
            checkedType = ((MapType<?, ?>) type).getValuesType();
        } else if (type instanceof ListType<?>) {
            checkedType = ((ListType<?>) type).getElementsType();
        } else if (type instanceof SetType) {
            checkedType = ((SetType<?>) type).getElementsType();
        }
    }

    if (type instanceof ReversedType) {
        ReversedType reversedType = (ReversedType) type;
        checkedType = reversedType.baseType;
    }

    for (AbstractType<?> n : supportedTypes) {
        if (checkedType.getClass() == n.getClass()) {
            return true;
        }
    }
    return false;
}