/** * 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(); }