cassandra-driver 3.0.0.rc.1-java → 3.0.0.rc.2-java

data/lib/cassandra/protocol/responses/set_keyspace_result_response.rb

@@ -19,6 +19,9 @@
 module Cassandra
   module Protocol
     class SetKeyspaceResultResponse < ResultResponse
+      # @private
+      RESULT_TYPES[0x03] = self
+
       attr_reader :keyspace
 
       def initialize(custom_payload, warnings, keyspace, trace_id)
@@ -29,10 +32,6 @@ module Cassandra
       def to_s
         %(RESULT SET_KEYSPACE "#{@keyspace}")
       end
-
-      private
-
-      RESULT_TYPES[0x03] = self
     end
   end
 end

data/lib/cassandra/protocol/responses/status_change_event_response.rb

@@ -21,6 +21,9 @@ module Cassandra
     class StatusChangeEventResponse < EventResponse
       TYPE = 'STATUS_CHANGE'.freeze
 
+      # @private
+      EVENT_TYPES[TYPE] = self
+
       attr_reader :type, :change, :address, :port
 
       def initialize(*args)
@@ -31,10 +34,6 @@ module Cassandra
       def to_s
         %(EVENT #{@type} #{@change} #{@address}:#{@port})
       end
-
-      private
-
-      EVENT_TYPES[TYPE] = self
     end
   end
 end

data/lib/cassandra/protocol/responses/supported_response.rb

@@ -19,6 +19,9 @@
 module Cassandra
   module Protocol
     class SupportedResponse < Response
+      # @private
+      RESPONSE_TYPES[0x06] = self
+
       attr_reader :options
 
       def initialize(options)
@@ -28,10 +31,6 @@ module Cassandra
       def to_s
         %(SUPPORTED #{options})
       end
-
-      private
-
-      RESPONSE_TYPES[0x06] = self
     end
   end
 end

data/lib/cassandra/protocol/responses/topology_change_event_response.rb

@@ -21,14 +21,13 @@ module Cassandra
     class TopologyChangeEventResponse < StatusChangeEventResponse
       TYPE = 'TOPOLOGY_CHANGE'.freeze
 
+      # @private
+      EVENT_TYPES[TYPE] = self
+
       def initialize(*args)
         super
         @type = TYPE
       end
-
-      private
-
-      EVENT_TYPES[TYPE] = self
     end
   end
 end

data/lib/cassandra/protocol/responses/void_result_response.rb

@@ -19,6 +19,9 @@
 module Cassandra
   module Protocol
     class VoidResultResponse < ResultResponse
+      # @private
+      RESULT_TYPES[0x01] = self
+
       def to_s
         %(RESULT VOID)
       end
@@ -26,10 +29,6 @@ module Cassandra
       def void?
         true
       end
-
-      private
-
-      RESULT_TYPES[0x01] = self
     end
   end
 end

data/lib/cassandra/protocol/v1.rb

@@ -155,8 +155,6 @@ module Cassandra
           end
         end
 
-        private
-
         CODE_ERROR          = 0x00
         CODE_READY          = 0x02
         CODE_AUTHENTICATE   = 0x03
@@ -258,9 +256,7 @@ module Cassandra
               id = buffer.read_short_bytes
               params_metadata = Coder.read_metadata_v1(buffer).first
               result_metadata = nil
-              if protocol_version > 1
-                result_metadata = Coder.read_metadata_v1(buffer).first
-              end
+              result_metadata = Coder.read_metadata_v1(buffer).first if protocol_version > 1
 
               PreparedResultResponse.new(nil,
                                          nil,

data/lib/cassandra/protocol/v3.rb

@@ -290,9 +290,7 @@ module Cassandra
               id = buffer.read_short_bytes
               params_metadata = Coder.read_metadata_v3(buffer).first
               result_metadata = nil
-              if protocol_version > 1
-                result_metadata = Coder.read_metadata_v3(buffer).first
-              end
+              result_metadata = Coder.read_metadata_v3(buffer).first if protocol_version > 1
 
               PreparedResultResponse.new(nil,
                                          nil,

data/lib/cassandra/result.rb

@@ -96,7 +96,8 @@ module Cassandra
     #   undefined and will likely cause a server process of the coordinator of
     #   such request to abort.
     #
-    # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L482-L487 Paging State description in Cassandra Native Protocol v2 specification
+    # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L482-L487 Paging State
+    #   description in Cassandra Native Protocol v2 specification
     def paging_state
     end
   end

data/lib/cassandra/retry/policies/downgrading_consistency.rb

@@ -24,9 +24,7 @@ module Cassandra
 
         def read_timeout(statement, consistency, required, received, retrieved, retries)
           return reraise if retries > 0 || SERIAL_CONSISTENCIES.include?(consistency)
-          if received < required
-            return max_likely_to_work(consistency, required, received)
-          end
+          return max_likely_to_work(consistency, required, received) if received < required
 
           retrieved ? reraise : try_again(consistency)
         end

data/lib/cassandra/statements/prepared.rb

@@ -189,9 +189,9 @@ module Cassandra
           buffer.discard(4) # discard size
         else
           buf = Protocol::CqlByteBuffer.new
-          partition_key.each do |i|
-            value    = values[i]
-            metadata = params_metadata[i]
+          partition_key.each do |ind|
+            value    = values[ind]
+            metadata = params_metadata[ind]
             name     = metadata[2]
             type     = metadata[3]
 

data/lib/cassandra/table.rb

@@ -20,232 +20,65 @@ module Cassandra
   # Represents a cassandra table
   # @see Cassandra::Keyspace#each_table
   # @see Cassandra::Keyspace#table
-  class Table
-    # @private
-    class Options
-      attr_reader :comment, :read_repair_chance, :local_read_repair_chance,
-                  :gc_grace_seconds, :caching, :bloom_filter_fp_chance,
-                  :populate_io_cache_on_flush, :memtable_flush_period_in_ms,
-                  :default_time_to_live, :speculative_retry, :index_interval,
-                  :replicate_on_write, :compaction_strategy, :compact_storage,
-                  :compression_parameters
-
-      def initialize(comment,
-                     read_repair_chance,
-                     local_read_repair_chance,
-                     gc_grace_seconds,
-                     caching,
-                     bloom_filter_fp_chance,
-                     populate_io_cache_on_flush,
-                     memtable_flush_period_in_ms,
-                     default_time_to_live,
-                     speculative_retry,
-                     index_interval,
-                     replicate_on_write,
-                     min_index_interval,
-                     max_index_interval,
-                     compaction_strategy,
-                     compression_parameters,
-                     compact_storage)
-        @comment                     = comment
-        @read_repair_chance          = read_repair_chance
-        @local_read_repair_chance    = local_read_repair_chance
-        @gc_grace_seconds            = gc_grace_seconds
-        @caching                     = caching
-        @bloom_filter_fp_chance      = bloom_filter_fp_chance
-        @populate_io_cache_on_flush  = populate_io_cache_on_flush
-        @memtable_flush_period_in_ms = memtable_flush_period_in_ms
-        @default_time_to_live        = default_time_to_live
-        @speculative_retry           = speculative_retry
-        @index_interval              = index_interval
-        @replicate_on_write          = replicate_on_write
-        @min_index_interval          = min_index_interval
-        @max_index_interval          = max_index_interval
-        @compaction_strategy         = compaction_strategy
-        @compression_parameters      = compression_parameters
-        @compact_storage             = compact_storage
-      end
-
-      def replicate_on_write?
-        @replicate_on_write
-      end
-
-      def populate_io_cache_on_flush?
-        @populate_io_cache_on_flush
-      end
-
-      def compact_storage?
-        @compact_storage
-      end
-
-      def to_cql
-        options = []
-
-        options << 'COMPACT STORAGE' if @compact_storage
-        unless @bloom_filter_fp_chance.nil?
-          options <<
-            "bloom_filter_fp_chance = #{Util.encode_object(@bloom_filter_fp_chance)}"
-        end
-        options << "caching = #{Util.encode_object(@caching)}" unless @caching.nil?
-        options << "comment = #{Util.encode_object(@comment)}" unless @comment.nil?
-        unless @compaction_strategy.nil?
-          options << "compaction = #{@compaction_strategy.to_cql}"
-        end
-        unless @compression_parameters.nil?
-          options << "compression = #{Util.encode_object(@compression_parameters)}"
-        end
-        unless @local_read_repair_chance.nil?
-          options << 'dclocal_read_repair_chance = ' \
-              "#{Util.encode_object(@local_read_repair_chance)}"
-        end
-        unless @default_time_to_live.nil?
-          options << "default_time_to_live = #{Util.encode_object(@default_time_to_live)}"
-        end
-        unless @gc_grace_seconds.nil?
-          options << "gc_grace_seconds = #{Util.encode_object(@gc_grace_seconds)}"
-        end
-        unless @index_interval.nil?
-          options << "index_interval = #{Util.encode_object(@index_interval)}"
-        end
-        unless @max_index_interval.nil?
-          options << "max_index_interval = #{Util.encode_object(@max_index_interval)}"
-        end
-        unless @memtable_flush_period_in_ms.nil?
-          options << 'memtable_flush_period_in_ms = ' \
-              "#{Util.encode_object(@memtable_flush_period_in_ms)}"
-        end
-        unless @min_index_interval.nil?
-          options << "min_index_interval = #{Util.encode_object(@min_index_interval)}"
-        end
-        unless @populate_io_cache_on_flush.nil?
-          options << "populate_io_cache_on_flush = '#{@populate_io_cache_on_flush}'"
-        end
-        unless @read_repair_chance.nil?
-          options << "read_repair_chance = #{Util.encode_object(@read_repair_chance)}"
-        end
-        unless @replicate_on_write.nil?
-          options << "replicate_on_write = '#{@replicate_on_write}'"
-        end
-        unless @speculative_retry.nil?
-          options << "speculative_retry = #{Util.encode_object(@speculative_retry)}"
-        end
-
-        options.join("\nAND ")
-      end
-
-      def eql?(other)
-        other.is_a?(Options) &&
-          @comment == other.comment &&
-          @read_repair_chance == other.read_repair_chance &&
-          @local_read_repair_chance == other.local_read_repair_chance &&
-          @gc_grace_seconds == other.gc_grace_seconds &&
-          @caching == other.caching &&
-          @bloom_filter_fp_chance == other.bloom_filter_fp_chance &&
-          @populate_io_cache_on_flush == other.populate_io_cache_on_flush &&
-          @memtable_flush_period_in_ms == other.memtable_flush_period_in_ms &&
-          @default_time_to_live == other.default_time_to_live &&
-          @speculative_retry == other.speculative_retry &&
-          @index_interval == other.index_interval &&
-          @replicate_on_write == other.replicate_on_write &&
-          @compaction_strategy == other.compaction_strategy &&
-          @compression_parameters == other.compression_parameters &&
-          @compact_storage == other.compact_storage
-      end
-      alias == eql?
-    end
-
-    # @private
-    class Compaction
-      attr_reader :klass, :options
-
-      def initialize(klass, options)
-        @klass   = klass
-        @options = options
-      end
-
-      def to_cql
-        compaction = {'class' => @klass}
-        compaction.merge!(@options)
-
-        Util.encode_hash(compaction)
-      end
-
-      def eql?(other)
-        other.is_a?(Compaction) &&
-          @klass == other.klass &&
-          @options == other.options
-      end
-      alias == eql?
-    end
-
-    # @private
-    attr_reader :keyspace
-    # @return [String] table name
-    attr_reader :name
-    # @private
-    attr_reader :options
-    # @private
-    attr_reader :partition_key
+  class Table < ColumnContainer
+    # @return [Array<Symbol>] an array of order values (`:asc` or `:desc`) that apply to the
+    #   `clustering_columns` array.
+    attr_reader :clustering_order
 
     # @private
     def initialize(keyspace,
                    name,
                    partition_key,
                    clustering_columns,
-                   columns,
+                   other_columns,
                    options,
-                   clustering_order)
-      @keyspace           = keyspace
-      @name               = name
-      @partition_key      = partition_key
-      @clustering_columns = clustering_columns
-      @columns            = columns
-      @options            = options
-      @clustering_order   = clustering_order
+                   clustering_order,
+                   id)
+      super(keyspace, name, partition_key, clustering_columns, other_columns, options, id)
+      @clustering_order = clustering_order.freeze
+      @indexes = []
+      @indexes_hash = {}
     end
 
-    # @param name [String] column name
-    # @return [Boolean] whether this table has a given column
-    def has_column?(name)
-      @columns.key?(name)
+    # @param name [String] index name
+    # @return [Boolean] whether this table has a given index
+    def has_index?(name)
+      @indexes_hash.key?(name)
     end
 
-    # @param name [String] column name
-    # @return [Cassandra::Column, nil] a column or nil
-    def column(name)
-      @columns[name]
+    # @param name [String] index name
+    # @return [Cassandra::Index, nil] an index or nil
+    def index(name)
+      @indexes_hash[name]
     end
 
-    # Yield or enumerate each column defined in this table
-    # @overload each_column
-    #   @yieldparam column [Cassandra::Column] current column
+    # Yield or enumerate each index bound to this table
+    # @overload each_index
+    #   @yieldparam index [Cassandra::Index] current index
     #   @return [Cassandra::Table] self
-    # @overload each_column
-    #   @return [Array<Cassandra::Column>] a list of columns
-    def each_column(&block)
+    # @overload each_index
+    #   @return [Array<Cassandra::Index>] a list of indexes
+    def each_index(&block)
       if block_given?
-        @columns.each_value(&block)
+        @indexes.each(&block)
         self
       else
-        @columns.values
+        @indexes.freeze
       end
     end
-    alias columns each_column
+    alias indexes each_index
 
     # @return [String] a cql representation of this table
     def to_cql
-      cql = "CREATE TABLE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
-      primary_key = nil
-      if @partition_key.one? && @clustering_columns.empty?
-        primary_key = @partition_key.first.name
-      end
+      cql = "CREATE TABLE #{Util.escape_name(@keyspace.name)}.#{Util.escape_name(@name)} (\n"
+      primary_key = @partition_key.first.name if @partition_key.one? && @clustering_columns.empty?
 
       first = true
-      @columns.each do |(_, column)|
+      @columns.each do |column|
         if first
           first = false
         else
-          cql << ",\n" unless first
+          cql << ",\n"
         end
         cql << "  #{column.name} #{type_to_cql(column.type, column.frozen?)}"
         cql << ' PRIMARY KEY' if primary_key && column.name == primary_key
@@ -296,21 +129,17 @@ module Cassandra
     end
 
     # @private
-    def inspect
-      "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
-          "@keyspace=#{@keyspace} @name=#{@name}>"
+    def add_index(index)
+      @indexes << index
+      @indexes_hash[index.name] = index
     end
 
     # @private
     def eql?(other)
       other.is_a?(Table) &&
-        @keyspace == other.keyspace &&
-        @name == other.name &&
-        @partition_key == other.partition_key &&
-        @clustering_columns == other.clustering_columns &&
-        @columns == other.raw_columns &&
-        @options == other.options &&
-        @clustering_order == other.clustering_order
+        super.eql?(other) &&
+        @clustering_order == other.clustering_order &&
+        @indexes == other.indexes
     end
     alias == eql?
 
@@ -322,7 +151,7 @@ module Cassandra
       when :tuple
         "frozen <#{type}>"
       when :udt
-        if @keyspace == type.keyspace
+        if @keyspace.name == type.keyspace
           "frozen <#{Util.escape_name(type.name)}>"
         else
           "frozen <#{Util.escape_name(type.keyspace)}.#{Util.escape_name(type.name)}>"
@@ -335,15 +164,5 @@ module Cassandra
         end
       end
     end
-
-    attr_reader :clustering_columns, :clustering_order
-    protected :clustering_columns, :clustering_order
-
-    protected
-
-    # @private
-    def raw_columns
-      @columns
-    end
   end
 end