Java ClusteringComparator类代码示例

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
public ClusteringComparator getKeyValidatorAsClusteringComparator()
{
    boolean isCompound = keyValidator instanceof CompositeType;
    List<AbstractType<?>> types = isCompound
            ? ((CompositeType) keyValidator).types
            : Collections.<AbstractType<?>>singletonList(keyValidator);
    return new ClusteringComparator(types);
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
private int compare(List<ByteBuffer> values1, List<ByteBuffer> values2)
{
    ClusteringComparator comparator = metadata.comparator;
    for (int i = 0; i < Math.min(values1.size(), values2.size()); i++)
    {
        int cmp = comparator.subtype(i).compare(values1.get(i), values2.get(i));
        if (cmp != 0)
            return cmp;
    }
    return 0;
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
boolean isValid(ClusteringComparator comparator, String search, PartitionRangeReadCommand command) {
	if (search.equals(this.search)) {
		DataRange dataRange = command.dataRange();
		return validKey(dataRange) && validPrefix(comparator, dataRange);
	}
	return false;
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
private boolean validPrefix(ClusteringComparator comparator, DataRange dataRange) {

		// Discard start prefix
		Optional<ClusteringPrefix> start = KeyMapper.startClusteringPrefix(dataRange);
		if (start.isPresent() && startPrefix.isPresent() && comparator.compare(startPrefix.get(), start.get()) > 0) {
			return false;
		}

		// Discard null clusterings
		if (start.isPresent() != currentClustering.isPresent()) {
			return false;
		}

		// Discard clustering
		if (start.isPresent()
				&& comparator.compare(new Clustering(start.get().getRawValues()), currentClustering.get()) != 0) {
			return false;
		}

		// Discard stop prefix
		Optional<ClusteringPrefix> stop = KeyMapper.stopClusteringPrefix(dataRange);
		if (stop.isPresent() && stopPrefix.isPresent() && comparator.compare(stopPrefix.get(), stop.get()) != 0) {
			return false;
		}

		return true;
	}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
private TestableCSW(File file, File offsetsFile) throws IOException
{
    this(file, offsetsFile, new CompressedSequentialWriter(file,
                                                           offsetsFile.getPath(),
                                                           CompressionParams.lz4(BUFFER_SIZE),
                                                           new MetadataCollector(new ClusteringComparator(UTF8Type.instance))));
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
public AbstractPrimaryKeyRestrictions(ClusteringComparator comparator)
{
    this.comparator = comparator;
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
@Test
public void test6791() throws IOException, ConfigurationException
{
    File f = File.createTempFile("compressed6791_", "3");
    String filename = f.getAbsolutePath();
    try(ChannelProxy channel = new ChannelProxy(f))
    {

        MetadataCollector sstableMetadataCollector = new MetadataCollector(new ClusteringComparator(BytesType.instance));
        try(CompressedSequentialWriter writer = new CompressedSequentialWriter(f, filename + ".metadata", CompressionParams.snappy(32), sstableMetadataCollector))
        {

            for (int i = 0; i < 20; i++)
                writer.write("x".getBytes());

            DataPosition mark = writer.mark();
            // write enough garbage to create new chunks:
            for (int i = 0; i < 40; ++i)
                writer.write("y".getBytes());

            writer.resetAndTruncate(mark);

            for (int i = 0; i < 20; i++)
                writer.write("x".getBytes());
            writer.finish();
        }

        try(RandomAccessReader reader = new CompressedRandomAccessReader.Builder(channel,
                                                                                 new CompressionMetadata(filename + ".metadata", f.length(), ChecksumType.CRC32))
                                        .build())
        {
            String res = reader.readLine();
            assertEquals(res, "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
            assertEquals(40, res.length());
        }
    }
    finally
    {
        if (f.exists())
            assertTrue(f.delete());
        File metadata = new File(filename+ ".metadata");
        if (metadata.exists())
            metadata.delete();
    }
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
@Test
public void testMapForCompressionMetadata() throws Exception
{
    int OLD_MAX_SEGMENT_SIZE = MmappedRegions.MAX_SEGMENT_SIZE;
    MmappedRegions.MAX_SEGMENT_SIZE = 1024;

    ByteBuffer buffer = allocateBuffer(128 * 1024);
    File f = File.createTempFile("testMapForCompressionMetadata", "1");
    f.deleteOnExit();

    File cf = File.createTempFile(f.getName() + ".metadata", "1");
    cf.deleteOnExit();

    MetadataCollector sstableMetadataCollector = new MetadataCollector(new ClusteringComparator(BytesType.instance));
    try(SequentialWriter writer = new CompressedSequentialWriter(f,
                                                                 cf.getAbsolutePath(),
                                                                 CompressionParams.snappy(),
                                                                 sstableMetadataCollector))
    {
        writer.write(buffer);
        writer.finish();
    }

    CompressionMetadata metadata = new CompressionMetadata(cf.getAbsolutePath(), f.length(), ChecksumType.CRC32);
    try(ChannelProxy channel = new ChannelProxy(f);
        MmappedRegions regions = MmappedRegions.map(channel, metadata))
    {

        assertFalse(regions.isEmpty());
        int i = 0;
        while(i < buffer.capacity())
        {
            CompressionMetadata.Chunk chunk = metadata.chunkFor(i);

            MmappedRegions.Region region = regions.floor(chunk.offset);
            assertNotNull(region);

            ByteBuffer compressedChunk = region.buffer.duplicate();
            assertNotNull(compressedChunk);
            assertEquals(chunk.length + 4, compressedChunk.capacity());

            assertEquals(chunk.offset, region.bottom());
            assertEquals(chunk.offset + chunk.length + 4, region.top());

            i += metadata.chunkLength();
        }
    }
    finally
    {
        MmappedRegions.MAX_SEGMENT_SIZE = OLD_MAX_SEGMENT_SIZE;
        metadata.close();
    }
}
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
/**
 * Returns a filter for continuing the paging of this filter given the last returned clustering prefix.
 *
 * @param comparator the comparator for the table this is a filter for.
 * @param lastReturned the last clustering that was returned for the query we are paging for. The
 * resulting filter will be such that results coming after {@code lastReturned} are returned
 * (where coming after means "greater than" if the filter is not reversed, "lesser than" otherwise;
 * futher, whether the comparison is strict or not depends on {@code inclusive}).
 * @param inclusive whether or not we want to include the {@code lastReturned} in the newly returned
 * page of results.
 *
 * @return a new filter that selects results coming after {@code lastReturned}.
 */
public ClusteringIndexFilter forPaging(ClusteringComparator comparator, Clustering lastReturned, boolean inclusive);
 

import org.apache.cassandra.db.ClusteringComparator; //导入依赖的package包/类
/**
 * Returns the clustering key comparator.
 *
 * @return the comparator
 */
public ClusteringComparator clusteringComparator() {
	return clusteringComparator;
}