Java BTree.update方法代码示例

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
@Test
public void testSlicingAllSmallTrees() throws ExecutionException, InterruptedException
{
    Object[] cur = BTree.empty();
    TreeSet<Integer> canon = new TreeSet<>();
    // we set FAN_FACTOR to 4, so 128 items is four levels deep, three fully populated
    for (int i = 0 ; i < 128 ; i++)
    {
        String id = String.format("[0..%d)", canon.size());
        System.out.println("Testing " + id);
        Futures.allAsList(testAllSlices(id, cur, canon)).get();
        Object[] next = null;
        while (next == null)
            next = BTree.update(cur, ICMP, Arrays.asList(i), true, SPORADIC_ABORT);
        cur = next;
        canon.add(i);
    }
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
@Test
public void testClearOnAbort()
{
    final Comparator<String> cmp = new Comparator<String>()
    {
        public int compare(String o1, String o2)
        {
            return o1.compareTo(o2);
        }
    };

    Object[] btree = BTree.build(ranges(range(0, 8)), cmp, true, UpdateFunction.NoOp.<String>instance());
    BTree.update(btree, cmp, ranges(range(0, 94)), false, new AbortAfterX(90));
    btree = BTree.update(btree, cmp, ranges(range(0, 94)), false, UpdateFunction.NoOp.<String>instance());
    Assert.assertTrue(BTree.isWellFormed(btree, cmp));
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
@Test
public void testOversizedMiddleInsert()
{
    TreeSet<Integer> canon = new TreeSet<>();
    for (int i = 0 ; i < 10000000 ; i++)
        canon.add(i);
    Object[] btree = BTree.build(Arrays.asList(Integer.MIN_VALUE, Integer.MAX_VALUE), ICMP, true, null);
    btree = BTree.update(btree, ICMP, canon, true);
    canon.add(Integer.MIN_VALUE);
    canon.add(Integer.MAX_VALUE);
    Assert.assertTrue(BTree.isWellFormed(btree, ICMP));
    testEqual("Oversize", BTree.<Integer>slice(btree, true), canon.iterator());
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
/**
 * Tests that the apply method of the <code>UpdateFunction</code> is only called once with each key update.
 * (see CASSANDRA-8018).
 */
@Test
public void testUpdate_UpdateFunctionCallBack()
{
    Object[] btree = new Object[1];
    CallsMonitor monitor = new CallsMonitor();

    btree = BTree.update(btree, CMP, Arrays.asList(1), monitor);
    assertArrayEquals(new Object[] {1}, btree);
    assertEquals(1, monitor.getNumberOfCalls(1));

    monitor.clear();
    btree = BTree.update(btree, CMP, Arrays.asList(2), monitor);
    assertArrayEquals(new Object[] {1, 2, null}, btree);
    assertEquals(1, monitor.getNumberOfCalls(2));

    // with existing value
    monitor.clear();
    btree = BTree.update(btree, CMP, Arrays.asList(1), monitor);
    assertArrayEquals(new Object[] {1, 2, null}, btree);
    assertEquals(1, monitor.getNumberOfCalls(1));

    // with two non-existing values
    monitor.clear();
    btree = BTree.update(btree, CMP, Arrays.asList(3, 4), monitor);
    assertArrayEquals(new Object[] {1, 2, 3, 4, null}, btree);
    assertEquals(1, monitor.getNumberOfCalls(3));
    assertEquals(1, monitor.getNumberOfCalls(4));

    // with one existing value and one non existing value
    monitor.clear();
    btree = BTree.update(btree, CMP, Arrays.asList(2, 5), monitor);
    assertArrayEquals(new Object[] {3, new Object[]{1, 2, null}, new Object[]{4, 5, null},  new int[]{2, 5}}, btree);
    assertEquals(1, monitor.getNumberOfCalls(2));
    assertEquals(1, monitor.getNumberOfCalls(5));
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
@Test
public void testClearOnAbort()
{
    Object[] btree = BTree.build(seq(2), noOp);
    Object[] copy = Arrays.copyOf(btree, btree.length);
    BTree.update(btree, CMP, seq(94), new AbortAfterX(90));

    assertArrayEquals(copy, btree);

    btree = BTree.update(btree, CMP, seq(94), noOp);
    assertTrue(BTree.isWellFormed(btree, CMP));
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
/**
 * This is only called by Memtable.resolve, so only AtomicBTreeColumns needs to implement it.
 *
 * @return the difference in size seen after merging the given columns
 */
public long addAllWithSizeDelta(final ColumnFamily cm, MemtableAllocator allocator, OpOrder.Group writeOp, Updater indexer)
{
    ColumnUpdater updater = new ColumnUpdater(this, cm.metadata, allocator, writeOp, indexer);
    DeletionInfo inputDeletionInfoCopy = null;

    while (true)
    {
        Holder current = ref;
        updater.ref = current;
        updater.reset();

        DeletionInfo deletionInfo;
        if (cm.deletionInfo().mayModify(current.deletionInfo))
        {
            if (inputDeletionInfoCopy == null)
                inputDeletionInfoCopy = cm.deletionInfo().copy(HeapAllocator.instance);

            deletionInfo = current.deletionInfo.copy().add(inputDeletionInfoCopy);
            updater.allocated(deletionInfo.unsharedHeapSize() - current.deletionInfo.unsharedHeapSize());
        }
        else
        {
            deletionInfo = current.deletionInfo;
        }

        Object[] tree = BTree.update(current.tree, metadata.comparator.columnComparator(Memtable.MEMORY_POOL instanceof NativePool), cm, cm.getColumnCount(), true, updater);

        if (tree != null && refUpdater.compareAndSet(this, current, new Holder(tree, deletionInfo)))
        {
            indexer.updateRowLevelIndexes();
            updater.finish();
            return updater.dataSize;
        }
    }
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
@Test
public void testOversizedMiddleInsert()
{
    TreeSet<Integer> canon = new TreeSet<>();
    for (int i = 0 ; i < 10000000 ; i++)
        canon.add(i);
    Object[] btree = BTree.build(Arrays.asList(Integer.MIN_VALUE, Integer.MAX_VALUE), ICMP, true);
    btree = BTree.update(btree, ICMP, canon, true);
    canon.add(Integer.MIN_VALUE);
    canon.add(Integer.MAX_VALUE);
    Assert.assertTrue(BTree.isWellFormed(btree, ICMP));
    testEqual("Oversize", BTree.<Integer>slice(btree, true), canon.iterator());
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
@Test
public void testSlicingAllSmallTrees() throws ExecutionException, InterruptedException
{
    Object[] cur = BTree.empty();
    TreeSet<Integer> canon = new TreeSet<>();
    // we set FAN_FACTOR to 4, so 128 items is four levels deep, three fully populated
    for (int i = 0 ; i < 128 ; i++)
    {
        String id = String.format("[0..%d)", canon.size());
        System.out.println("Testing " + id);
        Futures.allAsList(testAllSlices(id, cur, canon)).get();
        cur = BTree.update(cur, ICMP, Arrays.asList(i), true, null, null);
        canon.add(i);
    }
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
/**
 * This is only called by Memtable.resolve, so only AtomicBTreeColumns needs to implement it.
 *
 * @return the difference in size seen after merging the given columns
 */
public Pair<Long, Long> addAllWithSizeDelta(final ColumnFamily cm, MemtableAllocator allocator, OpOrder.Group writeOp, Updater indexer)
{
    ColumnUpdater updater = new ColumnUpdater(this, cm.metadata, allocator, writeOp, indexer);
    DeletionInfo inputDeletionInfoCopy = null;

    boolean monitorOwned = false;
    try
    {
        if (usePessimisticLocking())
        {
            Locks.monitorEnterUnsafe(this);
            monitorOwned = true;
        }
        while (true)
        {
            Holder current = ref;
            updater.ref = current;
            updater.reset();

            DeletionInfo deletionInfo;
            if (cm.deletionInfo().mayModify(current.deletionInfo))
            {
                if (inputDeletionInfoCopy == null)
                    inputDeletionInfoCopy = cm.deletionInfo().copy(HeapAllocator.instance);

                deletionInfo = current.deletionInfo.copy().add(inputDeletionInfoCopy);
                updater.allocated(deletionInfo.unsharedHeapSize() - current.deletionInfo.unsharedHeapSize());
            }
            else
            {
                deletionInfo = current.deletionInfo;
            }

            Object[] tree = BTree.update(current.tree, metadata.comparator.columnComparator(Memtable.MEMORY_POOL instanceof NativePool), cm, cm.getColumnCount(), true, updater);

            if (tree != null && refUpdater.compareAndSet(this, current, new Holder(tree, deletionInfo)))
            {
                indexer.updateRowLevelIndexes();
                updater.finish();
                return Pair.create(updater.dataSize, updater.colUpdateTimeDelta);
            }
            else if (!monitorOwned)
            {
                boolean shouldLock = usePessimisticLocking();
                if (!shouldLock)
                {
                    shouldLock = updateWastedAllocationTracker(updater.heapSize);
                }
                if (shouldLock)
                {
                    Locks.monitorEnterUnsafe(this);
                    monitorOwned = true;
                }
            }
        }
    }
    finally
    {
        if (monitorOwned)
            Locks.monitorExitUnsafe(this);
    }
}
 

import org.apache.cassandra.utils.btree.BTree; //导入方法依赖的package包/类
/**
 * This is only called by Memtable.resolve, so only AtomicBTreeColumns needs to implement it.
 *
 * @return the difference in size seen after merging the given columns
 */
public Delta addAllWithSizeDelta(final ColumnFamily cm, Function<Cell, Cell> transformation, Updater indexer, Delta delta)
{
    boolean transformed = false;
    Collection<Cell> insert = cm.getSortedColumns();

    while (true)
    {
        Holder current = ref;

        delta.reset();
        DeletionInfo deletionInfo;
        if (cm.deletionInfo().mayModify(current.deletionInfo))
        {
            if (indexer != SecondaryIndexManager.nullUpdater && cm.deletionInfo().hasRanges())
            {
                for (Iterator<RangeTombstone> rangeIterator = cm.deletionInfo().rangeIterator(); rangeIterator.hasNext(); )
                {
                    RangeTombstone rt = rangeIterator.next();
                    long deleteAt = rt.timestamp();
                    for (Iterator<Cell> iter = current.cellRange(getComparator().columnComparator(), rt.min, rt.max); iter.hasNext(); )
                    {
                        Cell c = iter.next();
                        if (deleteAt >= c.timestamp())
                            indexer.remove(c);
                    }
                }
            }

            deletionInfo = current.deletionInfo.copy().add(cm.deletionInfo());
            delta.addHeapSize(deletionInfo.unsharedHeapSize() - current.deletionInfo.unsharedHeapSize());
        }
        else
        {
            deletionInfo = current.deletionInfo;
        }

        ColumnUpdater updater = new ColumnUpdater(this, current, transformation, indexer, delta);
        Object[] tree = BTree.update(current.tree, metadata.comparator.columnComparator(), insert, true, updater);

        if (tree != null && refUpdater.compareAndSet(this, current, new Holder(tree, deletionInfo)))
        {
            indexer.updateRowLevelIndexes();
            return updater.delta;
        }

        if (!transformed)
        {
            // After failing once, transform Columns into a new collection to avoid repeatedly allocating Slab space
            insert = transform(metadata.comparator.columnComparator(), cm, transformation, false);
            transformed = true;
        }
    }

}