Java CFMetaData.isCompound方法代码示例

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public static Clustering decodeClustering(CFMetaData metadata, ByteBuffer value)
{
    int csize = metadata.comparator.size();
    if (csize == 0)
        return Clustering.EMPTY;

    if (metadata.isCompound() && CompositeType.isStaticName(value))
        return Clustering.STATIC_CLUSTERING;

    List<ByteBuffer> components = metadata.isCompound()
        ? CompositeType.splitName(value)
        : Collections.singletonList(value);

    return Clustering.make(components.subList(0, Math.min(csize, components.size())).toArray(new ByteBuffer[csize]));
}
 

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public void serialize(DataOutputPlus out, CFMetaData metadata) throws IOException
{
    out.writeInt(size);
    if (size == 0)
        return;

    if (metadata.isCompound())
        serializeCompound(out, metadata.isDense());
    else
        serializeSimple(out);
}
 

import org.apache.cassandra.config.CFMetaData; //导入方法依赖的package包/类
public long serializedSize(CFMetaData metadata)
{
    long size = 0;
    size += TypeSizes.sizeof(this.size);

    if (this.size == 0)
        return size;

    if (metadata.isCompound())
        return size + serializedSizeCompound(metadata.isDense());
    else
        return size + serializedSizeSimple();
}
 

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