Refine search
private void ensureColumnFamilyExists(String keyspaceName, String columnfamilyName, AbstractType<?> comparator) throws BackendException { if (null != Schema.instance.getCFMetaData(keyspaceName, columnfamilyName)) return; CFMetaData cfm = new CFMetaData(keyspaceName, columnfamilyName, ColumnFamilyType.Standard, CellNames.fromAbstractType(comparator, true)); cfm.caching(CachingOptions.KEYS_ONLY); } else if (columnfamilyName.startsWith(Backend.INDEXSTORE_NAME)) { cfm.caching(CachingOptions.ROWS_ONLY); columnfamilyName, CompressionParameters.SSTABLE_COMPRESSION); cfm.compressionParameters(cp); cfm.addDefaultIndexNames(); } catch (ConfigurationException e) { throw new PermanentBackendException("Failed to create column family metadata for " + keyspaceName + ":" + columnfamilyName, e);
private static CFMetaData superCFMD(String ksName, String cfName, AbstractType subcc) { return new CFMetaData(ksName, cfName, ColumnFamilyType.Super, BytesType.instance, subcc).rebuild(); }
private static CFMetaData jdbcCFMD(String ksName, String cfName, AbstractType comp) { return new CFMetaData(ksName, cfName, ColumnFamilyType.Standard, comp, null) .defaultValidator(comp).rebuild(); }
public ColumnIdentifier getIdentifier(CFMetaData cfm) { if (!cfm.isStaticCompactTable()) return ColumnIdentifier.getInterned(text, true); AbstractType<?> thriftColumnNameType = cfm.thriftColumnNameType(); if (thriftColumnNameType instanceof UTF8Type) return ColumnIdentifier.getInterned(text, true); // We have a Thrift-created table with a non-text comparator. Check if we have a match column, otherwise assume we should use // thriftColumnNameType ByteBuffer bufferName = ByteBufferUtil.bytes(text); for (ColumnDefinition def : cfm.allColumns()) { if (def.name.bytes.equals(bufferName)) return def.name; } return ColumnIdentifier.getInterned(thriftColumnNameType, thriftColumnNameType.fromString(text), text); }
/** * This method returns the N endpoints that are responsible for storing the * specified key i.e for replication. * * @param keyspaceName keyspace name also known as keyspace * @param cf Column family name * @param key key for which we need to find the endpoint * @return the endpoint responsible for this key */ public List<InetAddress> getNaturalEndpoints(String keyspaceName, String cf, String key) { KeyspaceMetadata ksMetaData = Schema.instance.getKSMetaData(keyspaceName); if (ksMetaData == null) throw new IllegalArgumentException("Unknown keyspace '" + keyspaceName + "'"); CFMetaData cfMetaData = ksMetaData.getTableOrViewNullable(cf); if (cfMetaData == null) throw new IllegalArgumentException("Unknown table '" + cf + "' in keyspace '" + keyspaceName + "'"); return getNaturalEndpoints(keyspaceName, tokenMetadata.partitioner.getToken(cfMetaData.getKeyValidator().fromString(key))); }
public List<String> getSSTablesForKey(String key, boolean hexFormat) { ByteBuffer keyBuffer = hexFormat ? ByteBufferUtil.hexToBytes(key) : metadata.getKeyValidator().fromString(key); DecoratedKey dk = decorateKey(keyBuffer); try (OpOrder.Group op = readOrdering.start()) { List<String> files = new ArrayList<>(); for (SSTableReader sstr : select(View.select(SSTableSet.LIVE, dk)).sstables) { // check if the key actually exists in this sstable, without updating cache and stats if (sstr.getPosition(dk, SSTableReader.Operator.EQ, false) != null) files.add(sstr.getFilename()); } return files; } }
private void maybeLogLargePartitionWarning(DecoratedKey key, long rowSize) { if (rowSize > DatabaseDescriptor.getCompactionLargePartitionWarningThreshold()) { String keyString = metadata.getKeyValidator().getString(key.getKey()); logger.warn("Writing large partition {}/{}:{} ({}) to sstable {}", metadata.ksName, metadata.cfName, keyString, FBUtilities.prettyPrintMemory(rowSize), getFilename()); } }
public boolean announceMigration(boolean isLocalOnly) throws RequestValidationException CFMetaData cfm = Schema.instance.getCFMetaData(keyspace(), columnFamily()).copy(); IndexTarget target = rawTarget.prepare(cfm); logger.debug("Updating column {} definition for index {}", target.column, indexName); ColumnDefinition cd = cfm.getColumnDefinition(target.column); if (cd.type.isCollection() && cd.type.isMultiCell()) options = ImmutableMap.of(target.isCollectionKeys ? SecondaryIndex.INDEX_KEYS_OPTION_NAME : SecondaryIndex.INDEX_VALUES_OPTION_NAME, ""); cfm.addDefaultIndexNames(); MigrationManager.announceColumnFamilyUpdate(cfm, false, isLocalOnly); return true;
public enum Flag { SUPER, COUNTER, DENSE, COMPOUND }
defs.addAll(cfm.partitionKeyColumns()); defs.addAll(cfm.clusteringColumns()); if (cfm.isSuper() && cfm.isDense()) defs.add(cfm.superColumnValueColumn()); options, builder, FBUtilities.nowInSeconds());
public default String toCQLString(CFMetaData metadata) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < size(); i++) { ColumnDefinition c = metadata.clusteringColumns().get(i); sb.append(i == 0 ? "" : ", ").append(c.type.getString(get(i))); } return sb.toString(); }
dynamicCompositeCFMD(ks1, "DynamicComposite1"), cqlTestCf(ks1, "StandardLong1",UTF8Type.instance), standardCFMD(ks1, "StandardLong2").keyValidator(UTF8Type.instance), superCFMD(ks1, "Super1", BytesType.instance), superCFMD(ks1, "Super2", LongType.instance), indexCFMD(ks1, "Indexed2", false), new CFMetaData(ks1, "Counter1", st, bytes, null).replicateOnWrite(true).defaultValidator(CounterColumnType.instance).rebuild(), new CFMetaData(ks1, "Counter2", st, bytes, null).replicateOnWrite(true).defaultValidator(CounterColumnType.instance).rebuild(), new CFMetaData(ks1, "SuperCounter1", su, bytes, bytes).replicateOnWrite(true).defaultValidator(CounterColumnType.instance).rebuild(), jdbcCFMD(ks1, "JdbcInteger", IntegerType.instance), jdbcCFMD(ks1, "JdbcUtf8", UTF8Type.instance),
private static CFMetaData cqlTestCf(String ksName, String cfName, AbstractType comp) throws ConfigurationException { return new CFMetaData(ksName, cfName, ColumnFamilyType.Standard, comp, null) .keyValidator(UTF8Type.instance).columnMetadata(new HashMap<ByteBuffer, ColumnDefinition>() {{ ByteBuffer cName = ByteBuffer.wrap("birthyear".getBytes(Charsets.UTF_8)); put(cName, new ColumnDefinition(cName, LongType.instance, null, null, null,null, Type.REGULAR)); }}).rebuild(); } }
public AbstractType<?> getKeyType(String keyspace) { return Schema.instance.getCFMetaData(keyspace, columnFamily).getKeyValidator(); }
protected void appendCQLWhereClause(StringBuilder sb) { sb.append(" WHERE "); sb.append(ColumnDefinition.toCQLString(metadata().partitionKeyColumns())).append(" = "); DataRange.appendKeyString(sb, metadata().getKeyValidator(), partitionKey().getKey()); // We put the row filter first because the clustering index filter can end by "ORDER BY" if (!rowFilter().isEmpty()) sb.append(" AND ").append(rowFilter()); String filterString = clusteringIndexFilter().toCQLString(metadata()); if (!filterString.isEmpty()) sb.append(" AND ").append(filterString); }
private static ColumnDefinition makeDefinition(CFMetaData metadata, ByteBuffer name) { ColumnDefinition def = metadata.getColumnDefinition(name); if (def != null) return def; // In thrift, we actually allow expression on non-defined columns for the sake of filtering. To accomodate // this we create a "fake" definition. This is messy but it works so is probably good enough. return ColumnDefinition.regularDef(metadata, name, metadata.compactValueColumn().type); }
public boolean hasDroppedCollectionColumns() { for (DroppedColumn def : getDroppedColumns().values()) if (def.type instanceof CollectionType && def.type.isMultiCell()) return true; return false; }
public static Selection wildcard(CFMetaData cfm) { List<ColumnDefinition> all = new ArrayList<>(cfm.allColumns().size()); Iterators.addAll(all, cfm.allColumnsInSelectOrder()); return new SimpleSelection(cfm, all, true); }
public void build() AbstractType<?> keyValidator = cfs.metadata.getKeyValidator(); for (Map.Entry<SSTableReader, Map<ColumnDefinition, ColumnIndex>> e : sstables.entrySet()) ByteBufferUtil.readWithShortLength(dataFile); // key if (cfs.metadata.hasStaticColumns()) indexWriter.nextUnfilteredCluster(partition.staticRow());
public void validate(ClientState state) throws RequestValidationException KeyspaceMetadata ksm = Schema.instance.getKSMetaData(name.getKeyspace()); if (ksm == null) if (function.returnType().referencesUserType(name.getStringTypeName())) throw new InvalidRequestException(String.format("Cannot drop user type %s as it is still used by function %s", name, function)); if (argType.referencesUserType(name.getStringTypeName())) throw new InvalidRequestException(String.format("Cannot drop user type %s as it is still used by function %s", name, function)); for (ColumnDefinition def : cfm.allColumns()) if (def.type.referencesUserType(name.getStringTypeName())) throw new InvalidRequestException(String.format("Cannot drop user type %s as it is still used by table %s.%s", name, cfm.ksName, cfm.cfName));