Java CompositeType.getInstance方法代码示例

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
protected Pair<ByteBuffer, SortedMap<ByteBuffer, Cell>> computeNext()
{
    maybeInit();
    if (rows == null)
        return endOfData();

    totalRead++;
    KeySlice ks = rows.get(i++);
    AbstractType<?> comp = isSuper ? CompositeType.getInstance(comparator, subComparator) : comparator;
    SortedMap<ByteBuffer, Cell> map = new TreeMap<ByteBuffer, Cell>(comp);
    for (ColumnOrSuperColumn cosc : ks.columns)
    {
        List<Cell> cells = unthriftify(cosc);
        for (Cell cell : cells)
            map.put(cell.name().toByteBuffer(), cell);
    }
    return Pair.create(ks.key, map);
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
@BeforeClass
public static void defineSchema() throws ConfigurationException
{
    SchemaLoader.prepareServer();
    AbstractType<?> compositeMaxMin = CompositeType.getInstance(Arrays.asList(new AbstractType<?>[]{BytesType.instance, IntegerType.instance}));
    SchemaLoader.createKeyspace(KEYSPACE1,
                                SimpleStrategy.class,
                                KSMetaData.optsWithRF(1),
                                SchemaLoader.standardCFMD(KEYSPACE1, CF_STANDARD1),
                                SchemaLoader.standardCFMD(KEYSPACE1, CF_STANDARD2),
                                SchemaLoader.standardCFMD(KEYSPACE1, CF_STANDARDLONG),
                                CFMetaData.denseCFMetaData(KEYSPACE1, CF_STANDARDCOMPOSITE2, compositeMaxMin));
    SchemaLoader.createKeyspace(KEYSPACE2,
                                SimpleStrategy.class,
                                KSMetaData.optsWithRF(1),
                                SchemaLoader.standardCFMD(KEYSPACE2, CF_STANDARD3));
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
/**
 * Constructor specifying the partition and clustering key mappers.
 *
 * @param metadata
 *            the indexed table metadata
 */
public KeyMapper(CFMetaData metadata) {
	this.metadata = metadata;
	clusteringComparator = metadata.comparator;
	clusteringType = CompositeType.getInstance(clusteringComparator.subtypes());
	type = CompositeType.getInstance(LongType.instance, metadata.getKeyValidator(), clusteringType);
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
public AbstractType<?> asAbstractType()
{
    return CompositeType.getInstance(types);
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
public AbstractType<?> asAbstractType()
{
    return CompositeType.getInstance(fullType.types);
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
@Test
public void testLimitSSTablesComposites()
{
    /*
    creates 10 sstables, composite columns like this:
    ---------------------
    k   |a0:0|a1:1|..|a9:9
    ---------------------
    ---------------------
    k   |a0:10|a1:11|..|a9:19
    ---------------------
    ...
    ---------------------
    k   |a0:90|a1:91|..|a9:99
    ---------------------
    then we slice out col1 = a5 and col2 > 85 -> which should let us just check 2 sstables and get 2 columns
     */
    Keyspace keyspace = Keyspace.open("Keyspace1");

    ColumnFamilyStore cfs = keyspace.getColumnFamilyStore("StandardComposite2");
    cfs.disableAutoCompaction();

    CompositeType ct = CompositeType.getInstance(BytesType.instance, IntegerType.instance);
    DecoratedKey key = Util.dk("k");
    for (int j = 0; j < 10; j++)
    {
        for (int i = 0; i < 10; i++)
        {
            RowMutation rm = new RowMutation("Keyspace1", key.key);
            ByteBuffer colName = ct.builder().add(ByteBufferUtil.bytes("a" + i)).add(ByteBufferUtil.bytes(j*10 + i)).build();
            rm.add("StandardComposite2", colName, ByteBufferUtil.EMPTY_BYTE_BUFFER, 0);
            rm.apply();
        }
        cfs.forceBlockingFlush();
    }
    ByteBuffer start = ct.builder().add(ByteBufferUtil.bytes("a5")).add(ByteBufferUtil.bytes(85)).build();
    ByteBuffer finish = ct.builder().add(ByteBufferUtil.bytes("a5")).buildAsEndOfRange();
    cfs.metric.sstablesPerReadHistogram.clear();
    ColumnFamily cf = cfs.getColumnFamily(key, start, finish, false, 1000, System.currentTimeMillis());
    int colCount = 0;
    for (Column c : cf)
        colCount++;
    assertEquals(2, colCount);
    assertEquals(2, cfs.metric.sstablesPerReadHistogram.max(), 0.1);
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
public AbstractType<?> getIndexedValueType(ColumnDefinition indexedColumn)
{
    CollectionType colType = (CollectionType)indexedColumn.type;
    return CompositeType.getInstance(colType.nameComparator(), colType.valueComparator());
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
private static AbstractType<?> makeRawAbstractType(AbstractType<?> comparator, AbstractType<?> subComparator)
{
    return subComparator == null ? comparator : CompositeType.getInstance(Arrays.asList(comparator, subComparator));
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
private static CFMetaData compositeCFMD(String ksName, String cfName, AbstractType<?>... types) {
    return new CFMetaData(ksName, cfName, ColumnFamilyType.Standard,
            CompositeType.getInstance(Arrays.asList(types)), null);
}
 

import org.apache.cassandra.db.marshal.CompositeType; //导入方法依赖的package包/类
/**
 * Returns a new {@link FullKeyMapper} using the specified column family metadata.
 *
 * @param partitionKeyMapper  A {@link PartitionKeyMapper}.
 * @param clusteringKeyMapper A {@link ClusteringKeyMapper}.
 */
private FullKeyMapper(PartitionKeyMapper partitionKeyMapper, ClusteringKeyMapper clusteringKeyMapper) {
    AbstractType<?> partitionKeyType = partitionKeyMapper.getType();
    AbstractType<?> clusteringKeyType = clusteringKeyMapper.getType().asAbstractType();
    type = CompositeType.getInstance(partitionKeyType, clusteringKeyType);
}