Java PartitionPosition类代码示例

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
public int binarySearch(PartitionPosition key)
{
    // We will be comparing non-native Keys, so use a buffer with appropriate byte order
    ByteBuffer hollow = MemoryUtil.getHollowDirectByteBuffer().order(ByteOrder.BIG_ENDIAN);
    int low = 0, mid = offsetCount, high = mid - 1, result = -1;
    while (low <= high)
    {
        mid = (low + high) >> 1;
        fillTemporaryKey(mid, hollow);
        result = -DecoratedKey.compareTo(partitioner, hollow, key);
        if (result > 0)
        {
            low = mid + 1;
        }
        else if (result == 0)
        {
            return mid;
        }
        else
        {
            high = mid - 1;
        }
    }

    return -mid - (result < 0 ? 1 : 2);
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
@Test
public void testNormalizeComplex()
{
    List<Range<PartitionPosition>> input, expected;

    input = asList(range("8", "2"), range("7", "9"), range("4", "5"));
    expected = asList(range("", "2"), range("4", "5"), range("7", ""));
    assertNormalize(input, expected);

    input = asList(range("5", "9"), range("2", "5"));
    expected = asList(range("2", "9"));
    assertNormalize(input, expected);

    input = asList(range ("", "1"), range("9", "2"), range("4", "5"), range("", ""));
    expected = asList(range("", ""));
    assertNormalize(input, expected);

    input = asList(range ("", "1"), range("1", "4"), range("4", "5"), range("5", ""));
    expected = asList(range("", ""));
    assertNormalize(input, expected);
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
@Test
public void testSSTablesInBounds()
{
    ColumnFamilyStore cfs = MockSchema.newCFS();
    View initialView = fakeView(0, 5, cfs);
    for (int i = 0 ; i < 5 ; i++)
    {
        for (int j = i ; j < 5 ; j++)
        {
            PartitionPosition min = MockSchema.readerBounds(i);
            PartitionPosition max = MockSchema.readerBounds(j);
            for (boolean minInc : new boolean[] { true })//, false} )
            {
                for (boolean maxInc : new boolean[] { true })//, false} )
                {
                    if (i == j && !(minInc && maxInc))
                        continue;

                    AbstractBounds<PartitionPosition> bounds = AbstractBounds.bounds(min, minInc, max, maxInc);
                    List<SSTableReader> r = ImmutableList.copyOf(initialView.liveSSTablesInBounds(bounds.left, bounds.right));
                    Assert.assertEquals(String.format("%d(%s) %d(%s)", i, minInc, j, maxInc), j - i + (minInc ? 0 : -1) + (maxInc ? 1 : 0), r.size());
                }
            }
        }
    }
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
public int compareTo(PartitionPosition pos)
{
    if (this == pos)
        return 0;

    int cmp = getToken().compareTo(pos.getToken());
    if (cmp != 0)
        return cmp;

    if (isMinimumBound)
        return ((pos instanceof KeyBound) && ((KeyBound)pos).isMinimumBound) ? 0 : -1;
    else
        return ((pos instanceof KeyBound) && !((KeyBound)pos).isMinimumBound) ? 0 : 1;
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
public static List<Interval<PartitionPosition, SSTableReader>> buildIntervals(Iterable<SSTableReader> sstables)
{
    List<Interval<PartitionPosition, SSTableReader>> intervals = new ArrayList<>(Iterables.size(sstables));
    for (SSTableReader sstable : sstables)
        intervals.add(Interval.<PartitionPosition, SSTableReader>create(sstable.first, sstable.last, sstable));
    return intervals;
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
/**
 * Gets the position in the index file to start scanning to find the given key (at most indexInterval keys away,
 * modulo downsampling of the index summary). Always returns a {@code value >= 0}
 */
public long getIndexScanPosition(PartitionPosition key)
{
    if (openReason == OpenReason.MOVED_START && key.compareTo(first) < 0)
        key = first;

    return getIndexScanPositionFromBinarySearchResult(indexSummary.binarySearch(key), indexSummary);
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
/**
 * Finds and returns the first key beyond a given token in this SSTable or null if no such key exists.
 */
public DecoratedKey firstKeyBeyond(PartitionPosition token)
{
    if (token.compareTo(first) < 0)
        return first;

    long sampledPosition = getIndexScanPosition(token);

    if (ifile == null)
        return null;

    String path = null;
    try (FileDataInput in = ifile.createReader(sampledPosition))
    {
        path = in.getPath();
        while (!in.isEOF())
        {
            ByteBuffer indexKey = ByteBufferUtil.readWithShortLength(in);
            DecoratedKey indexDecoratedKey = decorateKey(indexKey);
            if (indexDecoratedKey.compareTo(token) > 0)
                return indexDecoratedKey;

            RowIndexEntry.Serializer.skip(in, descriptor.version);
        }
    }
    catch (IOException e)
    {
        markSuspect();
        throw new CorruptSSTableException(e, path);
    }

    return null;
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
private boolean validKey(DataRange dataRange) {
	PartitionPosition start = dataRange.startKey();
	if (currentPosition.compareTo(start) == 0 && startPosition.compareTo(start) <= 0) {
		PartitionPosition stop = dataRange.stopKey();
		return stopPosition.compareTo(stop) == 0;
	}
	return false;
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
/**
 * Returns the sstables that have any partition between {@code left} and {@code right}, when both bounds are taken inclusively.
 * The interval formed by {@code left} and {@code right} shouldn't wrap.
 */
public Iterable<SSTableReader> liveSSTablesInBounds(PartitionPosition left, PartitionPosition right)
{
    assert !AbstractBounds.strictlyWrapsAround(left, right);

    if (intervalTree.isEmpty())
        return Collections.emptyList();

    PartitionPosition stopInTree = right.isMinimum() ? intervalTree.max() : right;
    return intervalTree.search(Interval.create(left, stopInTree));
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
public static List<SSTableReader> sstablesInBounds(PartitionPosition left, PartitionPosition right, SSTableIntervalTree intervalTree)
{
    assert !AbstractBounds.strictlyWrapsAround(left, right);

    if (intervalTree.isEmpty())
        return Collections.emptyList();

    PartitionPosition stopInTree = right.isMinimum() ? intervalTree.max() : right;
    return intervalTree.search(Interval.create(left, stopInTree));
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
/**
 * @return a ViewFragment containing the sstables and memtables that may need to be merged
 * for rows within @param rowBounds, inclusive, according to the interval tree.
 */
public static Function<View, Iterable<SSTableReader>> selectLive(AbstractBounds<PartitionPosition> rowBounds)
{
    // Note that View.sstablesInBounds always includes it's bound while rowBounds may not. This is ok however
    // because the fact we restrict the sstables returned by this function is an optimization in the first
    // place and the returned sstables will (almost) never cover *exactly* rowBounds anyway. It's also
    // *very* unlikely that a sstable is included *just* because we consider one of the bound inclusively
    // instead of exclusively, so the performance impact is negligible in practice.
    return (view) -> view.liveSSTablesInBounds(rowBounds.left, rowBounds.right);
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
LeveledManifest(ColumnFamilyStore cfs, int maxSSTableSizeInMB, SizeTieredCompactionStrategyOptions options)
{
    this.cfs = cfs;
    this.maxSSTableSizeInBytes = maxSSTableSizeInMB * 1024L * 1024L;
    this.options = options;

    generations = new List[MAX_LEVEL_COUNT];
    lastCompactedKeys = new PartitionPosition[MAX_LEVEL_COUNT];
    for (int i = 0; i < generations.length; i++)
    {
        generations[i] = new ArrayList<>();
        lastCompactedKeys[i] = cfs.getPartitioner().getMinimumToken().minKeyBound();
    }
    compactionCounter = new int[MAX_LEVEL_COUNT];
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
@Test
public void testNormalizeNoop()
{
    List<Range<PartitionPosition>> l;

    l = asList(range("1", "3"), range("4", "5"));
    assertNormalize(l, l);
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
@Test
public void testNormalizeSimpleOverlap()
{
    List<Range<PartitionPosition>> input, expected;

    input = asList(range("1", "4"), range("3", "5"));
    expected = asList(range("1", "5"));
    assertNormalize(input, expected);

    input = asList(range("1", "4"), range("1", "4"));
    expected = asList(range("1", "4"));
    assertNormalize(input, expected);
}
 

import org.apache.cassandra.db.PartitionPosition; //导入依赖的package包/类
@Test
public void testNormalizeSort()
{
    List<Range<PartitionPosition>> input, expected;

    input = asList(range("4", "5"), range("1", "3"));
    expected = asList(range("1", "3"), range("4", "5"));
    assertNormalize(input, expected);
}