/** * Returns the first non-static cell in the ColumnFamily. This is necessary to avoid recording a * static column as the "last" cell seen in a reversed query. Because we will always query static * columns alongside the normal data for a page, they are not a good indicator of where paging * should resume. When we begin the next page, we need to start from the last non-static cell. */ protected Column firstNonStaticColumn(ColumnFamily cf) { for (Column column : cf) { ColumnDefinition def = cfm.getColumnDefinitionFromColumnName(column.name()); if (def == null || def.type != ColumnDefinition.Type.STATIC) return column; } return null; }
private int discardHead( ColumnFamily cf, int toDiscard, ColumnFamily copy, Iterator<Column> iter, DeletionInfo.InOrderTester tester) { ColumnCounter counter = columnCounter(); List<Column> staticColumns = new ArrayList<>(cfm.staticColumns().size()); // Discard the first 'toDiscard' live, non-static columns while (iter.hasNext()) { Column c = iter.next(); // if it's a static column, don't count it and save it to add to the trimmed results ColumnDefinition columnDef = cfm.getColumnDefinitionFromColumnName(c.name()); if (columnDef != null && columnDef.type == ColumnDefinition.Type.STATIC) { staticColumns.add(c); continue; } counter.count(c, tester); // once we've discarded the required amount, add the rest if (counter.live() > toDiscard) { for (Column staticColumn : staticColumns) copy.addColumn(staticColumn); copy.addColumn(c); while (iter.hasNext()) copy.addColumn(iter.next()); } } return Math.min(counter.live(), toDiscard); }
public IndexedEntry decodeEntry(DecoratedKey indexedValue, Column indexEntry) { int ckCount = baseCfs.metadata.clusteringKeyColumns().size(); ByteBuffer[] components = getIndexComparator().split(indexEntry.name()); ColumnNameBuilder builder = getBaseComparator().builder(); for (int i = 0; i < ckCount; i++) builder.add(components[i + 1]); return new IndexedEntry( indexedValue, indexEntry.name(), indexEntry.timestamp(), components[0], builder); }
public RowMutation toSchema(long timestamp) { RowMutation rm = new RowMutation(Table.SYSTEM_TABLE, SystemTable.getSchemaKSKey(name)); ColumnFamily cf = rm.addOrGet(SystemTable.SCHEMA_KEYSPACES_CF); cf.addColumn(Column.create(name, timestamp, "name")); cf.addColumn(Column.create(durableWrites, timestamp, "durable_writes")); cf.addColumn(Column.create(strategyClass.getName(), timestamp, "strategy_class")); cf.addColumn(Column.create(json(strategyOptions), timestamp, "strategy_options")); for (CFMetaData cfm : cfMetaData.values()) cfm.toSchema(rm, timestamp); return rm; }
public Column reconcile(Column left, Column right) { ClockRelationship cr = left.clock().compare(right.clock()); switch (cr) { case EQUAL: // tombstones take precedence. (if both are tombstones, then it doesn't matter which one we // use.) if (left.isMarkedForDelete()) return left; if (right.isMarkedForDelete()) return right; // break ties by comparing values. return FBUtilities.compareByteArrays(left.value(), right.value()) < 0 ? right : left; case GREATER_THAN: return left; case LESS_THAN: return right; default: throw new IllegalArgumentException( "Timestamp clocks must either be equal, greater then or less than: " + cr); } }