Java ColumnSlice类代码示例

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
protected Cell computeNext()
{
    while (currentSlice != null || idx < slices.length)
    {
        if (currentSlice == null)
        {
            ColumnSlice slice = slices[idx++];
            if (forwards)
                currentSlice = slice(btree, comparator, slice.start, slice.finish, true);
            else
                currentSlice = slice(btree, comparator, slice.finish, slice.start, false);
        }

        if (currentSlice.hasNext())
            return currentSlice.next();

        currentSlice = null;
    }

    return endOfData();
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
protected Cell computeNext()
{
    if (currentSlice == null)
    {
        if (idx >= slices.length)
            return endOfData();

        ColumnSlice slice = slices[idx++];
        if (forwards)
            currentSlice = slice(btree, comparator, slice.start, slice.finish, true);
        else
            currentSlice = slice(btree, comparator, slice.finish, slice.start, false);
    }

    if (currentSlice.hasNext())
        return currentSlice.next();

    currentSlice = null;
    return computeNext();
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
protected Iterator<Cell> collectionColumns(CellName collection, ColumnFamily cf, final long now)
{
    // We are testing for collection equality, so we need to have the expected values *and* only those.
    ColumnSlice[] collectionSlice = new ColumnSlice[]{ collection.slice() };
    // Filter live columns, this makes things simpler afterwards
    return Iterators.filter(cf.iterator(collectionSlice), new Predicate<Cell>()
    {
        public boolean apply(Cell c)
        {
            // we only care about live columns
            return c.isLive(now);
        }
    });
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
protected AbstractCType(boolean isByteOrderComparable)
{
    reverseComparator = new Comparator<Composite>()
    {
        public int compare(Composite c1, Composite c2)
        {
            return AbstractCType.this.compare(c2, c1);
        }
    };
    indexComparator = new Comparator<IndexInfo>()
    {
        public int compare(IndexInfo o1, IndexInfo o2)
        {
            return AbstractCType.this.compare(o1.lastName, o2.lastName);
        }
    };
    indexReverseComparator = new Comparator<IndexInfo>()
    {
        public int compare(IndexInfo o1, IndexInfo o2)
        {
            return AbstractCType.this.compare(o1.firstName, o2.firstName);
        }
    };

    serializer = new Serializer(this);

    indexSerializer = new IndexInfo.Serializer(this);
    sliceSerializer = new ColumnSlice.Serializer(this);
    sliceQueryFilterSerializer = new SliceQueryFilter.Serializer(this);
    deletionInfoSerializer = new DeletionInfo.Serializer(this);
    rangeTombstoneSerializer = new RangeTombstone.Serializer(this);
    rowIndexEntrySerializer = new RowIndexEntry.Serializer(this);
    this.isByteOrderComparable = isByteOrderComparable;
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
public Iterator<Cell> iterator(ColumnSlice[] slices)
{
    maybeSortCells();
    return slices.length == 1
         ? slice(slices[0], reversed, null)
         : new SlicesIterator(slices, reversed);
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
public Iterator<Cell> reverseIterator(ColumnSlice[] slices)
{
    maybeSortCells();
    return slices.length == 1
         ? slice(slices[0], !reversed, null)
         : new SlicesIterator(slices, !reversed);
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
SliceIterator(Object[] btree, Comparator<Object> comparator, boolean forwards, ColumnSlice[] slices)
{
    this.btree = btree;
    this.comparator = comparator;
    this.slices = slices;
    this.forwards = forwards;
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
/**
 * This slice reader assumes that slices are sorted correctly, e.g. that for forward lookup slices are in
 * lexicographic order of start elements and that for reverse lookup they are in reverse lexicographic order of
 * finish (reverse start) elements. i.e. forward: [a,b],[d,e],[g,h] reverse: [h,g],[e,d],[b,a]. This reader also
 * assumes that validation has been performed in terms of intervals (no overlapping intervals).
 */
public IndexedSliceReader(SSTableReader sstable, RowIndexEntry indexEntry, FileDataInput input, ColumnSlice[] slices, boolean reversed)
{
    Tracing.trace("Seeking to partition indexed section in data file");
    this.sstable = sstable;
    this.originalInput = input;
    this.reversed = reversed;
    this.slices = slices;
    this.comparator = sstable.metadata.comparator;
    this.rangeTombstonesReversed = reversed ? new ArrayDeque<OnDiskAtom>() : null;

    try
    {
        this.indexes = indexEntry.columnsIndex();
        emptyColumnFamily = ArrayBackedSortedColumns.factory.create(sstable.metadata);
        if (indexes.isEmpty())
        {
            setToRowStart(indexEntry, input);
            emptyColumnFamily.delete(DeletionTime.serializer.deserialize(file));
            fetcher = new SimpleBlockFetcher();
        }
        else
        {
            emptyColumnFamily.delete(indexEntry.deletionTime());
            fetcher = new IndexedBlockFetcher(indexEntry.position);
        }
    }
    catch (IOException e)
    {
        sstable.markSuspect();
        throw new CorruptSSTableException(e, file.getPath());
    }
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
/**
 * Set the to start-of end-of value of "" for start and finish.
 * @param columnSlice
 */
private static void fixOptionalSliceParameters(org.apache.cassandra.thrift.ColumnSlice columnSlice) {
    if (!columnSlice.isSetStart())
        columnSlice.setStart(new byte[0]);
    if (!columnSlice.isSetFinish())
        columnSlice.setFinish(new byte[0]);
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
private void testIteratorInternal(boolean reversed)
{
    CellNameType type = new SimpleDenseCellNameType(Int32Type.instance);
    ColumnFamily map = ArrayBackedSortedColumns.factory.create(metadata(), reversed);

    int[] values = new int[]{ 1, 2, 3, 5, 9 };

    for (int i = 0; i < values.length; ++i)
        map.addColumn(new BufferCell(type.makeCellName(values[reversed ? values.length - 1 - i : i])));

    assertSame(new int[]{ 3, 2, 1 }, map.reverseIterator(new ColumnSlice[]{ new ColumnSlice(type.make(3), Composites.EMPTY) }));
    assertSame(new int[]{ 3, 2, 1 }, map.reverseIterator(new ColumnSlice[]{ new ColumnSlice(type.make(4), Composites.EMPTY) }));

    assertSame(map.iterator(), map.iterator(ColumnSlice.ALL_COLUMNS_ARRAY));
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
protected Column computeNext()
{
    if (currentSlice == null)
    {
        if (idx >= slices.length)
            return endOfData();

        ColumnSlice slice = slices[idx++];
        // The first idx to include
        int startIdx = slice.start.remaining() == 0 ? 0 : binarySearch(list, comparator, slice.start, previousSliceEnd);
        if (startIdx < 0)
            startIdx = -startIdx - 1;

        // The first idx to exclude
        int finishIdx = slice.finish.remaining() == 0 ? list.size() - 1 : binarySearch(list, comparator, slice.finish, previousSliceEnd);
        if (finishIdx >= 0)
            finishIdx++;
        else
            finishIdx = -finishIdx - 1;

        if (startIdx == 0 && finishIdx == list.size())
            currentSlice = list.iterator();
        else
            currentSlice = list.subList(startIdx, finishIdx).iterator();

        previousSliceEnd = finishIdx > 0 ? finishIdx - 1 : 0;
    }

    if (currentSlice.hasNext())
        return currentSlice.next();

    currentSlice = null;
    return computeNext();
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
/**
 * This slice reader assumes that slices are sorted correctly, e.g. that for forward lookup slices are in
 * lexicographic order of start elements and that for reverse lookup they are in reverse lexicographic order of
 * finish (reverse start) elements. i.e. forward: [a,b],[d,e],[g,h] reverse: [h,g],[e,d],[b,a]. This reader also
 * assumes that validation has been performed in terms of intervals (no overlapping intervals).
 */
public IndexedSliceReader(SSTableReader sstable, RowIndexEntry indexEntry, FileDataInput input, ColumnSlice[] slices, boolean reversed)
{
    Tracing.trace("Seeking to partition indexed section in data file");
    this.sstable = sstable;
    this.originalInput = input;
    this.reversed = reversed;
    this.slices = slices;
    this.comparator = sstable.metadata.comparator;
    this.rangeTombstonesReversed = reversed ? new ArrayDeque<OnDiskAtom>() : null;

    try
    {
        this.indexes = indexEntry.columnsIndex();
        emptyColumnFamily = EmptyColumns.factory.create(sstable.metadata);
        if (indexes.isEmpty())
        {
            setToRowStart(indexEntry, input);
            emptyColumnFamily.delete(DeletionTime.serializer.deserialize(file));
            fetcher = new SimpleBlockFetcher();
        }
        else
        {
            emptyColumnFamily.delete(indexEntry.deletionTime());
            fetcher = new IndexedBlockFetcher(indexEntry.position);
        }
    }
    catch (IOException e)
    {
        sstable.markSuspect();
        throw new CorruptSSTableException(e, file.getPath());
    }
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
private void testIteratorInternal(boolean reversed)
{
    ColumnFamily map = ArrayBackedSortedColumns.factory.create(metadata(), reversed);

    int[] values = new int[]{ 1, 2, 3, 5, 9 };

    for (int i = 0; i < values.length; ++i)
        map.addColumn(new Column(ByteBufferUtil.bytes(values[reversed ? values.length - 1 - i : i])), HeapAllocator.instance);

    assertSame(new int[]{ 3, 2, 1 }, map.reverseIterator(new ColumnSlice[]{ new ColumnSlice(ByteBufferUtil.bytes(3), ByteBufferUtil.EMPTY_BYTE_BUFFER) }));
    assertSame(new int[]{ 3, 2, 1 }, map.reverseIterator(new ColumnSlice[]{ new ColumnSlice(ByteBufferUtil.bytes(4), ByteBufferUtil.EMPTY_BYTE_BUFFER) }));

    assertSame(map.iterator(), map.iterator(ColumnSlice.ALL_COLUMNS_ARRAY));
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
protected IColumn computeNext()
{
    if (currentSlice == null)
    {
        if (idx >= slices.length)
            return endOfData();

        ColumnSlice slice = slices[idx++];
        // The first idx to include
        int startIdx = slice.start.remaining() == 0 ? 0 : binarySearch(list, comparator, slice.start, previousSliceEnd);
        if (startIdx < 0)
            startIdx = -startIdx - 1;

        // The first idx to exclude
        int finishIdx = slice.finish.remaining() == 0 ? list.size() - 1 : binarySearch(list, comparator, slice.finish, previousSliceEnd);
        if (finishIdx >= 0)
            finishIdx++;
        else
            finishIdx = -finishIdx - 1;

        if (startIdx == 0 && finishIdx == list.size())
            currentSlice = list.iterator();
        else
            currentSlice = list.subList(startIdx, finishIdx).iterator();

        previousSliceEnd = finishIdx > 0 ? finishIdx - 1 : 0;
    }

    if (currentSlice.hasNext())
        return currentSlice.next();

    currentSlice = null;
    return computeNext();
}
 

import org.apache.cassandra.db.filter.ColumnSlice; //导入依赖的package包/类
/**
 * @param key row to index
 * @param cfs ColumnFamily to index row in
 * @param idxNames columns to index, in comparator order
 */
public static void indexRow(DecoratedKey key, ColumnFamilyStore cfs, Set<String> idxNames)
{
    if (logger.isDebugEnabled())
        logger.debug("Indexing row {} ", cfs.metadata.getKeyValidator().getString(key.key));

    Collection<SecondaryIndex> indexes = cfs.indexManager.getIndexesByNames(idxNames);

    switchLock.readLock().lock();
    try
    {
        // Our index lock is per-row, but we don't want to hold writes for too long, so for large rows
        // we release the lock between pages
        SliceQueryPager pager = new SliceQueryPager(cfs, key, ColumnSlice.ALL_COLUMNS_ARRAY);
        while (pager.hasNext())
        {
            synchronized (cfs.table.indexLockFor(key.key))
            {
                ColumnFamily cf = pager.next();
                ColumnFamily cf2 = cf.cloneMeShallow();
                for (IColumn column : cf)
                {
                    if (cfs.indexManager.indexes(column.name(), indexes))
                        cf2.addColumn(column);
                }
                cfs.indexManager.indexRow(key.key, cf2);
            }
        }
    }
    finally
    {
        switchLock.readLock().unlock();
    }
}