public Builder addStaticColumn(ColumnIdentifier name, AbstractType type) { this.staticColumns.add(Pair.create(name, type)); return this; }
public Builder addPartitionKey(ColumnIdentifier name, AbstractType type) { this.partitionKeys.add(Pair.create(name, type)); return this; }
public Builder addClusteringColumn(ColumnIdentifier name, AbstractType type) { this.clusteringColumns.add(Pair.create(name, type)); return this; }
/** * Used for ColumnFamily data eviction out from the schema * * @param cfm The ColumnFamily Definition to evict */ public void unload(CFMetaData cfm) { cfIdMap.remove(Pair.create(cfm.ksName, cfm.cfName)); }
public Set<Permission> getPermissions(AuthenticatedUser user, IResource resource) { try { return get(Pair.create(user, resource)); } catch (ExecutionException e) { throw new RuntimeException(e); } } }
public static synchronized <K, V> MapSerializer<K, V> getInstance(TypeSerializer<K> keys, TypeSerializer<V> values, Comparator<ByteBuffer> comparator) { Pair<TypeSerializer<?>, TypeSerializer<?>> p = Pair.<TypeSerializer<?>, TypeSerializer<?>>create(keys, values); MapSerializer<K, V> t = instances.get(p); if (t == null) { t = new MapSerializer<K, V>(keys, values, comparator); instances.put(p, t); } return t; }
protected Pair<Long, LongSet> computeNext() { if (!iterator.hasNext()) return endOfData(); Map.Entry<Long, LongSet> entry = iterator.next(); return Pair.create(entry.getKey(), entry.getValue()); } };
public Set<Permission> getPermissions(AuthenticatedUser user, IResource resource) { try { return get(Pair.create(user, resource)); } catch (ExecutionException e) { throw new RuntimeException(e); } } }
/** * Used for View eviction from the schema * * @param view The view definition to evict */ private void unload(ViewDefinition view) { cfIdMap.remove(Pair.create(view.ksName, view.viewName)); }
public void setGossipTokens(Collection<Token> tokens) { List<Pair<ApplicationState, VersionedValue>> states = new ArrayList<Pair<ApplicationState, VersionedValue>>(); states.add(Pair.create(ApplicationState.TOKENS, valueFactory.tokens(tokens))); states.add(Pair.create(ApplicationState.STATUS, valueFactory.normal(tokens))); Gossiper.instance.addLocalApplicationStates(states); }
public static List<Pair<SSTableReader, Long>> createSSTableAndLengthPairs(Iterable<SSTableReader> sstables) { List<Pair<SSTableReader, Long>> sstableLengthPairs = new ArrayList<>(Iterables.size(sstables)); for(SSTableReader sstable : sstables) sstableLengthPairs.add(Pair.create(sstable, sstable.onDiskLength())); return sstableLengthPairs; }
public void addConditions(Collection<ColumnCondition> conds, QueryOptions options) throws InvalidRequestException { for (ColumnCondition condition : conds) { ColumnCondition.Bound current = condition.bind(options); conditions.put(Pair.create(condition.column.name, current.getCollectionElementValue()), current); } }
public Pair<AbstractBounds<T>, AbstractBounds<T>> split(T position) { assert contains(position) || left.equals(position); // Check if the split would have no effect on the range if (position.equals(left) || position.equals(right)) return null; AbstractBounds<T> lb = new Range<T>(left, position); AbstractBounds<T> rb = new Range<T>(position, right); return Pair.create(lb, rb); }
public Pair<AbstractBounds<T>, AbstractBounds<T>> split(T position) { assert contains(position) || left.equals(position); if (left.equals(position)) return null; AbstractBounds<T> lb = new Range<T>(left, position); AbstractBounds<T> rb = new ExcludingBounds<T>(position, right); return Pair.create(lb, rb); }
public static List<Pair<String, String>> loadPreparedStatements() { String query = String.format("SELECT logged_keyspace, query_string FROM %s.%s", SchemaConstants.SYSTEM_KEYSPACE_NAME, PREPARED_STATEMENTS); UntypedResultSet resultSet = executeOnceInternal(query); List<Pair<String, String>> r = new ArrayList<>(); for (UntypedResultSet.Row row : resultSet) r.add(Pair.create(row.has("logged_keyspace") ? row.getString("logged_keyspace") : null, row.getString("query_string"))); return r; } }
public void addRawUpdate(List<Pair<ColumnDefinition.Raw, Operation.RawUpdate>> operations, ColumnDefinition.Raw key, Operation.RawUpdate update) { for (Pair<ColumnDefinition.Raw, Operation.RawUpdate> p : operations) { if (p.left.equals(key) && !p.right.isCompatibleWith(update)) addRecognitionError("Multiple incompatible setting of column " + key); } operations.add(Pair.create(key, update)); }
public Pair<AbstractBounds<T>, AbstractBounds<T>> split(T position) { assert contains(position); // Check if the split would have no effect on the range if (position.equals(right)) return null; AbstractBounds<T> lb = new Bounds<T>(left, position); AbstractBounds<T> rb = new Range<T>(position, right); return Pair.create(lb, rb); }
public Pair<AbstractBounds<T>, AbstractBounds<T>> split(T position) { assert contains(position); AbstractBounds<T> lb = new Bounds<T>(left, position); AbstractBounds<T> rb = new ExcludingBounds<T>(position, right); return Pair.create(lb, rb); }
protected Pair<IndexedTerm, TokenTreeBuilder> computeNext() { if (!termIterator.hasNext()) return endOfData(); Term<ByteBuffer> term = termIterator.next(); return Pair.create(new IndexedTerm(term.getTerm(), false), term.getTokens().finish()); } }
public Pair<RowCacheKey, IRowCacheEntry> call() throws Exception { DecoratedKey key = cfs.decorateKey(buffer); int nowInSec = FBUtilities.nowInSeconds(); SinglePartitionReadCommand cmd = SinglePartitionReadCommand.fullPartitionRead(cfs.metadata, nowInSec, key); try (ReadExecutionController controller = cmd.executionController(); UnfilteredRowIterator iter = cmd.queryMemtableAndDisk(cfs, controller)) { CachedPartition toCache = CachedBTreePartition.create(DataLimits.cqlLimits(rowsToCache).filter(iter, nowInSec, true), nowInSec); return Pair.create(new RowCacheKey(cfs.metadata.ksAndCFName, key), (IRowCacheEntry)toCache); } } });