cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tylerho...@apache.org
Subject [2/2] cassandra git commit: Merge branch 'cassandra-2.2' into cassandra-3.0
Date Tue, 21 Jun 2016 16:14:53 GMT
Merge branch 'cassandra-2.2' into cassandra-3.0


Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/621d08a1
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/621d08a1
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/621d08a1

Branch: refs/heads/cassandra-3.0
Commit: 621d08a1464d43d828c8eceed57f45268e89a3c3
Parents: 723a143 9e85e85
Author: Tyler Hobbs <tylerlhobbs@gmail.com>
Authored: Tue Jun 21 11:13:12 2016 -0500
Committer: Tyler Hobbs <tylerlhobbs@gmail.com>
Committed: Tue Jun 21 11:13:12 2016 -0500

----------------------------------------------------------------------
 CHANGES.txt                                     |  2 +
 .../apache/cassandra/schema/TableParams.java    |  7 ++-
 .../cassandra/utils/BloomCalculations.java      | 15 +++++-
 .../schema/CreateTableValidationTest.java       | 51 ++++++++++++++++++++
 4 files changed, 71 insertions(+), 4 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cassandra/blob/621d08a1/CHANGES.txt
----------------------------------------------------------------------
diff --cc CHANGES.txt
index cc682c4,36009c5..134a5e1
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@@ -1,33 -1,9 +1,35 @@@
 -2.2.7
 +3.0.8
 + * Fix upgrading schema with super columns with non-text subcomparators (CASSANDRA-12023)
 + * Add TimeWindowCompactionStrategy (CASSANDRA-9666)
 +Merged from 2.2:
+  * Validate bloom_filter_fp_chance against lowest supported
+    value when the table is created (CASSANDRA-11920)
 - * RandomAccessReader: call isEOF() only when rebuffering, not for every read operation
(CASSANDRA-12013)
   * Don't send erroneous NEW_NODE notifications on restart (CASSANDRA-11038)
   * StorageService shutdown hook should use a volatile variable (CASSANDRA-11984)
 +Merged from 2.1:
 + * Cache local ranges when calculating repair neighbors (CASSANDRA-11934)
 + * Allow LWT operation on static column with only partition keys (CASSANDRA-10532)
 + * Create interval tree over canonical sstables to avoid missing sstables during streaming
(CASSANDRA-11886)
 + * cqlsh COPY FROM: shutdown parent cluster after forking, to avoid corrupting SSL connections
(CASSANDRA-11749)
 +
 +
 +3.0.7
 + * Fix legacy serialization of Thrift-generated non-compound range tombstones
 +   when communicating with 2.x nodes (CASSANDRA-11930)
 + * Fix Directories instantiations where CFS.initialDirectories should be used (CASSANDRA-11849)
 + * Avoid referencing DatabaseDescriptor in AbstractType (CASSANDRA-11912)
 + * Fix sstables not being protected from removal during index build (CASSANDRA-11905)
 + * cqlsh: Suppress stack trace from Read/WriteFailures (CASSANDRA-11032)
 + * Remove unneeded code to repair index summaries that have
 +   been improperly down-sampled (CASSANDRA-11127)
 + * Avoid WriteTimeoutExceptions during commit log replay due to materialized
 +   view lock contention (CASSANDRA-11891)
 + * Prevent OOM failures on SSTable corruption, improve tests for corruption detection (CASSANDRA-9530)
 + * Use CFS.initialDirectories when clearing snapshots (CASSANDRA-11705)
 + * Allow compaction strategies to disable early open (CASSANDRA-11754)
 + * Refactor Materialized View code (CASSANDRA-11475)
 + * Update Java Driver (CASSANDRA-11615)
 +Merged from 2.2:
   * Persist local metadata earlier in startup sequence (CASSANDRA-11742)
   * Run CommitLog tests with different compression settings (CASSANDRA-9039)
   * cqlsh: fix tab completion for case-sensitive identifiers (CASSANDRA-11664)

http://git-wip-us.apache.org/repos/asf/cassandra/blob/621d08a1/src/java/org/apache/cassandra/schema/TableParams.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/schema/TableParams.java
index 7e44e73,0000000..29d3e29
mode 100644,000000..100644
--- a/src/java/org/apache/cassandra/schema/TableParams.java
+++ b/src/java/org/apache/cassandra/schema/TableParams.java
@@@ -1,377 -1,0 +1,380 @@@
 +/*
 + * 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.
 + */
 +package org.apache.cassandra.schema;
 +
 +import java.nio.ByteBuffer;
 +import java.util.Map;
 +
 +import com.google.common.base.MoreObjects;
 +import com.google.common.base.Objects;
 +import com.google.common.collect.ImmutableMap;
 +
 +import org.apache.cassandra.exceptions.ConfigurationException;
++import org.apache.cassandra.utils.BloomCalculations;
 +import static java.lang.String.format;
 +
 +public final class TableParams
 +{
 +    public static final TableParams DEFAULT = TableParams.builder().build();
 +
 +    public enum Option
 +    {
 +        BLOOM_FILTER_FP_CHANCE,
 +        CACHING,
 +        COMMENT,
 +        COMPACTION,
 +        COMPRESSION,
 +        DCLOCAL_READ_REPAIR_CHANCE,
 +        DEFAULT_TIME_TO_LIVE,
 +        EXTENSIONS,
 +        GC_GRACE_SECONDS,
 +        MAX_INDEX_INTERVAL,
 +        MEMTABLE_FLUSH_PERIOD_IN_MS,
 +        MIN_INDEX_INTERVAL,
 +        READ_REPAIR_CHANCE,
 +        SPECULATIVE_RETRY,
 +        CRC_CHECK_CHANCE;
 +
 +        @Override
 +        public String toString()
 +        {
 +            return name().toLowerCase();
 +        }
 +    }
 +
 +    public static final String DEFAULT_COMMENT = "";
 +    public static final double DEFAULT_READ_REPAIR_CHANCE = 0.0;
 +    public static final double DEFAULT_DCLOCAL_READ_REPAIR_CHANCE = 0.1;
 +    public static final int DEFAULT_GC_GRACE_SECONDS = 864000; // 10 days
 +    public static final int DEFAULT_DEFAULT_TIME_TO_LIVE = 0;
 +    public static final int DEFAULT_MEMTABLE_FLUSH_PERIOD_IN_MS = 0;
 +    public static final int DEFAULT_MIN_INDEX_INTERVAL = 128;
 +    public static final int DEFAULT_MAX_INDEX_INTERVAL = 2048;
 +    public static final double DEFAULT_CRC_CHECK_CHANCE = 1.0;
 +
 +    public final String comment;
 +    public final double readRepairChance;
 +    public final double dcLocalReadRepairChance;
 +    public final double bloomFilterFpChance;
 +    public final double crcCheckChance;
 +    public final int gcGraceSeconds;
 +    public final int defaultTimeToLive;
 +    public final int memtableFlushPeriodInMs;
 +    public final int minIndexInterval;
 +    public final int maxIndexInterval;
 +    public final SpeculativeRetryParam speculativeRetry;
 +    public final CachingParams caching;
 +    public final CompactionParams compaction;
 +    public final CompressionParams compression;
 +    public final ImmutableMap<String, ByteBuffer> extensions;
 +
 +    private TableParams(Builder builder)
 +    {
 +        comment = builder.comment;
 +        readRepairChance = builder.readRepairChance;
 +        dcLocalReadRepairChance = builder.dcLocalReadRepairChance;
 +        bloomFilterFpChance = builder.bloomFilterFpChance == null
 +                            ? builder.compaction.defaultBloomFilterFbChance()
 +                            : builder.bloomFilterFpChance;
 +        crcCheckChance = builder.crcCheckChance;
 +        gcGraceSeconds = builder.gcGraceSeconds;
 +        defaultTimeToLive = builder.defaultTimeToLive;
 +        memtableFlushPeriodInMs = builder.memtableFlushPeriodInMs;
 +        minIndexInterval = builder.minIndexInterval;
 +        maxIndexInterval = builder.maxIndexInterval;
 +        speculativeRetry = builder.speculativeRetry;
 +        caching = builder.caching;
 +        compaction = builder.compaction;
 +        compression = builder.compression;
 +        extensions = builder.extensions;
 +    }
 +
 +    public static Builder builder()
 +    {
 +        return new Builder();
 +    }
 +
 +    public static Builder builder(TableParams params)
 +    {
 +        return new Builder().bloomFilterFpChance(params.bloomFilterFpChance)
 +                            .caching(params.caching)
 +                            .comment(params.comment)
 +                            .compaction(params.compaction)
 +                            .compression(params.compression)
 +                            .dcLocalReadRepairChance(params.dcLocalReadRepairChance)
 +                            .crcCheckChance(params.crcCheckChance)
 +                            .defaultTimeToLive(params.defaultTimeToLive)
 +                            .gcGraceSeconds(params.gcGraceSeconds)
 +                            .maxIndexInterval(params.maxIndexInterval)
 +                            .memtableFlushPeriodInMs(params.memtableFlushPeriodInMs)
 +                            .minIndexInterval(params.minIndexInterval)
 +                            .readRepairChance(params.readRepairChance)
 +                            .speculativeRetry(params.speculativeRetry)
 +                            .extensions(params.extensions);
 +    }
 +
 +    public void validate()
 +    {
 +        compaction.validate();
 +        compression.validate();
 +
-         if (bloomFilterFpChance <= 0 || bloomFilterFpChance > 1)
++        double minBloomFilterFpChanceValue = BloomCalculations.minSupportedBloomFilterFpChance();
++        if (bloomFilterFpChance <=  minBloomFilterFpChanceValue || bloomFilterFpChance
> 1)
 +        {
-             fail("%s must be larger than 0.0 and less than or equal to 1.0 (got %s)",
++            fail("%s must be larger than %s and less than or equal to 1.0 (got %s)",
 +                 Option.BLOOM_FILTER_FP_CHANCE,
++                 minBloomFilterFpChanceValue,
 +                 bloomFilterFpChance);
 +        }
 +
 +        if (dcLocalReadRepairChance < 0 || dcLocalReadRepairChance > 1.0)
 +        {
 +            fail("%s must be larger than or equal to 0 and smaller than or equal to 1.0
(got %s)",
 +                 Option.DCLOCAL_READ_REPAIR_CHANCE,
 +                 dcLocalReadRepairChance);
 +        }
 +
 +        if (readRepairChance < 0 || readRepairChance > 1.0)
 +        {
 +            fail("%s must be larger than or equal to 0 and smaller than or equal to 1.0
(got %s)",
 +                 Option.READ_REPAIR_CHANCE,
 +                 readRepairChance);
 +        }
 +
 +        if (crcCheckChance < 0 || crcCheckChance > 1.0)
 +        {
 +            fail("%s must be larger than or equal to 0 and smaller than or equal to 1.0
(got %s)",
 +                 Option.CRC_CHECK_CHANCE,
 +                 crcCheckChance);
 +        }
 +
 +        if (defaultTimeToLive < 0)
 +            fail("%s must be greater than or equal to 0 (got %s)", Option.DEFAULT_TIME_TO_LIVE,
defaultTimeToLive);
 +
 +        if (gcGraceSeconds < 0)
 +            fail("%s must be greater than or equal to 0 (got %s)", Option.GC_GRACE_SECONDS,
gcGraceSeconds);
 +
 +        if (minIndexInterval < 1)
 +            fail("%s must be greater than or equal to 1 (got %s)", Option.MIN_INDEX_INTERVAL,
minIndexInterval);
 +
 +        if (maxIndexInterval < minIndexInterval)
 +        {
 +            fail("%s must be greater than or equal to %s (%s) (got %s)",
 +                 Option.MAX_INDEX_INTERVAL,
 +                 Option.MIN_INDEX_INTERVAL,
 +                 minIndexInterval,
 +                 maxIndexInterval);
 +        }
 +
 +        if (memtableFlushPeriodInMs < 0)
 +            fail("%s must be greater than or equal to 0 (got %s)", Option.MEMTABLE_FLUSH_PERIOD_IN_MS,
memtableFlushPeriodInMs);
 +    }
 +
 +    private static void fail(String format, Object... args)
 +    {
 +        throw new ConfigurationException(format(format, args));
 +    }
 +
 +    @Override
 +    public boolean equals(Object o)
 +    {
 +        if (this == o)
 +            return true;
 +
 +        if (!(o instanceof TableParams))
 +            return false;
 +
 +        TableParams p = (TableParams) o;
 +
 +        return comment.equals(p.comment)
 +            && readRepairChance == p.readRepairChance
 +            && dcLocalReadRepairChance == p.dcLocalReadRepairChance
 +            && bloomFilterFpChance == p.bloomFilterFpChance
 +            && crcCheckChance == p.crcCheckChance
 +            && gcGraceSeconds == p.gcGraceSeconds
 +            && defaultTimeToLive == p.defaultTimeToLive
 +            && memtableFlushPeriodInMs == p.memtableFlushPeriodInMs
 +            && minIndexInterval == p.minIndexInterval
 +            && maxIndexInterval == p.maxIndexInterval
 +            && speculativeRetry.equals(p.speculativeRetry)
 +            && caching.equals(p.caching)
 +            && compaction.equals(p.compaction)
 +            && compression.equals(p.compression)
 +            && extensions.equals(p.extensions);
 +    }
 +
 +    @Override
 +    public int hashCode()
 +    {
 +        return Objects.hashCode(comment,
 +                                readRepairChance,
 +                                dcLocalReadRepairChance,
 +                                bloomFilterFpChance,
 +                                crcCheckChance,
 +                                gcGraceSeconds,
 +                                defaultTimeToLive,
 +                                memtableFlushPeriodInMs,
 +                                minIndexInterval,
 +                                maxIndexInterval,
 +                                speculativeRetry,
 +                                caching,
 +                                compaction,
 +                                compression,
 +                                extensions);
 +    }
 +
 +    @Override
 +    public String toString()
 +    {
 +        return MoreObjects.toStringHelper(this)
 +                          .add(Option.COMMENT.toString(), comment)
 +                          .add(Option.READ_REPAIR_CHANCE.toString(), readRepairChance)
 +                          .add(Option.DCLOCAL_READ_REPAIR_CHANCE.toString(), dcLocalReadRepairChance)
 +                          .add(Option.BLOOM_FILTER_FP_CHANCE.toString(), bloomFilterFpChance)
 +                          .add(Option.CRC_CHECK_CHANCE.toString(), crcCheckChance)
 +                          .add(Option.GC_GRACE_SECONDS.toString(), gcGraceSeconds)
 +                          .add(Option.DEFAULT_TIME_TO_LIVE.toString(), defaultTimeToLive)
 +                          .add(Option.MEMTABLE_FLUSH_PERIOD_IN_MS.toString(), memtableFlushPeriodInMs)
 +                          .add(Option.MIN_INDEX_INTERVAL.toString(), minIndexInterval)
 +                          .add(Option.MAX_INDEX_INTERVAL.toString(), maxIndexInterval)
 +                          .add(Option.SPECULATIVE_RETRY.toString(), speculativeRetry)
 +                          .add(Option.CACHING.toString(), caching)
 +                          .add(Option.COMPACTION.toString(), compaction)
 +                          .add(Option.COMPRESSION.toString(), compression)
 +                          .add(Option.EXTENSIONS.toString(), extensions)
 +                          .toString();
 +    }
 +
 +    public static final class Builder
 +    {
 +        private String comment = DEFAULT_COMMENT;
 +        private double readRepairChance = DEFAULT_READ_REPAIR_CHANCE;
 +        private double dcLocalReadRepairChance = DEFAULT_DCLOCAL_READ_REPAIR_CHANCE;
 +        private Double bloomFilterFpChance;
 +        public Double crcCheckChance = DEFAULT_CRC_CHECK_CHANCE;
 +        private int gcGraceSeconds = DEFAULT_GC_GRACE_SECONDS;
 +        private int defaultTimeToLive = DEFAULT_DEFAULT_TIME_TO_LIVE;
 +        private int memtableFlushPeriodInMs = DEFAULT_MEMTABLE_FLUSH_PERIOD_IN_MS;
 +        private int minIndexInterval = DEFAULT_MIN_INDEX_INTERVAL;
 +        private int maxIndexInterval = DEFAULT_MAX_INDEX_INTERVAL;
 +        private SpeculativeRetryParam speculativeRetry = SpeculativeRetryParam.DEFAULT;
 +        private CachingParams caching = CachingParams.DEFAULT;
 +        private CompactionParams compaction = CompactionParams.DEFAULT;
 +        private CompressionParams compression = CompressionParams.DEFAULT;
 +        private ImmutableMap<String, ByteBuffer> extensions = ImmutableMap.of();
 +
 +        public Builder()
 +        {
 +        }
 +
 +        public TableParams build()
 +        {
 +            return new TableParams(this);
 +        }
 +
 +        public Builder comment(String val)
 +        {
 +            comment = val;
 +            return this;
 +        }
 +
 +        public Builder readRepairChance(double val)
 +        {
 +            readRepairChance = val;
 +            return this;
 +        }
 +
 +        public Builder dcLocalReadRepairChance(double val)
 +        {
 +            dcLocalReadRepairChance = val;
 +            return this;
 +        }
 +
 +        public Builder bloomFilterFpChance(double val)
 +        {
 +            bloomFilterFpChance = val;
 +            return this;
 +        }
 +
 +        public Builder crcCheckChance(double val)
 +        {
 +            crcCheckChance = val;
 +            return this;
 +        }
 +
 +        public Builder gcGraceSeconds(int val)
 +        {
 +            gcGraceSeconds = val;
 +            return this;
 +        }
 +
 +        public Builder defaultTimeToLive(int val)
 +        {
 +            defaultTimeToLive = val;
 +            return this;
 +        }
 +
 +        public Builder memtableFlushPeriodInMs(int val)
 +        {
 +            memtableFlushPeriodInMs = val;
 +            return this;
 +        }
 +
 +        public Builder minIndexInterval(int val)
 +        {
 +            minIndexInterval = val;
 +            return this;
 +        }
 +
 +        public Builder maxIndexInterval(int val)
 +        {
 +            maxIndexInterval = val;
 +            return this;
 +        }
 +
 +        public Builder speculativeRetry(SpeculativeRetryParam val)
 +        {
 +            speculativeRetry = val;
 +            return this;
 +        }
 +
 +        public Builder caching(CachingParams val)
 +        {
 +            caching = val;
 +            return this;
 +        }
 +
 +        public Builder compaction(CompactionParams val)
 +        {
 +            compaction = val;
 +            return this;
 +        }
 +
 +        public Builder compression(CompressionParams val)
 +        {
 +            compression = val;
 +            return this;
 +        }
 +
 +        public Builder extensions(Map<String, ByteBuffer> val)
 +        {
 +            extensions = ImmutableMap.copyOf(val);
 +            return this;
 +        }
 +    }
 +}


Mime
View raw message