* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* This class can be tricky to modify. Please read http://wiki.apache.org/cassandra/ConfigurationNotes for how to do so safely.

*/

    private static final Logger logger = LoggerFactory.getLogger(CFMetaData.class);

    public final static double DEFAULT_READ_REPAIR_CHANCE = 0.0;

    public final static double DEFAULT_DCLOCAL_READ_REPAIR_CHANCE = 0.1;

    public final static int DEFAULT_GC_GRACE_SECONDS = 864000;

    public final static int DEFAULT_MIN_COMPACTION_THRESHOLD = 4;

    public final static int DEFAULT_MAX_COMPACTION_THRESHOLD = 32;

    public final static Class<? extends AbstractCompactionStrategy> DEFAULT_COMPACTION_STRATEGY_CLASS = SizeTieredCompactionStrategy.class;

    public final static CachingOptions DEFAULT_CACHING_STRATEGY = CachingOptions.KEYS_ONLY;

    public final static int DEFAULT_DEFAULT_TIME_TO_LIVE = 0;

    public final static SpeculativeRetry DEFAULT_SPECULATIVE_RETRY = new SpeculativeRetry(SpeculativeRetry.RetryType.PERCENTILE, 0.99);

    public final static int DEFAULT_MIN_INDEX_INTERVAL = 128;

    public final static int DEFAULT_MAX_INDEX_INTERVAL = 2048;

    // Note that this is the default only for user created tables

    public final static String DEFAULT_COMPRESSOR = LZ4Compressor.class.getCanonicalName();

    // Note that this need to come *before* any CFMetaData is defined so before the compile below.

    private static final Comparator<ColumnDefinition> regularColumnComparator = new Comparator<ColumnDefinition>()

    {

        public int compare(ColumnDefinition def1, ColumnDefinition def2)

        {

            return ByteBufferUtil.compareUnsigned(def1.name.bytes, def2.name.bytes);

        }

    };

    public static final CFMetaData IndexCf = compile("CREATE TABLE \"" + SystemKeyspace.INDEX_CF + "\" ("

                                                             + "table_name text,"

                                                             + "index_name text,"

                                                             + "PRIMARY KEY (table_name, index_name)"

                                                             + ") WITH COMPACT STORAGE AND COMMENT='indexes that have been completed'");

    public static final CFMetaData SchemaKeyspacesCf = compile("CREATE TABLE " + SystemKeyspace.SCHEMA_KEYSPACES_CF + " ("

                                                                       + "keyspace_name text PRIMARY KEY,"

                                                                       + "durable_writes boolean,"

                                                                       + "strategy_class text,"

                                                                       + "strategy_options text"

                                                                       + ") WITH COMPACT STORAGE AND COMMENT='keyspace definitions' AND gc_grace_seconds=604800");

    public static final CFMetaData SchemaColumnFamiliesCf = compile("CREATE TABLE " + SystemKeyspace.SCHEMA_COLUMNFAMILIES_CF + " ("

                                                                            + "keyspace_name text,"

                                                                            + "columnfamily_name text,"

                                                                            + "cf_id uuid," // post-2.1 UUID cfid

                                                                            + "type text,"

                                                                            + "is_dense boolean,"

                                                                            + "comparator text,"

                                                                            + "subcomparator text,"

                                                                            + "comment text,"

                                                                            + "read_repair_chance double,"

                                                                            + "local_read_repair_chance double,"

                                                                            + "gc_grace_seconds int,"

                                                                            + "default_validator text,"

                                                                            + "key_validator text,"

                                                                            + "min_compaction_threshold int,"

                                                                            + "max_compaction_threshold int,"

                                                                            + "memtable_flush_period_in_ms int,"

                                                                            + "key_aliases text,"

                                                                            + "bloom_filter_fp_chance double,"

                                                                            + "caching text,"

                                                                            + "default_time_to_live int,"

                                                                            + "compaction_strategy_class text,"

                                                                            + "compression_parameters text,"

                                                                            + "value_alias text,"

                                                                            + "column_aliases text,"

                                                                            + "compaction_strategy_options text,"

                                                                            + "speculative_retry text,"

                                                                            + "index_interval int,"

                                                                            + "min_index_interval int,"

                                                                            + "max_index_interval int,"

                                                                            + "dropped_columns map<text, bigint>,"

                                                                            + "PRIMARY KEY (keyspace_name, columnfamily_name)"

                                                                            + ") WITH COMMENT='ColumnFamily definitions' AND gc_grace_seconds=604800");

    public static final CFMetaData SchemaColumnsCf = compile("CREATE TABLE " + SystemKeyspace.SCHEMA_COLUMNS_CF + " ("

                                                                     + "keyspace_name text,"

                                                                     + "columnfamily_name text,"

                                                                     + "column_name text,"

                                                                     + "validator text,"

                                                                     + "index_type text,"

                                                                     + "index_options text,"

                                                                     + "index_name text,"

                                                                     + "component_index int,"

                                                                     + "type text,"

                                                                     + "PRIMARY KEY(keyspace_name, columnfamily_name, column_name)"

                                                                     + ") WITH COMMENT='ColumnFamily column attributes' AND gc_grace_seconds=604800");

    public static final CFMetaData SchemaTriggersCf = compile("CREATE TABLE " + SystemKeyspace.SCHEMA_TRIGGERS_CF + " ("

                                                                      + "keyspace_name text,"

                                                                      + "columnfamily_name text,"

                                                                      + "trigger_name text,"

                                                                      + "trigger_options map<text, text>,"

                                                                      + "PRIMARY KEY (keyspace_name, columnfamily_name, trigger_name)"

                                                                      + ") WITH COMMENT='triggers metadata table' AND gc_grace_seconds=604800");

    public static final CFMetaData SchemaUserTypesCf = compile("CREATE TABLE " + SystemKeyspace.SCHEMA_USER_TYPES_CF + " ("

                                                                       + "keyspace_name text,"

                                                                       + "type_name text,"

                                                                       + "field_names list<text>,"

                                                                       + "field_types list<text>,"

                                                                       + "PRIMARY KEY (keyspace_name, type_name)"

                                                                       + ") WITH COMMENT='Defined user types' AND gc_grace_seconds=604800");

    public static final CFMetaData HintsCf = compile("CREATE TABLE " + SystemKeyspace.HINTS_CF + " ("

                                                             + "target_id uuid,"

                                                             + "hint_id timeuuid,"

                                                             + "message_version int,"

                                                             + "mutation blob,"

                                                             + "PRIMARY KEY (target_id, hint_id, message_version)"

                                                             + ") WITH COMPACT STORAGE "

                                                             + "AND COMPACTION={'class' : 'SizeTieredCompactionStrategy', 'enabled' : false} "

                                                             + "AND COMMENT='hints awaiting delivery'"

                                                             + "AND gc_grace_seconds=0");

    public static final CFMetaData PeersCf = compile("CREATE TABLE " + SystemKeyspace.PEERS_CF + " ("

                                                             + "peer inet PRIMARY KEY,"

                                                             + "host_id uuid,"

                                                             + "tokens set<varchar>,"

                                                             + "schema_version uuid,"

                                                             + "release_version text,"

                                                             + "rpc_address inet,"

                                                             + "preferred_ip inet,"

                                                             + "data_center text,"

                                                             + "rack text"

                                                             + ") WITH COMMENT='known peers in the cluster'");

    public static final CFMetaData PeerEventsCf = compile("CREATE TABLE " + SystemKeyspace.PEER_EVENTS_CF + " ("

                                                                  + "peer inet PRIMARY KEY,"

                                                                  + "hints_dropped map<uuid, int>"

                                                                  + ") WITH COMMENT='cf contains events related to peers'");

    public static final CFMetaData LocalCf = compile("CREATE TABLE " + SystemKeyspace.LOCAL_CF + " ("

                                                             + "key text PRIMARY KEY,"

                                                             + "tokens set<varchar>,"

                                                             + "cluster_name text,"

                                                             + "gossip_generation int,"

                                                             + "bootstrapped text,"

                                                             + "host_id uuid,"

                                                             + "release_version text,"

                                                             + "thrift_version text,"

                                                             + "cql_version text,"

                                                             + "native_protocol_version text,"

                                                             + "data_center text,"

                                                             + "rack text,"

                                                             + "partitioner text,"

                                                             + "schema_version uuid,"

                                                             + "truncated_at map<uuid, blob>"

                                                             + ") WITH COMMENT='information about the local node'");

    public static final CFMetaData TraceSessionsCf = compile("CREATE TABLE " + Tracing.SESSIONS_CF + " ("

                                                                     + "session_id uuid PRIMARY KEY,"

                                                                     + "coordinator inet,"

                                                                     + "request text,"

                                                                     + "started_at timestamp,"

                                                                     + "parameters map<text, text>,"

                                                                     + "duration int"

                                                                     + ") WITH COMMENT='traced sessions'",

                                                             Tracing.TRACE_KS);

    public static final CFMetaData TraceEventsCf = compile("CREATE TABLE " + Tracing.EVENTS_CF + " ("

                                                                   + "session_id uuid,"

                                                                   + "event_id timeuuid,"

                                                                   + "source inet,"

                                                                   + "thread text,"

                                                                   + "activity text,"

                                                                   + "source_elapsed int,"

                                                                   + "PRIMARY KEY (session_id, event_id)"

                                                                   + ")",

                                                           Tracing.TRACE_KS);

    public static final CFMetaData BatchlogCf = compile("CREATE TABLE " + SystemKeyspace.BATCHLOG_CF + " ("

                                                                + "id uuid PRIMARY KEY,"

                                                                + "written_at timestamp,"

                                                                + "data blob,"

                                                                + "version int,"

                                                                + ") WITH COMMENT='uncommited batches' AND gc_grace_seconds=0 "

                                                                + "AND COMPACTION={'class' : 'SizeTieredCompactionStrategy', 'min_threshold' : 2}");

    public static final CFMetaData RangeXfersCf = compile("CREATE TABLE " + SystemKeyspace.RANGE_XFERS_CF + " ("

                                                                  + "token_bytes blob PRIMARY KEY,"

                                                                  + "requested_at timestamp"

                                                                  + ") WITH COMMENT='ranges requested for transfer here'");

    public static final CFMetaData CompactionLogCf = compile("CREATE TABLE " + SystemKeyspace.COMPACTION_LOG + " ("

                                                                     + "id uuid PRIMARY KEY,"

                                                                     + "keyspace_name text,"

                                                                     + "columnfamily_name text,"

                                                                     + "inputs set<int>"

                                                                     + ") WITH COMMENT='unfinished compactions'");

    public static final CFMetaData PaxosCf = compile("CREATE TABLE " + SystemKeyspace.PAXOS_CF + " ("

                                                             + "row_key blob,"

                                                             + "cf_id UUID,"

                                                             + "in_progress_ballot timeuuid,"

                                                             + "proposal_ballot timeuuid,"

                                                             + "proposal blob,"

                                                             + "most_recent_commit_at timeuuid,"

                                                             + "most_recent_commit blob,"

                                                             + "PRIMARY KEY (row_key, cf_id)"

                                                             + ") WITH COMMENT='in-progress paxos proposals' "

                                                             + "AND COMPACTION={'class' : 'LeveledCompactionStrategy'}");

    public static final CFMetaData SSTableActivityCF = compile("CREATE TABLE " + SystemKeyspace.SSTABLE_ACTIVITY_CF + " ("

                                                                       + "keyspace_name text,"

                                                                       + "columnfamily_name text,"

                                                                       + "generation int,"

                                                                       + "rate_15m double,"

                                                                       + "rate_120m double,"

                                                                       + "PRIMARY KEY ((keyspace_name, columnfamily_name, generation))"

                                                                       + ") WITH COMMENT='historic sstable read rates'");

    public static final CFMetaData CompactionHistoryCf = compile("CREATE TABLE " + SystemKeyspace.COMPACTION_HISTORY_CF + " ("

                                                                         + "id uuid,"

                                                                         + "keyspace_name text,"

                                                                         + "columnfamily_name text,"

                                                                         + "compacted_at timestamp,"

                                                                         + "bytes_in bigint,"

                                                                         + "bytes_out bigint,"

                                                                         + "rows_merged map<int, bigint>,"

                                                                         + "PRIMARY KEY (id)"

                                                                         + ") WITH COMMENT='show all compaction history' AND DEFAULT_TIME_TO_LIVE=604800");

    public static class SpeculativeRetry

    {

        public enum RetryType

        {

            NONE, CUSTOM, PERCENTILE, ALWAYS

        }

        public final RetryType type;

        public final double value;

        private SpeculativeRetry(RetryType type, double value)

        {

            this.type = type;

            this.value = value;

        }

        public static SpeculativeRetry fromString(String retry) throws ConfigurationException

        {

            String name = retry.toUpperCase();

            try

            {

                if (name.endsWith(RetryType.PERCENTILE.toString()))

                {

                    double value = Double.parseDouble(name.substring(0, name.length() - 10));

                    if (value > 100 || value < 0)

                        throw new ConfigurationException("PERCENTILE should be between 0 and 100");

                    return new SpeculativeRetry(RetryType.PERCENTILE, (value / 100));

                }

                else if (name.endsWith("MS"))

                {

                    double value = Double.parseDouble(name.substring(0, name.length() - 2));

                    return new SpeculativeRetry(RetryType.CUSTOM, value);

                }

                else

                {

                    return new SpeculativeRetry(RetryType.valueOf(name), 0);

                }

            }

            catch (IllegalArgumentException e)

            {

                // ignore to throw the below exception.

            }

            throw new ConfigurationException("invalid speculative_retry type: " + retry);

        }

        @Override

        public boolean equals(Object obj)

        {

            if (!(obj instanceof SpeculativeRetry))

                return false;

            SpeculativeRetry rhs = (SpeculativeRetry) obj;

            return Objects.equal(type, rhs.type) && Objects.equal(value, rhs.value);

        }

        @Override

        public int hashCode()

        {

            return Objects.hashCode(type, value);

        }

        @Override

        public String toString()

        {

            switch (type)

            {

                case PERCENTILE:

                    // TODO switch to BigDecimal so round-tripping isn't lossy

                    return (value * 100) + "PERCENTILE";

                case CUSTOM:

                    return value + "ms";

                default:

                    return type.toString();

            }

        }

    }

    //REQUIRED

    public final UUID cfId;                           // internal id, never exposed to user

    public final String ksName;                       // name of keyspace

    public final String cfName;                       // name of this column family

    public final ColumnFamilyType cfType;             // standard, super

    public volatile CellNameType comparator;          // bytes, long, timeuuid, utf8, etc.

    //OPTIONAL

    private volatile String comment = "";

    private volatile double readRepairChance = DEFAULT_READ_REPAIR_CHANCE;

    private volatile double dcLocalReadRepairChance = DEFAULT_DCLOCAL_READ_REPAIR_CHANCE;

    private volatile int gcGraceSeconds = DEFAULT_GC_GRACE_SECONDS;

    private volatile AbstractType<?> defaultValidator = BytesType.instance;

    private volatile AbstractType<?> keyValidator = BytesType.instance;

    private volatile int minCompactionThreshold = DEFAULT_MIN_COMPACTION_THRESHOLD;

    private volatile int maxCompactionThreshold = DEFAULT_MAX_COMPACTION_THRESHOLD;

    private volatile Double bloomFilterFpChance = null;

    private volatile CachingOptions caching = DEFAULT_CACHING_STRATEGY;

    private volatile int minIndexInterval = DEFAULT_MIN_INDEX_INTERVAL;

    private volatile int maxIndexInterval = DEFAULT_MAX_INDEX_INTERVAL;

    private volatile int memtableFlushPeriod = 0;

    private volatile int defaultTimeToLive = DEFAULT_DEFAULT_TIME_TO_LIVE;

    private volatile SpeculativeRetry speculativeRetry = DEFAULT_SPECULATIVE_RETRY;

    private volatile Map<ColumnIdentifier, Long> droppedColumns = new HashMap<>();

    private volatile Map<String, TriggerDefinition> triggers = new HashMap<>();

    private volatile boolean isPurged = false;

    /*

     * All CQL3 columns definition are stored in the columnMetadata map.

     * On top of that, we keep separated collection of each kind of definition, to

     * 1) allow easy access to each kind and 2) for the partition key and

     * clustering key ones, those list are ordered by the "component index" of the

     * elements.

     */

    public static final String DEFAULT_KEY_ALIAS = "key";

    public static final String DEFAULT_COLUMN_ALIAS = "column";

    public static final String DEFAULT_VALUE_ALIAS = "value";

    // We call dense a CF for which each component of the comparator is a clustering column, i.e. no

    // component is used to store a regular column names. In other words, non-composite static "thrift"

    // and CQL3 CF are *not* dense.

    private volatile Boolean isDense; // null means "we don't know and need to infer from other data"

    private volatile Map<ByteBuffer, ColumnDefinition> columnMetadata = new HashMap<>();

    private volatile List<ColumnDefinition> partitionKeyColumns;  // Always of size keyValidator.componentsCount, null padded if necessary

    private volatile List<ColumnDefinition> clusteringColumns;    // Of size comparator.componentsCount or comparator.componentsCount -1, null padded if necessary

    private volatile SortedSet<ColumnDefinition> regularColumns;  // We use a sorted set so iteration is of predictable order (for SELECT for instance)

    private volatile SortedSet<ColumnDefinition> staticColumns;   // Same as above

    private volatile ColumnDefinition compactValueColumn;

    public volatile Class<? extends AbstractCompactionStrategy> compactionStrategyClass = DEFAULT_COMPACTION_STRATEGY_CLASS;

    public volatile Map<String, String> compactionStrategyOptions = new HashMap<>();

    public volatile CompressionParameters compressionParameters = new CompressionParameters(null);

    // attribute setters that return the modified CFMetaData instance

    public CFMetaData comment(String prop) { comment = Strings.nullToEmpty(prop); return this;}

    public CFMetaData readRepairChance(double prop) {readRepairChance = prop; return this;}

    public CFMetaData dcLocalReadRepairChance(double prop) {dcLocalReadRepairChance = prop; return this;}

    public CFMetaData gcGraceSeconds(int prop) {gcGraceSeconds = prop; return this;}

    public CFMetaData defaultValidator(AbstractType<?> prop) {defaultValidator = prop; return this;}

    public CFMetaData keyValidator(AbstractType<?> prop) {keyValidator = prop; return this;}

    public CFMetaData minCompactionThreshold(int prop) {minCompactionThreshold = prop; return this;}

    public CFMetaData maxCompactionThreshold(int prop) {maxCompactionThreshold = prop; return this;}

    public CFMetaData compactionStrategyClass(Class<? extends AbstractCompactionStrategy> prop) {compactionStrategyClass = prop; return this;}

    public CFMetaData compactionStrategyOptions(Map<String, String> prop) {compactionStrategyOptions = prop; return this;}

    public CFMetaData compressionParameters(CompressionParameters prop) {compressionParameters = prop; return this;}

    public CFMetaData bloomFilterFpChance(Double prop) {bloomFilterFpChance = prop; return this;}

    public CFMetaData caching(CachingOptions prop) {caching = prop; return this;}

    public CFMetaData minIndexInterval(int prop) {minIndexInterval = prop; return this;}

    public CFMetaData maxIndexInterval(int prop) {maxIndexInterval = prop; return this;}

    public CFMetaData memtableFlushPeriod(int prop) {memtableFlushPeriod = prop; return this;}

    public CFMetaData defaultTimeToLive(int prop) {defaultTimeToLive = prop; return this;}

    public CFMetaData speculativeRetry(SpeculativeRetry prop) {speculativeRetry = prop; return this;}

    public CFMetaData droppedColumns(Map<ColumnIdentifier, Long> cols) {droppedColumns = cols; return this;}

    public CFMetaData triggers(Map<String, TriggerDefinition> prop) {triggers = prop; return this;}

    public CFMetaData isDense(Boolean prop) {isDense = prop; return this;}

    /**

     * Create new ColumnFamily metadata with generated random ID.

     * When loading from existing schema, use CFMetaData

     *

     * @param keyspace keyspace name

     * @param name column family name

     * @param comp default comparator

     */

    public CFMetaData(String keyspace, String name, ColumnFamilyType type, CellNameType comp)

    {

        this(keyspace, name, type, comp, UUIDGen.getTimeUUID());

    }

    private CFMetaData(String keyspace, String name, ColumnFamilyType type, CellNameType comp, UUID id)

    {

        cfId = id;

        ksName = keyspace;

        cfName = name;

        cfType = type;

        comparator = comp;

    }

    public static CFMetaData denseCFMetaData(String keyspace, String name, AbstractType<?> comp, AbstractType<?> subcc)

    {

        CellNameType cellNameType = CellNames.fromAbstractType(makeRawAbstractType(comp, subcc), true);

        return new CFMetaData(keyspace, name, subcc == null ? ColumnFamilyType.Standard : ColumnFamilyType.Super, cellNameType);

    }

    public static CFMetaData sparseCFMetaData(String keyspace, String name, AbstractType<?> comp)

    {

        CellNameType cellNameType = CellNames.fromAbstractType(comp, false);

        return new CFMetaData(keyspace, name, ColumnFamilyType.Standard, cellNameType);

    }

    public static CFMetaData denseCFMetaData(String keyspace, String name, AbstractType<?> comp)

    {

        return denseCFMetaData(keyspace, name, comp, null);

    }

    private static AbstractType<?> makeRawAbstractType(AbstractType<?> comparator, AbstractType<?> subComparator)

    {

        return subComparator == null ? comparator : CompositeType.getInstance(Arrays.asList(comparator, subComparator));

    }

    public Map<String, TriggerDefinition> getTriggers()

    {

        return triggers;

    }

    private static CFMetaData compile(String cql)

    {

        return compile(cql, Keyspace.SYSTEM_KS);

    }

    @VisibleForTesting

    public static CFMetaData compile(String cql, String keyspace)

    {

        try

        {

            CFStatement parsed = (CFStatement)QueryProcessor.parseStatement(cql);

            parsed.prepareKeyspace(keyspace);

            CreateTableStatement statement = (CreateTableStatement) parsed.prepare().statement;

            CFMetaData cfm = newSystemMetadata(keyspace, statement.columnFamily(), "", statement.comparator);

            statement.applyPropertiesTo(cfm);

            return cfm.rebuild();

        }

        catch (RequestValidationException e)

        {

            throw new RuntimeException(e);

        }

    }

    /**

     * Generates deterministic UUID from keyspace/columnfamily name pair.

     * This is used to generate the same UUID for C* version < 2.1

     *

     * Since 2.1, this is only used for system columnfamilies and tests.

     */

    public static UUID generateLegacyCfId(String ksName, String cfName)

    {

        return UUID.nameUUIDFromBytes(ArrayUtils.addAll(ksName.getBytes(), cfName.getBytes()));

    }

    private static CFMetaData newSystemMetadata(String keyspace, String cfName, String comment, CellNameType comparator)

    {

        return new CFMetaData(keyspace, cfName, ColumnFamilyType.Standard, comparator, generateLegacyCfId(keyspace, cfName))

                .comment(comment)

                .readRepairChance(0)

                .dcLocalReadRepairChance(0)

                .gcGraceSeconds(0)

                .memtableFlushPeriod(3600 * 1000);

    }

    /**

     * Creates CFMetaData for secondary index CF.

     * Secondary index CF has the same CF ID as parent's.

     *

     * @param parent Parent CF where secondary index is created

     * @param info Column definition containing secondary index definition

     * @param indexComparator Comparator for secondary index

     * @return CFMetaData for secondary index

     */

    public static CFMetaData newIndexMetadata(CFMetaData parent, ColumnDefinition info, CellNameType indexComparator)

    {

        // Depends on parent's cache setting, turn on its index CF's cache.

        // Row caching is never enabled; see CASSANDRA-5732

        CachingOptions indexCaching = parent.getCaching().keyCache.isEnabled()

                ? CachingOptions.KEYS_ONLY

                : CachingOptions.NONE;

        return new CFMetaData(parent.ksName, parent.indexColumnFamilyName(info), ColumnFamilyType.Standard, indexComparator, parent.cfId)

                .keyValidator(info.type)

                .readRepairChance(0.0)

                .dcLocalReadRepairChance(0.0)

                .gcGraceSeconds(0)

                .caching(indexCaching)

                .speculativeRetry(parent.speculativeRetry)

                .compactionStrategyClass(parent.compactionStrategyClass)

                .compactionStrategyOptions(parent.compactionStrategyOptions)

                .reloadSecondaryIndexMetadata(parent)

                .rebuild();

    }

    public CFMetaData reloadSecondaryIndexMetadata(CFMetaData parent)

    {

        minCompactionThreshold(parent.minCompactionThreshold);

        maxCompactionThreshold(parent.maxCompactionThreshold);

        compactionStrategyClass(parent.compactionStrategyClass);

        compactionStrategyOptions(parent.compactionStrategyOptions);

        compressionParameters(parent.compressionParameters);

        return this;

    }

    public CFMetaData copy()

    {

        return copyOpts(new CFMetaData(ksName, cfName, cfType, comparator, cfId), this);

    }

    /**

     * Clones the CFMetaData, but sets a different cfId

     *

     * @param newCfId the cfId for the cloned CFMetaData

     * @return the cloned CFMetaData instance with the new cfId

     */

    public CFMetaData copy(UUID newCfId)

    {

        return copyOpts(new CFMetaData(ksName, cfName, cfType, comparator, newCfId), this);

    }

    static CFMetaData copyOpts(CFMetaData newCFMD, CFMetaData oldCFMD)

    {

        List<ColumnDefinition> clonedColumns = new ArrayList<>(oldCFMD.allColumns().size());

        for (ColumnDefinition cd : oldCFMD.allColumns())

            clonedColumns.add(cd.copy());

        return newCFMD.addAllColumnDefinitions(clonedColumns)

                .comment(oldCFMD.comment)

                .readRepairChance(oldCFMD.readRepairChance)

                .dcLocalReadRepairChance(oldCFMD.dcLocalReadRepairChance)

                .gcGraceSeconds(oldCFMD.gcGraceSeconds)

                .defaultValidator(oldCFMD.defaultValidator)

                .keyValidator(oldCFMD.keyValidator)

                .minCompactionThreshold(oldCFMD.minCompactionThreshold)

                .maxCompactionThreshold(oldCFMD.maxCompactionThreshold)

                .compactionStrategyClass(oldCFMD.compactionStrategyClass)

                .compactionStrategyOptions(new HashMap<>(oldCFMD.compactionStrategyOptions))

                .compressionParameters(oldCFMD.compressionParameters.copy())

                .bloomFilterFpChance(oldCFMD.bloomFilterFpChance)

                .caching(oldCFMD.caching)

                .defaultTimeToLive(oldCFMD.defaultTimeToLive)

                .minIndexInterval(oldCFMD.minIndexInterval)

                .maxIndexInterval(oldCFMD.maxIndexInterval)

                .speculativeRetry(oldCFMD.speculativeRetry)

                .memtableFlushPeriod(oldCFMD.memtableFlushPeriod)

                .droppedColumns(new HashMap<>(oldCFMD.droppedColumns))

                .triggers(new HashMap<>(oldCFMD.triggers))

                .isDense(oldCFMD.isDense)

                .rebuild();

    }

    /**

     * generate a column family name for an index corresponding to the given column.

     * This is NOT the same as the index's name! This is only used in sstable filenames and is not exposed to users.

     *

     * @param info A definition of the column with index

     *

     * @return name of the index ColumnFamily

     */

    public String indexColumnFamilyName(ColumnDefinition info)

    {

        // TODO simplify this when info.index_name is guaranteed to be set

        return cfName + Directories.SECONDARY_INDEX_NAME_SEPARATOR + (info.getIndexName() == null ? ByteBufferUtil.bytesToHex(info.name.bytes) : info.getIndexName());

    }

    public String getComment()

    {

        return comment;

    }

    public boolean isSuper()

    {

        return cfType == ColumnFamilyType.Super;

    }

    public double getReadRepairChance()

    {

        return readRepairChance;

    }

    public double getDcLocalReadRepair()

    {

        return dcLocalReadRepairChance;

    }

    public ReadRepairDecision newReadRepairDecision()

    {

        double chance = FBUtilities.threadLocalRandom().nextDouble();

        if (getReadRepairChance() > chance)

            return ReadRepairDecision.GLOBAL;

        if (getDcLocalReadRepair() > chance)

            return ReadRepairDecision.DC_LOCAL;

        return ReadRepairDecision.NONE;

    }

    public int getGcGraceSeconds()

    {

        return gcGraceSeconds;

    }

    public AbstractType<?> getDefaultValidator()

    {

        return defaultValidator;

    }

    public AbstractType<?> getKeyValidator()

    {

        return keyValidator;

    }

    public Integer getMinCompactionThreshold()

    {

        return minCompactionThreshold;

    }

    public Integer getMaxCompactionThreshold()

    {

        return maxCompactionThreshold;

    }

    // Used by CQL2 only.

    public String getCQL2KeyName()

    {

        if (partitionKeyColumns.size() > 1)

            throw new IllegalStateException("Cannot acces column family with composite key from CQL < 3.0.0");

        // For compatibility sake, we uppercase if it's the default alias as we used to return it that way in resultsets.

        String str = partitionKeyColumns.get(0).name.toString();

        return str.equalsIgnoreCase(DEFAULT_KEY_ALIAS) ? str.toUpperCase() : str;

    }

    public CompressionParameters compressionParameters()

    {

        return compressionParameters;

    }

    public Collection<ColumnDefinition> allColumns()

    {

        return columnMetadata.values();

    }

    // An iterator over all column definitions but that respect the order of a SELECT *.

    public Iterator<ColumnDefinition> allColumnsInSelectOrder()

    {

        return new AbstractIterator<ColumnDefinition>()

        {

            private final Iterator<ColumnDefinition> partitionKeyIter = partitionKeyColumns.iterator();

            private final Iterator<ColumnDefinition> clusteringIter = clusteringColumns.iterator();

            private boolean valueDone;

            private final Iterator<ColumnDefinition> staticIter = staticColumns.iterator();

            private final Iterator<ColumnDefinition> regularIter = regularColumns.iterator();

            protected ColumnDefinition computeNext()

            {

                if (partitionKeyIter.hasNext())

                    return partitionKeyIter.next();

                if (clusteringIter.hasNext())

                    return clusteringIter.next();

                if (staticIter.hasNext())

                    return staticIter.next();

                if (compactValueColumn != null && !valueDone)

                {

                    valueDone = true;

                    // If the compactValueColumn is empty, this means we have a dense table but

                    // with only a PK. As far as selects are concerned, we should ignore the value.

                    if (compactValueColumn.name.bytes.hasRemaining())

                        return compactValueColumn;

                }

                if (regularIter.hasNext())

                    return regularIter.next();

                return endOfData();

            }

        };

    }

    public List<ColumnDefinition> partitionKeyColumns()

    {

        return partitionKeyColumns;

    }

    public List<ColumnDefinition> clusteringColumns()

    {

        return clusteringColumns;

    }

    public Set<ColumnDefinition> regularColumns()

    {

        return regularColumns;

    }

    public Set<ColumnDefinition> staticColumns()

    {

        return staticColumns;

    }

    public Iterable<ColumnDefinition> regularAndStaticColumns()

    {

        return Iterables.concat(staticColumns, regularColumns);

    }

    public ColumnDefinition compactValueColumn()

    {

        return compactValueColumn;

    }

    // TODO: we could use CType for key validation too to make this unnecessary but

    // it's unclear it would be a win overall

    public CType getKeyValidatorAsCType()

    {

        return keyValidator instanceof CompositeType

                ? new CompoundCType(((CompositeType) keyValidator).types)

                : new SimpleCType(keyValidator);

    }

    public double getBloomFilterFpChance()

    {

        // we disallow bFFPC==null starting in 1.2.1 but tolerated it before that

        return (bloomFilterFpChance == null || bloomFilterFpChance == 0)

                ? compactionStrategyClass == LeveledCompactionStrategy.class ? 0.1 : 0.01

                : bloomFilterFpChance;

    }

    public CachingOptions getCaching()

    {

        return caching;

    }

    public int getMinIndexInterval()

    {

        return minIndexInterval;

    }

    public int getMaxIndexInterval()

    {

        return maxIndexInterval;

    }

    public SpeculativeRetry getSpeculativeRetry()

    {

        return speculativeRetry;

    }

    public int getMemtableFlushPeriod()

    {

        return memtableFlushPeriod;

    }

    public int getDefaultTimeToLive()

    {

        return defaultTimeToLive;

    }

    public Map<ColumnIdentifier, Long> getDroppedColumns()

    {

        return droppedColumns;

    }

    public Boolean getIsDense()

    {

        return isDense;

    }

    @Override

    public boolean equals(Object o)

    {

        if (this == o)

            return true;

        if (!(o instanceof CFMetaData))

            return false;

        CFMetaData other = (CFMetaData) o;

        return Objects.equal(cfId, other.cfId)

                && Objects.equal(ksName, other.ksName)

                && Objects.equal(cfName, other.cfName)

                && Objects.equal(cfType, other.cfType)

                && Objects.equal(comparator, other.comparator)

                && Objects.equal(comment, other.comment)

                && Objects.equal(readRepairChance, other.readRepairChance)

                && Objects.equal(dcLocalReadRepairChance, other.dcLocalReadRepairChance)

                && Objects.equal(gcGraceSeconds, other.gcGraceSeconds)

                && Objects.equal(defaultValidator, other.defaultValidator)

                && Objects.equal(keyValidator, other.keyValidator)

                && Objects.equal(minCompactionThreshold, other.minCompactionThreshold)

                && Objects.equal(maxCompactionThreshold, other.maxCompactionThreshold)

                && Objects.equal(columnMetadata, other.columnMetadata)

                && Objects.equal(compactionStrategyClass, other.compactionStrategyClass)

                && Objects.equal(compactionStrategyOptions, other.compactionStrategyOptions)

                && Objects.equal(compressionParameters, other.compressionParameters)

                && Objects.equal(bloomFilterFpChance, other.bloomFilterFpChance)

                && Objects.equal(memtableFlushPeriod, other.memtableFlushPeriod)

                && Objects.equal(caching, other.caching)

                && Objects.equal(defaultTimeToLive, other.defaultTimeToLive)

                && Objects.equal(minIndexInterval, other.minIndexInterval)

                && Objects.equal(maxIndexInterval, other.maxIndexInterval)

                && Objects.equal(speculativeRetry, other.speculativeRetry)

                && Objects.equal(droppedColumns, other.droppedColumns)

                && Objects.equal(triggers, other.triggers)

                && Objects.equal(isDense, other.isDense);

    }

    @Override

    public int hashCode()

    {

        return new HashCodeBuilder(29, 1597)

                .append(cfId)

                .append(ksName)

                .append(cfName)

                .append(cfType)

                .append(comparator)

                .append(comment)

                .append(readRepairChance)

                .append(dcLocalReadRepairChance)

                .append(gcGraceSeconds)

                .append(defaultValidator)

                .append(keyValidator)

                .append(minCompactionThreshold)

                .append(maxCompactionThreshold)

                .append(columnMetadata)

                .append(compactionStrategyClass)

                .append(compactionStrategyOptions)