How to use

PartitionColumns

in

org.apache.cassandra.db

  /**
   * Whether or not the given metadata is compatible / representable with CQL Language
   */
  public static boolean isCqlCompatible(CFMetaData metaData)
  {
    if (metaData.isSuper())
      return false;

    if (metaData.isCompactTable()
      && metaData.partitionColumns().withoutStatics().size() > 1
      && metaData.clusteringColumns().size() >= 1)
      return false;

    return true;
  }
}

private PartitionColumns columnsToRead()
{
  PartitionColumns allColumns = cfm.partitionColumns();
  // If we update static row, we won't have any conditions on regular rows.
  // If we update regular row, we have to fetch all regular rows (which would satisfy column condition) and
  // static rows that take part in column condition.
  // In both cases, we're fetching enough rows to distinguish between "all conditions are nulls" and "row does not exist".
  // We have to do this as we can't rely on row marker for that (see #6623)
  Columns statics = updatesStaticRow ? allColumns.statics : conditionColumns.statics;
  Columns regulars = updatesRegularRows ? allColumns.regulars : conditionColumns.regulars;
  return new PartitionColumns(statics, regulars);
}

public Builder addAll(Iterable<ColumnDefinition> columns)
{
  if (queriedBuilder == null)
    queriedBuilder = PartitionColumns.builder();
  queriedBuilder.addAll(columns);
  return this;
}

@Override
public String toString()
{
  if (isFetchAll)
    return "*";
  if (queried.isEmpty())
    return "";
  Iterator<ColumnDefinition> defs = queried.selectOrderIterator();
  if (!defs.hasNext())
    return "<none>";
  StringBuilder sb = new StringBuilder();
  while (defs.hasNext())
  {
    appendColumnDef(sb, defs.next());
    if (defs.hasNext())
      sb.append(", ");
  }
  return sb.toString();
}

/**
 * Whether the provided column, which is assumed to be _fetched_ by this filter (so the caller must guarantee
 * that {@code fetches(column) == true}, is also _queried_ by the user.
 *
 * !WARNING! please be sure to understand the difference between _fetched_ and _queried_
 * columns that this class made before using this method. If unsure, you probably want
 * to use the {@link #fetches} method.
 */
public boolean fetchedColumnIsQueried(ColumnDefinition column)
{
  return !isFetchAll || queried == null || queried.contains(column);
}

private void rebuild()
{
  this.comparator = new ClusteringComparator(extractTypes(clusteringColumns));
  Map<ByteBuffer, ColumnDefinition> newColumnMetadata = Maps.newHashMapWithExpectedSize(partitionKeyColumns.size() + clusteringColumns.size() + partitionColumns.size());
  for (ColumnDefinition def : partitionKeyColumns)
    newColumnMetadata.put(def.name.bytes, def);
  for (ColumnDefinition def : clusteringColumns)
    newColumnMetadata.put(def.name.bytes, def);
  for (ColumnDefinition def : partitionColumns)
    newColumnMetadata.put(def.name.bytes, def);
  this.columnMetadata = newColumnMetadata;
  List<AbstractType<?>> keyTypes = extractTypes(partitionKeyColumns);
  this.keyValidator = keyTypes.size() == 1 ? keyTypes.get(0) : CompositeType.getInstance(keyTypes);
  if (isCompactTable())
    this.compactValueColumn = CompactTables.getCompactValueColumn(partitionColumns, isSuper());
  this.allColumnFilter = ColumnFilter.all(this);
}

Map<ByteBuffer, ColumnDefinition> newColumnMetadata = Maps.newHashMapWithExpectedSize(partitionKeyColumns.size() + clusteringColumns.size() + partitionColumns.size());
  newColumnMetadata.put(compactValueColumn.name.bytes, compactValueColumn);
  clusteringColumns = Arrays.asList(clusteringColumns().get(0));
  partitionColumns = PartitionColumns.of(compactValueColumn);

PartitionColumns.Builder conditionColumnsBuilder = PartitionColumns.builder();
Iterable<ColumnDefinition> columns = conditions.getColumns();
if (columns != null)
  conditionColumnsBuilder.addAll(columns);
PartitionColumns.Builder updatedColumnsBuilder = PartitionColumns.builder();
PartitionColumns.Builder requiresReadBuilder = PartitionColumns.builder();
for (Operation operation : operations)
if (cfm.isCompactTable() && modifiedColumns.isEmpty() && updatesRegularRows())
  modifiedColumns = cfm.partitionColumns();

private Iterator<ColumnDefinition> nonPkColumnIterator()
{
  final boolean noNonPkColumns = isCompactTable() && CompactTables.hasEmptyCompactValue(this) && !isSuper();
  if (noNonPkColumns)
  {
    return Collections.<ColumnDefinition>emptyIterator();
  }
  else if (isStaticCompactTable())
  {
    return partitionColumns.statics.selectOrderIterator();
  }
  else if (isSuper())
  {
    if (isDense)
      return Iterators.forArray(superCfKeyColumn, superCfValueColumn);
    else
      return Iterators.filter(partitionColumns.iterator(), (c) -> !c.type.isCollection());
  }
  else
    return partitionColumns().selectOrderIterator();
}

/**
 * Returns an iterator that concatenate two atom iterators.
 * This method assumes that both iterator are from the same partition and that the atom from
 * {@code iter2} come after the ones of {@code iter1} (that is, that concatenating the iterator
 * make sense).
 */
public static UnfilteredRowIterator concat(final UnfilteredRowIterator iter1, final UnfilteredRowIterator iter2)
{
  assert iter1.metadata().cfId.equals(iter2.metadata().cfId)
    && iter1.partitionKey().equals(iter2.partitionKey())
    && iter1.partitionLevelDeletion().equals(iter2.partitionLevelDeletion())
    && iter1.isReverseOrder() == iter2.isReverseOrder()
    && iter1.staticRow().equals(iter2.staticRow());
  class Extend implements MoreRows<UnfilteredRowIterator>
  {
    boolean returned = false;
    public UnfilteredRowIterator moreContents()
    {
      if (returned)
        return null;
      returned = true;
      return iter2;
    }
  }
  return MoreRows.extend(iter1, new Extend(), iter1.columns().mergeTo(iter2.columns()));
}

clusteringColumns = cfm.clusteringColumns;
boolean changeAffectsStatements = !partitionColumns.equals(cfm.partitionColumns);
partitionColumns = cfm.partitionColumns;
superCfKeyColumn = cfm.superCfKeyColumn;

if (metadata.partitionColumns().isEmpty())
  return new LegacyCellName(clustering, null, null);

Columns columns = filter.fetchedColumns().columns(isStatic());
Predicate<ColumnDefinition> inclusionTester = columns.inOrderInclusionTester();
Predicate<ColumnDefinition> queriedByUserTester = filter.queriedColumns().columns(isStatic()).inOrderInclusionTester();
final LivenessInfo rowLiveness = newInfo;
return transformAndFilter(newInfo, newDeletion, (cd) -> {

public Iterator<ColumnDefinition> allColumnsInSelectOrder()
{
  final boolean isStaticCompactTable = isStaticCompactTable();
  final boolean noNonPkColumns = isCompactTable() && CompactTables.hasEmptyCompactValue(this);
  return new AbstractIterator<ColumnDefinition>()
  {
    private final Iterator<ColumnDefinition> partitionKeyIter = partitionKeyColumns.iterator();
    private final Iterator<ColumnDefinition> clusteringIter = isStaticCompactTable ? Collections.<ColumnDefinition>emptyIterator() : clusteringColumns.iterator();
    private final Iterator<ColumnDefinition> otherColumns = noNonPkColumns
                               ? Collections.<ColumnDefinition>emptyIterator()
                               : (isStaticCompactTable
                                 ?  partitionColumns.statics.selectOrderIterator()
                                 :  partitionColumns.selectOrderIterator());
    protected ColumnDefinition computeNext()
    {
      if (partitionKeyIter.hasNext())
        return partitionKeyIter.next();
      if (clusteringIter.hasNext())
        return clusteringIter.next();
      return otherColumns.hasNext() ? otherColumns.next() : endOfData();
    }
  };
}

@Override
public String toString()
{
  if (isFetchAll)
    return "*";
  if (queried.isEmpty())
    return "";
  Iterator<ColumnDefinition> defs = queried.selectOrderIterator();
  if (!defs.hasNext())
    return "<none>";
  StringBuilder sb = new StringBuilder();
  while (defs.hasNext())
  {
    appendColumnDef(sb, defs.next());
    if (defs.hasNext())
      sb.append(", ");
  }
  return sb.toString();
}

/**
 * Whether the provided column is fetched by this filter.
 */
public boolean fetches(ColumnDefinition column)
{
  return isFetchAll || queried.contains(column);
}

static long serializedNamesFilterSize(ClusteringIndexNamesFilter filter, CFMetaData metadata, PartitionColumns fetchedColumns)
{
  SortedSet<Clustering> requestedRows = filter.requestedRows();
  long size = 0;
  if (requestedRows.isEmpty())
  {
    // only static columns are requested
    size += TypeSizes.sizeof(fetchedColumns.size());
    for (ColumnDefinition column : fetchedColumns)
      size += ByteBufferUtil.serializedSizeWithShortLength(column.name.bytes);
  }
  else
  {
    size += TypeSizes.sizeof(requestedRows.size() * fetchedColumns.size());
    for (Clustering clustering : requestedRows)
    {
      for (ColumnDefinition column : fetchedColumns)
        size += ByteBufferUtil.serializedSizeWithShortLength(LegacyLayout.encodeCellName(metadata, clustering, column.name.bytes, null));
    }
  }
  return size + TypeSizes.sizeof(true);  // countCql3Rows
}

Map<ByteBuffer, ColumnDefinition> newColumnMetadata = Maps.newHashMapWithExpectedSize(partitionKeyColumns.size() + clusteringColumns.size() + partitionColumns.size());
  newColumnMetadata.put(compactValueColumn.name.bytes, compactValueColumn);
  clusteringColumns = Arrays.asList(clusteringColumns().get(0));
  partitionColumns = PartitionColumns.of(compactValueColumn);

PartitionColumns.Builder conditionColumnsBuilder = PartitionColumns.builder();
Iterable<ColumnDefinition> columns = conditions.getColumns();
if (columns != null)
  conditionColumnsBuilder.addAll(columns);
PartitionColumns.Builder updatedColumnsBuilder = PartitionColumns.builder();
PartitionColumns.Builder requiresReadBuilder = PartitionColumns.builder();
for (Operation operation : operations)
if (cfm.isCompactTable() && modifiedColumns.isEmpty() && updatesRegularRows())
  modifiedColumns = cfm.partitionColumns();

private Iterator<ColumnDefinition> nonPkColumnIterator()
{
  final boolean noNonPkColumns = isCompactTable() && CompactTables.hasEmptyCompactValue(this) && !isSuper();
  if (noNonPkColumns)
  {
    return Collections.<ColumnDefinition>emptyIterator();
  }
  else if (isStaticCompactTable())
  {
    return partitionColumns.statics.selectOrderIterator();
  }
  else if (isSuper())
  {
    if (isDense)
      return Iterators.forArray(superCfKeyColumn, superCfValueColumn);
    else
      return Iterators.filter(partitionColumns.iterator(), (c) -> !c.type.isCollection());
  }
  else
    return partitionColumns().selectOrderIterator();
}