How to use

merge

method

in

org.apache.cassandra.db.rows.UnfilteredRowIterators

/**
 * Merges the provided updates, yielding a new update that incorporates all those updates.
 *
 * @param updates the collection of updates to merge. This shouldn't be empty.
 *
 * @return a partition update that include (merge) all the updates from {@code updates}.
 */
public static PartitionUpdate merge(List<PartitionUpdate> updates)
{
  assert !updates.isEmpty();
  final int size = updates.size();
  if (size == 1)
    return Iterables.getOnlyElement(updates);
  int nowInSecs = FBUtilities.nowInSeconds();
  List<UnfilteredRowIterator> asIterators = Lists.transform(updates, AbstractBTreePartition::unfilteredIterator);
  return fromIterator(UnfilteredRowIterators.merge(asIterators, nowInSecs), ColumnFilter.all(updates.get(0).metadata()));
}

/**
 * Merges the provided updates, yielding a new update that incorporates all those updates.
 *
 * @param updates the collection of updates to merge. This shouldn't be empty.
 *
 * @return a partition update that include (merge) all the updates from {@code updates}.
 */
public static PartitionUpdate merge(List<PartitionUpdate> updates)
{
  assert !updates.isEmpty();
  final int size = updates.size();
  if (size == 1)
    return Iterables.getOnlyElement(updates);
  int nowInSecs = FBUtilities.nowInSeconds();
  List<UnfilteredRowIterator> asIterators = Lists.transform(updates, AbstractBTreePartition::unfilteredIterator);
  return fromIterator(UnfilteredRowIterators.merge(asIterators, nowInSecs), ColumnFilter.all(updates.get(0).metadata()));
}

/**
 * Merges the provided updates, yielding a new update that incorporates all those updates.
 *
 * @param updates the collection of updates to merge. This shouldn't be empty.
 *
 * @return a partition update that include (merge) all the updates from {@code updates}.
 */
public static PartitionUpdate merge(List<PartitionUpdate> updates)
{
  assert !updates.isEmpty();
  final int size = updates.size();
  if (size == 1)
    return Iterables.getOnlyElement(updates);
  int nowInSecs = FBUtilities.nowInSeconds();
  List<UnfilteredRowIterator> asIterators = Lists.transform(updates, AbstractBTreePartition::unfilteredIterator);
  return fromIterator(UnfilteredRowIterators.merge(asIterators, nowInSecs), ColumnFilter.all(updates.get(0).metadata()));
}

private ImmutableBTreePartition add(UnfilteredRowIterator iter, ImmutableBTreePartition result, ClusteringIndexNamesFilter filter, boolean isRepaired)
{
  if (!isRepaired)
    oldestUnrepairedTombstone = Math.min(oldestUnrepairedTombstone, iter.stats().minLocalDeletionTime);
  int maxRows = Math.max(filter.requestedRows().size(), 1);
  if (result == null)
    return ImmutableBTreePartition.create(iter, maxRows);
  try (UnfilteredRowIterator merged = UnfilteredRowIterators.merge(Arrays.asList(iter, result.unfilteredIterator(columnFilter(), Slices.ALL, filter.isReversed())), nowInSec()))
  {
    return ImmutableBTreePartition.create(merged, maxRows);
  }
}

private ImmutableBTreePartition add(UnfilteredRowIterator iter, ImmutableBTreePartition result, ClusteringIndexNamesFilter filter, boolean isRepaired)
{
  if (!isRepaired)
    oldestUnrepairedTombstone = Math.min(oldestUnrepairedTombstone, iter.stats().minLocalDeletionTime);
  int maxRows = Math.max(filter.requestedRows().size(), 1);
  if (result == null)
    return ImmutableBTreePartition.create(iter, maxRows);
  try (UnfilteredRowIterator merged = UnfilteredRowIterators.merge(Arrays.asList(iter, result.unfilteredIterator(columnFilter(), Slices.ALL, filter.isReversed())), nowInSec()))
  {
    return ImmutableBTreePartition.create(merged, maxRows);
  }
}

  @Override
  protected UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition)
  {
    Iterable<UnfilteredRowIterator> sources = controller.shadowSources(partition.partitionKey(), !cellLevelGC);
    if (sources == null)
      return partition;
    List<UnfilteredRowIterator> iters = new ArrayList<>();
    for (UnfilteredRowIterator iter : sources)
    {
      if (!iter.isEmpty())
        iters.add(iter);
      else
        iter.close();
    }
    if (iters.isEmpty())
      return partition;
    return new GarbageSkippingUnfilteredRowIterator(partition, UnfilteredRowIterators.merge(iters, nowInSec), nowInSec, cellLevelGC);
  }
}

  @Override
  protected UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition)
  {
    Iterable<UnfilteredRowIterator> sources = controller.shadowSources(partition.partitionKey(), !cellLevelGC);
    if (sources == null)
      return partition;
    List<UnfilteredRowIterator> iters = new ArrayList<>();
    for (UnfilteredRowIterator iter : sources)
    {
      if (!iter.isEmpty())
        iters.add(iter);
      else
        iter.close();
    }
    if (iters.isEmpty())
      return partition;
    return new GarbageSkippingUnfilteredRowIterator(partition, UnfilteredRowIterators.merge(iters, nowInSec), nowInSec, cellLevelGC);
  }
}

  @Override
  protected UnfilteredRowIterator applyToPartition(UnfilteredRowIterator partition)
  {
    Iterable<UnfilteredRowIterator> sources = controller.shadowSources(partition.partitionKey(), !cellLevelGC);
    if (sources == null)
      return partition;
    List<UnfilteredRowIterator> iters = new ArrayList<>();
    for (UnfilteredRowIterator iter : sources)
    {
      if (!iter.isEmpty())
        iters.add(iter);
      else
        iter.close();
    }
    if (iters.isEmpty())
      return partition;
    return new GarbageSkippingUnfilteredRowIterator(partition, UnfilteredRowIterators.merge(iters, nowInSec), nowInSec, cellLevelGC);
  }
}

private ImmutableBTreePartition add(UnfilteredRowIterator iter, ImmutableBTreePartition result, ClusteringIndexNamesFilter filter, boolean isRepaired)
{
  if (!isRepaired)
    oldestUnrepairedTombstone = Math.min(oldestUnrepairedTombstone, iter.stats().minLocalDeletionTime);
  int maxRows = Math.max(filter.requestedRows().size(), 1);
  if (result == null)
    return ImmutableBTreePartition.create(iter, maxRows);
  try (UnfilteredRowIterator merged = UnfilteredRowIterators.merge(Arrays.asList(iter, result.unfilteredIterator(columnFilter(), Slices.ALL, filter.isReversed())), nowInSec()))
  {
    return ImmutableBTreePartition.create(merged, maxRows);
  }
}

/**
 * Merges the provided updates, yielding a new update that incorporates all those updates.
 *
 * @param updates the collection of updates to merge. This shouldn't be empty.
 *
 * @return a partition update that include (merge) all the updates from {@code updates}.
 */
public static PartitionUpdate merge(List<PartitionUpdate> updates)
{
  assert !updates.isEmpty();
  final int size = updates.size();
  if (size == 1)
    return Iterables.getOnlyElement(updates);
  int nowInSecs = FBUtilities.nowInSeconds();
  List<UnfilteredRowIterator> asIterators = Lists.transform(updates, AbstractBTreePartition::unfilteredIterator);
  return fromIterator(UnfilteredRowIterators.merge(asIterators, nowInSecs), ColumnFilter.all(updates.get(0).metadata()));
}

/**
 * Return a wrapped iterator that when closed will update the sstables iterated and READ sample metrics.
 * Note that we cannot use the Transformations framework because they greedily get the static row, which
 * would cause all iterators to be initialized and hence all sstables to be accessed.
 */
private UnfilteredRowIterator withSSTablesIterated(List<UnfilteredRowIterator> iterators,
                          TableMetrics metrics,
                          SSTableReadMetricsCollector metricsCollector)
{
  @SuppressWarnings("resource") //  Closed through the closing of the result of the caller method.
  UnfilteredRowIterator merged = UnfilteredRowIterators.merge(iterators, nowInSec());
  if (!merged.isEmpty())
  {
    DecoratedKey key = merged.partitionKey();
    metrics.samplers.get(TableMetrics.Sampler.READS).addSample(key.getKey(), key.hashCode(), 1);
  }
  class UpdateSstablesIterated extends Transformation
  {
    public void onPartitionClose()
    {
      int mergedSSTablesIterated = metricsCollector.getMergedSSTables();
      metrics.updateSSTableIterated(mergedSSTablesIterated);
      Tracing.trace("Merged data from memtables and {} sstables", mergedSSTablesIterated);
    }
  };
  return Transformation.apply(merged, new UpdateSstablesIterated());
}

/**
 * Return a wrapped iterator that when closed will update the sstables iterated and READ sample metrics.
 * Note that we cannot use the Transformations framework because they greedily get the static row, which
 * would cause all iterators to be initialized and hence all sstables to be accessed.
 */
private UnfilteredRowIterator withSSTablesIterated(List<UnfilteredRowIterator> iterators,
                          TableMetrics metrics,
                          SSTableReadMetricsCollector metricsCollector)
{
  @SuppressWarnings("resource") //  Closed through the closing of the result of the caller method.
  UnfilteredRowIterator merged = UnfilteredRowIterators.merge(iterators, nowInSec());
  if (!merged.isEmpty())
  {
    DecoratedKey key = merged.partitionKey();
    metrics.samplers.get(TableMetrics.Sampler.READS).addSample(key.getKey(), key.hashCode(), 1);
  }
  class UpdateSstablesIterated extends Transformation
  {
    public void onPartitionClose()
    {
      int mergedSSTablesIterated = metricsCollector.getMergedSSTables();
      metrics.updateSSTableIterated(mergedSSTablesIterated);
      Tracing.trace("Merged data from memtables and {} sstables", mergedSSTablesIterated);
    }
  };
  return Transformation.apply(merged, new UpdateSstablesIterated());
}

/**
 * Return a wrapped iterator that when closed will update the sstables iterated and READ sample metrics.
 * Note that we cannot use the Transformations framework because they greedily get the static row, which
 * would cause all iterators to be initialized and hence all sstables to be accessed.
 */
private UnfilteredRowIterator withSSTablesIterated(List<UnfilteredRowIterator> iterators,
                          TableMetrics metrics,
                          SSTableReadMetricsCollector metricsCollector)
{
  @SuppressWarnings("resource") //  Closed through the closing of the result of the caller method.
  UnfilteredRowIterator merged = UnfilteredRowIterators.merge(iterators, nowInSec());
  if (!merged.isEmpty())
  {
    DecoratedKey key = merged.partitionKey();
    metrics.samplers.get(TableMetrics.Sampler.READS).addSample(key.getKey(), key.hashCode(), 1);
  }
  class UpdateSstablesIterated extends Transformation
  {
    public void onPartitionClose()
    {
      int mergedSSTablesIterated = metricsCollector.getMergedSSTables();
      metrics.updateSSTableIterated(mergedSSTablesIterated);
      Tracing.trace("Merged data from memtables and {} sstables", mergedSSTablesIterated);
    }
  };
  return Transformation.apply(merged, new UpdateSstablesIterated());
}