cassandra-driver 3.0.0.beta.1-java → 3.0.0-java

data/lib/cassandra/statements/simple.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -48,21 +48,27 @@ module Cassandra
       #
       # @raise [ArgumentError] if cql statement given is not a String
       def initialize(cql, params = nil, type_hints = nil, idempotent = false)
-        Util.assert_instance_of(::String, cql) { "cql must be a string, #{cql.inspect} given" }
+        Util.assert_instance_of(::String, cql) do
+          "cql must be a string, #{cql.inspect} given"
+        end
 
         params ||= EMPTY_LIST
 
         if params.is_a?(::Hash)
           params_names = []
-          params = params.each_with_object([]) do |(name, value), params|
+          params = params.each_with_object([]) do |(name, value), collector|
             params_names << name
-            params       << value
+            collector    << value
           end
           if type_hints && !type_hints.empty?
-            Util.assert_instance_of(::Hash, type_hints) { "type_hints must be a Hash when using named params" }
+            Util.assert_instance_of(::Hash, type_hints) do
+              'type_hints must be a Hash when using named params'
+            end
           end
         else
-          Util.assert_instance_of(::Array, params) { "params must be an Array or a Hash, #{params.inspect} given" }
+          Util.assert_instance_of(::Array, params) do
+            "params must be an Array or a Hash, #{params.inspect} given"
+          end
           params_names = EMPTY_LIST
         end
 
@@ -71,19 +77,26 @@ module Cassandra
         if type_hints.is_a?(::Hash)
           type_hints = params_names.map {|name| type_hints[name] }
         else
-          Util.assert_instance_of(::Array, type_hints) { "type_hints must be an Array or a Hash, #{type_hints.inspect} given" }
+          Util.assert_instance_of(::Array, type_hints) do
+            "type_hints must be an Array or a Hash, #{type_hints.inspect} given"
+          end
         end
 
         @cql          = cql
         @params       = params
-        @params_types = params.each_with_index.map {|value, index| (!type_hints.empty? && type_hints[index] && type_hints[index].is_a?(Type)) ? type_hints[index] : Util.guess_type(value)}
+        @params_types = params.each_with_index.map do |value, index|
+          (!type_hints.empty? && type_hints[index] && type_hints[index].is_a?(Type)) ?
+              type_hints[index] :
+              Util.guess_type(value)
+        end
         @params_names = params_names
         @idempotent   = idempotent
       end
 
       # @return [String] a CLI-friendly simple statement representation
       def inspect
-        "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @cql=#{@cql.inspect} @params=#{@params.inspect}>"
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \
+            "@params=#{@params.inspect}>"
       end
 
       # @param other [Object, Cassandra::Statements::Simple] object to compare
@@ -94,7 +107,7 @@ module Cassandra
           @params == other.params
       end
 
-      alias :== :eql?
+      alias == eql?
     end
   end
 end

data/lib/cassandra/statements/void.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

data/lib/cassandra/table.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,193 +20,74 @@ 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
-        options << "bloom_filter_fp_chance = #{Util.encode_object(@bloom_filter_fp_chance)}" unless @bloom_filter_fp_chance.nil?
-        options << "caching = #{Util.encode_object(@caching)}" unless @caching.nil?
-        options << "comment = #{Util.encode_object(@comment)}" unless @comment.nil?
-        options << "compaction = #{@compaction_strategy.to_cql}" unless @compaction_strategy.nil?
-        options << "compression = #{Util.encode_object(@compression_parameters)}" unless @compression_parameters.nil?
-        options << "dclocal_read_repair_chance = #{Util.encode_object(@local_read_repair_chance)}" unless @local_read_repair_chance.nil?
-        options << "default_time_to_live = #{Util.encode_object(@default_time_to_live)}" unless @default_time_to_live.nil?
-        options << "gc_grace_seconds = #{Util.encode_object(@gc_grace_seconds)}" unless @gc_grace_seconds.nil?
-        options << "index_interval = #{Util.encode_object(@index_interval)}" unless @index_interval.nil?
-        options << "max_index_interval = #{Util.encode_object(@max_index_interval)}" unless @max_index_interval.nil?
-        options << "memtable_flush_period_in_ms = #{Util.encode_object(@memtable_flush_period_in_ms)}" unless @memtable_flush_period_in_ms.nil?
-        options << "min_index_interval = #{Util.encode_object(@min_index_interval)}" unless @min_index_interval.nil?
-        options << "populate_io_cache_on_flush = '#{@populate_io_cache_on_flush}'" unless @populate_io_cache_on_flush.nil?
-        options << "read_repair_chance = #{Util.encode_object(@read_repair_chance)}" unless @read_repair_chance.nil?
-        options << "replicate_on_write = '#{@replicate_on_write}'" unless @replicate_on_write.nil?
-        options << "speculative_retry = #{Util.encode_object(@speculative_retry)}" unless @speculative_retry.nil?
-
-        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
+  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
 
-      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
-
-    # @private
-    def initialize(keyspace, name, partition_key, clustering_columns, columns, options, clustering_order)
-      @keyspace           = keyspace
-      @name               = name
-      @partition_key      = partition_key
-      @clustering_columns = clustering_columns
-      @columns            = columns
-      @options            = options
-      @clustering_order   = clustering_order
+    def initialize(keyspace,
+                   name,
+                   partition_key,
+                   clustering_columns,
+                   other_columns,
+                   options,
+                   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.has_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 << "  #{Util.escape_name(column.name)} #{type_to_cql(column.type, column.frozen?)}"
         cql << ' PRIMARY KEY' if primary_key && column.name == primary_key
       end
 
       unless primary_key
         cql << ",\n  PRIMARY KEY ("
         if @partition_key.one?
-          cql << @partition_key.first.name
+          cql << Util.escape_name(@partition_key.first.name)
         else
           cql << '('
           first = true
@@ -216,12 +97,12 @@ module Cassandra
             else
               cql << ', '
             end
-            cql << column.name
+            cql << Util.escape_name(column.name)
           end
           cql << ')'
         end
         @clustering_columns.each do |column|
-          cql << ", #{column.name}"
+          cql << ", #{Util.escape_name(column.name)}"
         end
         cql << ')'
       end
@@ -229,7 +110,7 @@ module Cassandra
       cql << "\n)\nWITH "
 
       if @clustering_order.any? {|o| o != :asc}
-        cql << "CLUSTERING ORDER BY ("
+        cql << 'CLUSTERING ORDER BY ('
         first = true
         @clustering_columns.zip(@clustering_order) do |column, order|
           if first
@@ -237,7 +118,7 @@ module Cassandra
           else
             cql << ', '
           end
-          cql << "#{column.name} #{order.to_s.upcase}"
+          cql << "#{Util.escape_name(column.name)} #{order.to_s.upcase}"
         end
         cql << ")\n AND "
       end
@@ -248,22 +129,19 @@ module Cassandra
     end
 
     # @private
-    def inspect
-      "#<#{self.class.name}:0x#{self.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?
+    alias == eql?
 
     private
 
@@ -273,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)}>"
@@ -282,19 +160,9 @@ module Cassandra
         if is_frozen
           "frozen <#{type}>"
         else
-          "#{type}"
+          type.to_s
         end
       end
     end
-
-    attr_reader :clustering_columns, :clustering_order
-    protected :clustering_columns, :clustering_order
-
-    protected
-
-    # @private
-    def raw_columns
-      @columns
-    end
   end
 end

data/lib/cassandra/time.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -35,7 +35,7 @@ module Cassandra
     # @private
     def initialize(nanoseconds = 0)
       if nanoseconds < 0 && nanoseconds > NANOSECONDS_IN_DAY - 1
-        raise ::ArgumentError, "value must be between 0 and " \
+        raise ::ArgumentError, 'value must be between 0 and ' \
                                "#{NANOSECONDS_IN_DAY}, #{value.inspect} given"
       end
 
@@ -57,18 +57,23 @@ module Cassandra
     # @return [Integer] an integer between 0 and 60, the number of full seconds
     #   since the last full minutes that this time represents
     def seconds
-      (@nanoseconds - (hours * NANOSECONDS_IN_HOUR) - (minutes * NANOSECONDS_IN_MINUTE)) / NANOSECONDS_IN_SECOND
+      (@nanoseconds -
+          (hours * NANOSECONDS_IN_HOUR) -
+          (minutes * NANOSECONDS_IN_MINUTE)) / NANOSECONDS_IN_SECOND
     end
 
     # @return [Integer] an integer between 0 and 60, the number of full
     #   miliseconds since the last full second that this time represents
     def miliseconds
-      (@nanoseconds - (hours * NANOSECONDS_IN_HOUR) - (minutes * NANOSECONDS_IN_MINUTE) - (seconds * NANOSECONDS_IN_SECOND)) / NANOSECONDS_IN_MILISECOND
+      (@nanoseconds -
+          (hours * NANOSECONDS_IN_HOUR) -
+          (minutes * NANOSECONDS_IN_MINUTE) -
+          (seconds * NANOSECONDS_IN_SECOND)) / NANOSECONDS_IN_MILISECOND
     end
 
     # @return [String] a "%H:%M%S.%3N" formatted time string
     def to_s
-      '%.2d:%.2d:%.2d.%.3d' % [hours, minutes, seconds, miliseconds]
+      format('%.2d:%.2d:%.2d.%.3d', hours, minutes, seconds, miliseconds)
     end
 
     # @return [Integer] an integer between 0 and 86400000000000, the number of
@@ -81,7 +86,7 @@ module Cassandra
     def eql?(other)
       other.is_a?(Time) && other.to_nanoseconds == @nanoseconds
     end
-    alias :== :eql?
+    alias == eql?
 
     # @private
     def <=>(other)