Java CFMetaData.getColumnDefinition方法代码示例

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public Columns deserialize(DataInputPlus in, CFMetaData metadata) throws IOException
{
    int length = (int)in.readUnsignedVInt();
    BTree.Builder<ColumnDefinition> builder = BTree.builder(Comparator.naturalOrder());
    builder.auto(false);
    for (int i = 0; i < length; i++)
    {
        ByteBuffer name = ByteBufferUtil.readWithVIntLength(in);
        ColumnDefinition column = metadata.getColumnDefinition(name);
        if (column == null)
        {
            // If we don't find the definition, it could be we have data for a dropped column, and we shouldn't
            // fail deserialization because of that. So we grab a "fake" ColumnDefinition that ensure proper
            // deserialization. The column will be ignore later on anyway.
            column = metadata.getDroppedColumnDefinition(name);
            if (column == null)
                throw new RuntimeException("Unknown column " + UTF8Type.instance.getString(name) + " during deserialization");
        }
        builder.add(column);
    }
    return new Columns(builder.build());
}
 

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public SerializationHeader toHeader(CFMetaData metadata)
{
    Map<ByteBuffer, AbstractType<?>> typeMap = new HashMap<>(staticColumns.size() + regularColumns.size());
    typeMap.putAll(staticColumns);
    typeMap.putAll(regularColumns);

    PartitionColumns.Builder builder = PartitionColumns.builder();
    for (ByteBuffer name : typeMap.keySet())
    {
        ColumnDefinition column = metadata.getColumnDefinition(name);
        if (column == null)
        {
            // TODO: this imply we don't read data for a column we don't yet know about, which imply this is theoretically
            // racy with column addition. Currently, it is up to the user to not write data before the schema has propagated
            // and this is far from being the only place that has such problem in practice. This doesn't mean we shouldn't
            // improve this.

            // If we don't find the definition, it could be we have data for a dropped column, and we shouldn't
            // fail deserialization because of that. So we grab a "fake" ColumnDefinition that ensure proper
            // deserialization. The column will be ignore later on anyway.
            boolean isStatic = staticColumns.containsKey(name);
            column = metadata.getDroppedColumnDefinition(name, isStatic);
            if (column == null)
                throw new RuntimeException("Unknown column " + UTF8Type.instance.getString(name) + " during deserialization");
        }
        builder.add(column);
    }
    return new SerializationHeader(true, keyType, clusteringTypes, builder.build(), stats, typeMap);
}
 

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public ColumnSubselection deserialize(DataInputPlus in, int version, CFMetaData metadata) throws IOException
{
    ByteBuffer name = ByteBufferUtil.readWithShortLength(in);
    ColumnDefinition column = metadata.getColumnDefinition(name);
    if (column == null)
    {
        // If we don't find the definition, it could be we have data for a dropped column, and we shouldn't
        // fail deserialization because of that. So we grab a "fake" ColumnDefinition that ensure proper
        // deserialization. The column will be ignore later on anyway.
        column = metadata.getDroppedColumnDefinition(name);
        if (column == null)
            throw new RuntimeException("Unknown column " + UTF8Type.instance.getString(name) + " during deserialization");
    }

    Kind kind = Kind.values()[in.readUnsignedByte()];
    switch (kind)
    {
        case SLICE:
            CellPath from = column.cellPathSerializer().deserialize(in);
            CellPath to = column.cellPathSerializer().deserialize(in);
            return new Slice(column, from, to);
        case ELEMENT:
            CellPath elt = column.cellPathSerializer().deserialize(in);
            return new Element(column, elt);
    }
    throw new AssertionError();
}
 

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public static LegacyCellName decodeCellName(CFMetaData metadata, ByteBuffer cellname, boolean readAllAsDynamic) throws UnknownColumnException
{
    Clustering clustering = decodeClustering(metadata, cellname);

    if (metadata.isSuper())
        return decodeForSuperColumn(metadata, clustering, CompositeType.extractComponent(cellname, 1));

    if (metadata.isDense() || (metadata.isCompactTable() && readAllAsDynamic))
        return new LegacyCellName(clustering, metadata.compactValueColumn(), null);

    ByteBuffer column = metadata.isCompound() ? CompositeType.extractComponent(cellname, metadata.comparator.size()) : cellname;
    if (column == null)
    {
        // Tables for composite 2ndary indexes used to be compound but dense, but we've transformed them into regular tables
        // (non compact ones) but with no regular column (i.e. we only care about the clustering). So we'll get here
        // in that case, and what we want to return is basically a row marker.
        if (metadata.partitionColumns().isEmpty())
            return new LegacyCellName(clustering, null, null);

        // Otherwise, we shouldn't get there
        throw new IllegalArgumentException("No column name component found in cell name");
    }

    // Row marker, this is ok
    if (!column.hasRemaining())
        return new LegacyCellName(clustering, null, null);

    ColumnDefinition def = metadata.getColumnDefinition(column);
    if ((def == null) || def.isPrimaryKeyColumn())
    {
        // If it's a compact table, it means the column is in fact a "dynamic" one
        if (metadata.isCompactTable())
            return new LegacyCellName(Clustering.make(column), metadata.compactValueColumn(), null);

        if (def == null)
            throw new UnknownColumnException(metadata, column);
        else
            throw new IllegalArgumentException("Cannot add primary key column to partition update");
    }

    ByteBuffer collectionElement = metadata.isCompound() ? CompositeType.extractComponent(cellname, metadata.comparator.size() + 1) : null;

    // Note that because static compact columns are translated to static defs in the new world order, we need to force a static
    // clustering if the definition is static (as it might not be in this case).
    return new LegacyCellName(def.isStatic() ? Clustering.STATIC_CLUSTERING : clustering, def, collectionElement);
}