Java MapType类代码示例

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());
    }
}