Java Bounds类代码示例

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
public synchronized void maybeSnapshot(UUID cfId, UUID parentSessionId)
{
    String snapshotName = parentSessionId.toString();
    if (!columnFamilyStores.get(cfId).snapshotExists(snapshotName))
    {
        Set<SSTableReader> snapshottedSSTables = columnFamilyStores.get(cfId).snapshot(snapshotName, new Predicate<SSTableReader>()
        {
            public boolean apply(SSTableReader sstable)
            {
                return sstable != null &&
                       (!isIncremental || !sstable.isRepaired()) &&
                       !(sstable.metadata.isIndex()) && // exclude SSTables from 2i
                       new Bounds<>(sstable.first.getToken(), sstable.last.getToken()).intersects(ranges);
            }
        }, true);

        if (isAlreadyRepairing(cfId, parentSessionId, snapshottedSSTables))
        {
            columnFamilyStores.get(cfId).clearSnapshot(parentSessionId.toString());
            logger.error("Cannot start multiple repair sessions over the same sstables");
            throw new RuntimeException("Cannot start multiple repair sessions over the same sstables");
        }
        addSSTables(cfId, snapshottedSSTables);
        marked.add(cfId);
    }
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
@Test
public void testInvalidateRowCache() throws Exception
{
    StorageService.instance.initServer(0);
    CacheService.instance.setRowCacheCapacityInMB(1);
    rowCacheLoad(100, Integer.MAX_VALUE, 1000);

    ColumnFamilyStore store = Keyspace.open(KEYSPACE_CACHED).getColumnFamilyStore(CF_CACHED);
    assertEquals(CacheService.instance.rowCache.size(), 100);

    //construct 5 bounds of 20 elements each
    ArrayList<Bounds<Token>> subranges = getBounds(20);

    //invalidate 3 of the 5 bounds
    ArrayList<Bounds<Token>> boundsToInvalidate = Lists.newArrayList(subranges.get(0), subranges.get(2), subranges.get(4));
    int invalidatedKeys = store.invalidateRowCache(boundsToInvalidate);
    assertEquals(60, invalidatedKeys);

    //now there should be only 40 cached entries left
    assertEquals(CacheService.instance.rowCache.size(), 40);
    CacheService.instance.setRowCacheCapacityInMB(0);
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private ArrayList<Bounds<Token>> getBounds(int nElements)
{
    ColumnFamilyStore store = Keyspace.open(KEYSPACE_CACHED).getColumnFamilyStore(CF_CACHED);
    TreeSet<DecoratedKey> orderedKeys = new TreeSet<>();

    for(Iterator<RowCacheKey> it = CacheService.instance.rowCache.keyIterator();it.hasNext();)
        orderedKeys.add(store.decorateKey(ByteBuffer.wrap(it.next().key)));

    ArrayList<Bounds<Token>> boundsToInvalidate = new ArrayList<>();
    Iterator<DecoratedKey> iterator = orderedKeys.iterator();

    while (iterator.hasNext())
    {
        Token startRange = iterator.next().getToken();
        for (int i = 0; i < nElements-2; i++)
            iterator.next();
        Token endRange = iterator.next().getToken();
        boundsToInvalidate.add(new Bounds<>(startRange, endRange));
    }
    return boundsToInvalidate;
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
public void registerParentRepairSession(UUID parentRepairSession, List<ColumnFamilyStore> columnFamilyStores, Collection<Range<Token>> ranges)
{
    Map<UUID, Set<SSTableReader>> sstablesToRepair = new HashMap<>();
    for (ColumnFamilyStore cfs : columnFamilyStores)
    {
        Set<SSTableReader> sstables = new HashSet<>();
        for (SSTableReader sstable : cfs.getSSTables())
        {
            if (new Bounds<>(sstable.first.getToken(), sstable.last.getToken()).intersects(ranges))
            {
                if (!sstable.isRepaired())
                {
                    sstables.add(sstable);
                }
            }
        }
        sstablesToRepair.put(cfs.metadata.cfId, sstables);
    }
    parentRepairSessions.put(parentRepairSession, new ParentRepairSession(columnFamilyStores, ranges, sstablesToRepair, System.currentTimeMillis()));
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
public void registerParentRepairSession(UUID parentRepairSession, List<ColumnFamilyStore> columnFamilyStores, Collection<Range<Token>> ranges)
{
    Map<UUID, Set<SSTableReader>> sstablesToRepair = new HashMap<>();
    for (ColumnFamilyStore cfs : columnFamilyStores)
    {
        Set<SSTableReader> sstables = new HashSet<>();
        for (SSTableReader sstable : cfs.getSSTables())
        {
            if (new Bounds<>(sstable.first.token, sstable.last.token).intersects(ranges))
            {
                if (!sstable.isRepaired())
                {
                    sstables.add(sstable);
                }
            }
        }
        sstablesToRepair.put(cfs.metadata.cfId, sstables);
    }
    parentRepairSessions.put(parentRepairSession, new ParentRepairSession(columnFamilyStores, ranges, sstablesToRepair, System.currentTimeMillis()));
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private void findRowGetSlicesAndAssertColsFound(ColumnFamilyStore cfs, SliceQueryFilter filter, String rowKey,
        String... colNames)
{
    List<Row> rows = cfs.getRangeSlice(new Bounds<RowPosition>(rp(rowKey), rp(rowKey)),
                                       null,
                                       filter,
                                       Integer.MAX_VALUE,
                                       System.currentTimeMillis(),
                                       false,
                                       false);
    assertSame("unexpected number of rows ", 1, rows.size());
    Row row = rows.get(0);
    Collection<Cell> cols = !filter.isReversed() ? row.cf.getSortedColumns() : row.cf.getReverseSortedColumns();
    // printRow(cfs, new String(row.key.key.array()), cols);
    String[] returnedColsNames = Iterables.toArray(Iterables.transform(cols, new Function<Cell, String>()
    {
        public String apply(Cell arg0)
        {
            return Util.string(arg0.name().toByteBuffer());
        }
    }), String.class);

    assertTrue(
            "Columns did not match. Expected: " + Arrays.toString(colNames) + " but got:"
                    + Arrays.toString(returnedColsNames), Arrays.equals(colNames, returnedColsNames));
    int i = 0;
    for (Cell col : cols)
    {
        assertEquals(colNames[i++], Util.string(col.name().toByteBuffer()));
    }
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private synchronized Refs<SSTableReader> getSSTablesToValidate(ColumnFamilyStore cfs, Validator validator)
{
    Refs<SSTableReader> sstables;

    ActiveRepairService.ParentRepairSession prs = ActiveRepairService.instance.getParentRepairSession(validator.desc.parentSessionId);
    if (prs == null)
        return null;
    Set<SSTableReader> sstablesToValidate = new HashSet<>();
    if (prs.isGlobal)
        prs.markSSTablesRepairing(cfs.metadata.cfId, validator.desc.parentSessionId);
    // note that we always grab all existing sstables for this - if we were to just grab the ones that
    // were marked as repairing, we would miss any ranges that were compacted away and this would cause us to overstream
    try (ColumnFamilyStore.RefViewFragment sstableCandidates = cfs.selectAndReference(View.select(SSTableSet.CANONICAL, (s) -> !prs.isIncremental || !s.isRepaired())))
    {
        for (SSTableReader sstable : sstableCandidates.sstables)
        {
            if (new Bounds<>(sstable.first.getToken(), sstable.last.getToken()).intersects(validator.desc.ranges))
            {
                sstablesToValidate.add(sstable);
            }
        }

        sstables = Refs.tryRef(sstablesToValidate);
        if (sstables == null)
        {
            logger.error("Could not reference sstables");
            throw new RuntimeException("Could not reference sstables");
        }
    }

    return sstables;
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private void findRowGetSlicesAndAssertColsFound(ColumnFamilyStore cfs, SliceQueryFilter filter, String rowKey,
        String... colNames)
{
    List<Row> rows = cfs.getRangeSlice(null, new Bounds<RowPosition>(rp(rowKey), rp(rowKey)),
            Integer.MAX_VALUE,
            filter, null, false, false);
    assertSame("unexpected number of rows ", 1, rows.size());
    Row row = rows.get(0);
    Collection<IColumn> cols = !filter.isReversed() ? row.cf.getSortedColumns() : row.cf.getReverseSortedColumns();
    // printRow(cfs, new String(row.key.key.array()), cols);
    String[] returnedColsNames = Iterables.toArray(Iterables.transform(cols, new Function<IColumn, String>()
    {
        public String apply(IColumn arg0)
        {
            return new String(arg0.name().array());
        }
    }), String.class);

    assertTrue(
            "Columns did not match. Expected: " + Arrays.toString(colNames) + " but got:"
                    + Arrays.toString(returnedColsNames), Arrays.equals(colNames, returnedColsNames));
    int i = 0;
    for (IColumn col : cols)
    {
        assertEquals(colNames[i++], new String(col.name().array()));
    }
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
/**
 * Compute all ranges we're going to query, in sorted order. Nodes can be replica destinations for many ranges,
 * so we need to restrict each scan to the specific range we want, or else we'd get duplicate results.
 */
static List<AbstractBounds> getRestrictedRanges(final AbstractBounds queryRange)
{
    // special case for bounds containing exactly 1 (non-minimum) token
    if (queryRange instanceof Bounds && queryRange.left.equals(queryRange.right) && !queryRange.left.equals(StorageService.getPartitioner().getMinimumToken()))
    {
        if (logger.isDebugEnabled())
            logger.debug("restricted single token match for query " + queryRange);
        return Collections.singletonList(queryRange);
    }

    TokenMetadata tokenMetadata = StorageService.instance.getTokenMetadata();

    List<AbstractBounds> ranges = new ArrayList<AbstractBounds>();
    // divide the queryRange into pieces delimited by the ring and minimum tokens
    Iterator<Token> ringIter = TokenMetadata.ringIterator(tokenMetadata.sortedTokens(), queryRange.left, true);
    AbstractBounds remainder = queryRange;
    while (ringIter.hasNext())
    {
        Token token = ringIter.next();
        if (remainder == null || !(remainder.left.equals(token) || remainder.contains(token)))
            // no more splits
            break;
        Pair<AbstractBounds,AbstractBounds> splits = remainder.split(token);
        if (splits.left != null)
            ranges.add(splits.left);
        remainder = splits.right;
    }
    if (remainder != null)
        ranges.add(remainder);
    if (logger.isDebugEnabled())
        logger.debug("restricted ranges for query " + queryRange + " are " + ranges);

    return ranges;
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private static AbstractBounds<PartitionPosition> fullRange(SSTableReader sstable)
{
    return new Bounds<PartitionPosition>(sstable.first, sstable.last);
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
/**
 * Compute all ranges we're going to query, in sorted order. Nodes can be replica destinations for many ranges,
 * so we need to restrict each scan to the specific range we want, or else we'd get duplicate results.
 */
static <T extends RingPosition<T>> List<AbstractBounds<T>> getRestrictedRanges(final AbstractBounds<T> queryRange)
{
    // special case for bounds containing exactly 1 (non-minimum) token
    if (queryRange instanceof Bounds && queryRange.left.equals(queryRange.right) && !queryRange.left.isMinimum(StorageService.getPartitioner()))
    {
        return Collections.singletonList(queryRange);
    }

    TokenMetadata tokenMetadata = StorageService.instance.getTokenMetadata();

    List<AbstractBounds<T>> ranges = new ArrayList<AbstractBounds<T>>();
    // divide the queryRange into pieces delimited by the ring and minimum tokens
    Iterator<Token> ringIter = TokenMetadata.ringIterator(tokenMetadata.sortedTokens(), queryRange.left.getToken(), true);
    AbstractBounds<T> remainder = queryRange;
    while (ringIter.hasNext())
    {
        /*
         * remainder can be a range/bounds of token _or_ keys and we want to split it with a token:
         *   - if remainder is tokens, then we'll just split using the provided token.
         *   - if remainder is keys, we want to split using token.upperBoundKey. For instance, if remainder
         *     is [DK(10, 'foo'), DK(20, 'bar')], and we have 3 nodes with tokens 0, 15, 30. We want to
         *     split remainder to A=[DK(10, 'foo'), 15] and B=(15, DK(20, 'bar')]. But since we can't mix
         *     tokens and keys at the same time in a range, we uses 15.upperBoundKey() to have A include all
         *     keys having 15 as token and B include none of those (since that is what our node owns).
         * asSplitValue() abstracts that choice.
         */
        Token upperBoundToken = ringIter.next();
        T upperBound = (T)upperBoundToken.upperBound(queryRange.left.getClass());
        if (!remainder.left.equals(upperBound) && !remainder.contains(upperBound))
            // no more splits
            break;
        Pair<AbstractBounds<T>,AbstractBounds<T>> splits = remainder.split(upperBound);
        if (splits == null)
            continue;

        ranges.add(splits.left);
        remainder = splits.right;
    }
    ranges.add(remainder);

    return ranges;
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private static Bounds<RowPosition> bounds(RowPosition left, RowPosition right)
{
    return new Bounds<RowPosition>(left, right);
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private static Bounds<Token> tokenBounds(String left, String right)
{
    return new Bounds<Token>(token(left), token(right));
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
/**
 * Compute all ranges we're going to query, in sorted order. Nodes can be replica destinations for many ranges,
 * so we need to restrict each scan to the specific range we want, or else we'd get duplicate results.
 */
static <T extends RingPosition> List<AbstractBounds<T>> getRestrictedRanges(final AbstractBounds<T> queryRange)
{
    // special case for bounds containing exactly 1 (non-minimum) token
    if (queryRange instanceof Bounds && queryRange.left.equals(queryRange.right) && !queryRange.left.isMinimum(StorageService.getPartitioner()))
    {
        return Collections.singletonList(queryRange);
    }

    TokenMetadata tokenMetadata = StorageService.instance.getTokenMetadata();

    List<AbstractBounds<T>> ranges = new ArrayList<AbstractBounds<T>>();
    // divide the queryRange into pieces delimited by the ring and minimum tokens
    Iterator<Token> ringIter = TokenMetadata.ringIterator(tokenMetadata.sortedTokens(), queryRange.left.getToken(), true);
    AbstractBounds<T> remainder = queryRange;
    while (ringIter.hasNext())
    {
        /*
         * remainder can be a range/bounds of token _or_ keys and we want to split it with a token:
         *   - if remainder is tokens, then we'll just split using the provided token.
         *   - if remainder is keys, we want to split using token.upperBoundKey. For instance, if remainder
         *     is [DK(10, 'foo'), DK(20, 'bar')], and we have 3 nodes with tokens 0, 15, 30. We want to
         *     split remainder to A=[DK(10, 'foo'), 15] and B=(15, DK(20, 'bar')]. But since we can't mix
         *     tokens and keys at the same time in a range, we uses 15.upperBoundKey() to have A include all
         *     keys having 15 as token and B include none of those (since that is what our node owns).
         * asSplitValue() abstracts that choice.
         */
        Token upperBoundToken = ringIter.next();
        T upperBound = (T)upperBoundToken.upperBound(queryRange.left.getClass());
        if (!remainder.left.equals(upperBound) && !remainder.contains(upperBound))
            // no more splits
            break;
        Pair<AbstractBounds<T>,AbstractBounds<T>> splits = remainder.split(upperBound);
        if (splits == null)
            continue;

        ranges.add(splits.left);
        remainder = splits.right;
    }
    ranges.add(remainder);

    return ranges;
}
 

import org.apache.cassandra.dht.Bounds; //导入依赖的package包/类
private static Bounds<RowPosition> boundsFor(int start, int end)
{
    return new Bounds<RowPosition>(new BytesToken(toKey(start).getBytes()).minKeyBound(),
                                   new BytesToken(toKey(end).getBytes()).maxKeyBound());
}