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

data/lib/cassandra/time_uuid.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.
@@ -23,13 +23,18 @@ module Cassandra
   class TimeUuid < Uuid
     include Comparable
 
+    # @private
+    LOWER_HALF_MASK = 0xffffffff_ffffffff
+    # @private
+    GREGORIAN_OFFSET = 122192928000000000
+
     # Returns the time component from this UUID as a Time.
     #
     # @return [Time]
     def to_time
       t = time_bits - GREGORIAN_OFFSET
-      seconds = t/10_000_000
-      microseconds = (t - seconds * 10_000_000)/10.0
+      seconds = t / 10_000_000
+      microseconds = (t - seconds * 10_000_000) / 10.0
 
       ::Time.at(seconds, microseconds).utc
     end
@@ -52,10 +57,10 @@ module Cassandra
     # @return [Integer] `-1` when less than `other`, `0` when equal to `other`
     #   and `1` when greater than `other`
     def <=>(other)
-      return nil unless other.kind_of?(Cassandra::Uuid)
-      c = self.value <=> other.value
+      return nil unless other.is_a?(Cassandra::Uuid)
+      c = value <=> other.value
       return c if c == 0 || !other.is_a?(Cassandra::TimeUuid)
-      self.time_bits <=> other.time_bits
+      time_bits <=> other.time_bits
     end
 
     protected
@@ -69,12 +74,5 @@ module Cassandra
       t |= (n & 0xffffffff00000000) >> 32
       t
     end
-
-    private
-
-    # @private
-    LOWER_HALF_MASK = 0xffffffff_ffffffff
-    # @private
-    GREGORIAN_OFFSET = 122192928000000000
   end
-end
+end

data/lib/cassandra/timestamp_generator.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+#--
+# 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.
+# 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.
+#++
+
+module Cassandra
+  # A generator is used to create client-timestamps (in the form of long integers) to send with C* requests when
+  # the `:client_timestamps` cluster option is set to true.
+  #
+  # @abstract A timestamp generator given to {Cassandra.cluster} doesn't need to include this module, but needs to
+  #   implement the same methods. This module exists only for documentation purposes.
+  module TimestampGenerator
+    # Create a new timestamp, as a 64-bit integer. Calls must return monotonically increasing values.
+    #
+    # @return [Integer] an integer representing a timestamp in microseconds.
+    # @raise [NotImplementedError] if a class including this module does not define this method.
+    def next
+      raise NotImplementedError, "#{self.class} class must implement the 'next' method"
+    end
+  end
+end
+
+require 'cassandra/timestamp_generator/ticking_on_duplicate'
+require 'cassandra/timestamp_generator/simple'

data/lib/cassandra/timestamp_generator/simple.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+#--
+# 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.
+# 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.
+#++
+
+module Cassandra
+  module TimestampGenerator
+    # Generate long integer timestamps from current time. This implementation relies on the {::Time} class to return
+    # microsecond precision time.
+    # @note It is not appropriate for use with JRuby because its {::Time#now} returns millisecond precision time.
+    class Simple
+      include TimestampGenerator
+
+      # Create a new timestamp, as a 64-bit integer. This is just a wrapper around Time::now.
+      #
+      # @return [Integer] an integer representing a timestamp in microseconds.
+      def next
+        # Use Time.now, which has microsecond precision on MRI (and probably Rubinius) to make an int representing
+        # client timestamp in protocol requests.
+        timestamp = ::Time.now
+        timestamp.tv_sec * 1000000 + timestamp.tv_usec
+      end
+    end
+  end
+end

data/lib/cassandra/timestamp_generator/ticking_on_duplicate.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+#--
+# 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.
+# 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.
+#++
+
+module Cassandra
+  module TimestampGenerator
+    # In JRuby, {::Time} has millisecond precision. We require client timestamps to have microsecond precision to
+    # minimize clashes in C*. This generator keeps track of the last generated timestamp, and if the current-time
+    # is within the same millisecond as the last, it fills the microsecond portion of the new timestamp with the
+    # value of an incrementing counter.
+    #
+    # For example, if the generator triggers twice at time 12345678000 (microsecond granularity, but ms precisions
+    # as shown by 0's for the three least-significant digits), it'll return 12345678000 and 12345678001.
+    class TickingOnDuplicate
+      include MonitorMixin
+      include TimestampGenerator
+
+      # @private
+      def initialize
+        mon_initialize
+        @last = 0
+      end
+
+      # Create a new timestamp, as a 64-bit integer.
+      #
+      # @return [Integer] an integer representing a timestamp in microseconds.
+      def next
+        now = ::Time.now
+        now_millis = now.tv_sec * 1000 + now.tv_usec / 1000
+        synchronize do
+          millis = @last / 1000
+          counter = @last % 1000
+          if millis >= now_millis
+            counter += 1
+          else
+            millis = now_millis
+            counter = 0
+          end
+          @last = millis * 1000 + counter
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/tuple.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.
@@ -55,7 +55,7 @@ module Cassandra
       end
 
       def inspect
-        "#<Cassandra::Tuple:0x#{self.object_id.to_s(16)} #{to_s}>"
+        "#<Cassandra::Tuple:0x#{object_id.to_s(16)} #{self}>"
       end
     end
 
@@ -114,14 +114,14 @@ module Cassandra
 
     # @private
     def inspect
-      "#<Cassandra::Tuple:0x#{self.object_id.to_s(16)} #{to_s}>"
+      "#<Cassandra::Tuple:0x#{object_id.to_s(16)} #{self}>"
     end
 
     # @private
     def eql?(other)
       other == @values
     end
-    alias :== :eql?
+    alias == eql?
 
     # @private
     def hash

data/lib/cassandra/types.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,7 +48,13 @@ module Cassandra
     end
   end
 
-  module Types; extend self
+  module Types
+    # If we use module_function, the yard docs end up showing duplicates of all
+    # methods: one for self, the other as instance methods.
+    #
+    # rubocop:disable Style/ModuleFunction
+    extend self
+
     # @private
     class Simple < Type
       def new(value)
@@ -71,12 +77,13 @@ module Cassandra
       def eql?(other)
         other.is_a?(Simple) && @kind == other.kind
       end
-      alias :== :eql?
+
+      alias == eql?
 
       private
 
       def new_varchar(value)
-       String(value)
+        String(value)
       end
 
       def assert_varchar(value, message, &block)
@@ -140,11 +147,14 @@ module Cassandra
       end
 
       def new_boolean(value)
-        !!value
+        !value.nil? && value != false
       end
 
       def assert_boolean(value, message, &block)
-        Util.assert_instance_of_one_of([::TrueClass, ::FalseClass], value, message, &block)
+        Util.assert_instance_of_one_of([::TrueClass, ::FalseClass],
+                                       value,
+                                       message,
+                                       &block)
       end
 
       def new_decimal(value)
@@ -193,7 +203,7 @@ module Cassandra
         Util.assert_instance_of(::Time, value, message, &block)
       end
 
-      def new_uuid(value, message, &block)
+      def new_uuid(value)
         Cassandra::Uuid.new(value)
       end
 
@@ -649,7 +659,7 @@ module Cassandra
       # @return [String] `"list<type>"`
       # @see Cassandra::Type#to_s
       def to_s
-        "list<#{@value_type.to_s}>"
+        "list<#{@value_type}>"
       end
 
       def hash
@@ -664,7 +674,8 @@ module Cassandra
       def eql?(other)
         other.is_a?(List) && @value_type == other.value_type
       end
-      alias :== :eql?
+
+      alias == eql?
     end
 
     class Map < Type
@@ -674,7 +685,7 @@ module Cassandra
       # @private
       def initialize(key_type, value_type)
         super(:map)
-        @key_type   = key_type
+        @key_type = key_type
         @value_type = value_type
       end
 
@@ -701,7 +712,7 @@ module Cassandra
           end
           result
         else
-          raise ::ArgumentError, "cannot convert #{value.inspect} to #{to_s}"
+          raise ::ArgumentError, "cannot convert #{value.inspect} to #{self}"
         end
       end
 
@@ -724,7 +735,7 @@ module Cassandra
       # @return [String] `"map<type, type>"`
       # @see Cassandra::Type#to_s
       def to_s
-        "map<#{@key_type.to_s}, #{@value_type.to_s}>"
+        "map<#{@key_type}, #{@value_type}>"
       end
 
       def hash
@@ -742,7 +753,8 @@ module Cassandra
           @key_type == other.key_type &&
           @value_type == other.value_type
       end
-      alias :== :eql?
+
+      alias == eql?
     end
 
     class Set < Type
@@ -813,7 +825,7 @@ module Cassandra
       # @return [String] `"set<type>"`
       # @see Cassandra::Type#to_s
       def to_s
-        "set<#{@value_type.to_s}>"
+        "set<#{@value_type}>"
       end
 
       def hash
@@ -828,7 +840,8 @@ module Cassandra
       def eql?(other)
         other.is_a?(Set) && @value_type == other.value_type
       end
-      alias :== :eql?
+
+      alias == eql?
     end
 
     # @!parse
@@ -1042,7 +1055,9 @@ module Cassandra
       #
       #   tuple(varchar, varchar, int).new('Jane', 'Smith', 38) # => (Jane, Smith, 38)
       def new(*values)
-        Util.assert(values.size <= @members.size) { "too many values: #{values.size} out of max #{@members.size}" }
+        Util.assert(values.size <= @members.size) do
+          "too many values: #{values.size} out of max #{@members.size}"
+        end
         values.each_with_index do |v, i|
           Util.assert_type(@members[i], v)
         end
@@ -1083,7 +1098,8 @@ module Cassandra
       def eql?(other)
         other.is_a?(Tuple) && @members == other.members
       end
-      alias :== :eql?
+
+      alias == eql?
     end
 
     # @!parse
@@ -1183,7 +1199,8 @@ module Cassandra
             @name == other.name &&
             @type == other.type
         end
-        alias :== :eql?
+
+        alias == eql?
       end
 
       # @return [String] keyspace where this type is defined
@@ -1198,15 +1215,15 @@ module Cassandra
       # @private
       def initialize(keyspace, name, fields)
         super(:udt)
-        @keyspace  = keyspace
-        @name      = name
-        @fields    = fields
+        @keyspace = keyspace
+        @name = name
+        @fields = fields
       end
 
       # @param name [String] field name
       # @return [Boolean] whether this type has a given field
       def has_field?(name)
-        @fields.any? {|f| f.name == name}
+        @fields.any? { |f| f.name == name }
       end
 
       # Yield or enumerate each field defined in this type
@@ -1223,13 +1240,14 @@ module Cassandra
           @fields.dup
         end
       end
-      alias :fields :each_field
+
+      alias fields each_field
 
       # @param name [String] field name
       # @return [Cassandra::UserDefined::Field, nil] a field with this name or
       #   nil
       def field(name)
-        @fields.find {|f| f.name == name}
+        @fields.find { |f| f.name == name }
       end
 
       # Coerces the value to Cassandra::UDT
@@ -1240,7 +1258,9 @@ module Cassandra
         value = value.first if value.one?
         value = Array(value) unless value.is_a?(::Hash)
 
-        Util.assert(value.size <= @fields.size) { "too many values: #{value.size} out of #{@fields.size}" }
+        Util.assert(value.size <= @fields.size) do
+          "too many values: #{value.size} out of #{@fields.size}"
+        end
 
         case value
         when ::Array
@@ -1282,7 +1302,8 @@ module Cassandra
       # @return [String] `"keyspace.name"`
       # @see Cassandra::Type#to_s
       def to_s
-        "#{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} {#{@fields.join(', ')}}"
+        "#{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} " \
+                        "{#{@fields.join(', ')}}"
       end
 
       def hash
@@ -1302,11 +1323,13 @@ module Cassandra
           @name == other.name &&
           @fields == other.fields
       end
-      alias :== :eql?
+
+      alias == eql?
 
       # Output this type in CQL
       def to_cql
-        cql   = "CREATE TYPE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} (\n"
+        cql = "CREATE TYPE #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)} " \
+                        "(\n"
         first = true
 
         @fields.each do |field|
@@ -1337,7 +1360,7 @@ module Cassandra
             "frozen <#{Util.escape_name(type.keyspace)}.#{Util.escape_name(type.name)}>"
           end
         else
-          "#{type}"
+          type.to_s
         end
       end
     end
@@ -1355,7 +1378,8 @@ module Cassandra
       # @param value [*Object] value to be coerced
       # @return [Object] a value of this type
       def new(*value)
-        raise ::NotImplementedError, "unable to create a value for custom type: #{@name.inspect}"
+        raise ::NotImplementedError,
+              "unable to create a value for custom type: #{@name.inspect}"
       end
 
       # Asserts that a given value is of this type
@@ -1365,7 +1389,8 @@ module Cassandra
       # @raise [ArgumentError] if the value is invalid
       # @return [void]
       def assert(value, message = nil, &block)
-        raise ::NotImplementedError, "unable to assert a value for custom type: #{@name.inspect}"
+        raise ::NotImplementedError,
+              "unable to assert a value for custom type: #{@name.inspect}"
       end
 
       # @return [String] a cassandra representation of this type
@@ -1385,7 +1410,8 @@ module Cassandra
       def eql?(other)
         other.is_a?(Custom) && @name == other.name
       end
-      alias :== :eql?
+
+      alias == eql?
     end
 
     # @return [Cassandra::Types::Text] text type since varchar is an alias for text
@@ -1492,8 +1518,8 @@ module Cassandra
     # @return [Cassandra::Types::List] list type
     def list(value_type)
       Util.assert_instance_of(Cassandra::Type, value_type,
-        "list type must be a Cassandra::Type, #{value_type.inspect} given"
-      )
+                              "list type must be a Cassandra::Type, #{value_type.inspect} given"
+                             )
 
       List.new(value_type)
     end
@@ -1503,11 +1529,11 @@ module Cassandra
     # @return [Cassandra::Types::Map] map type
     def map(key_type, value_type)
       Util.assert_instance_of(Cassandra::Type, key_type,
-        "map key type must be a Cassandra::Type, #{key_type.inspect} given"
-      )
+                              "map key type must be a Cassandra::Type, #{key_type.inspect} given"
+                             )
       Util.assert_instance_of(Cassandra::Type, value_type,
-        "map value type must be a Cassandra::Type, #{value_type.inspect} given"
-      )
+                              "map value type must be a Cassandra::Type, #{value_type.inspect} given"
+                             )
 
       Map.new(key_type, value_type)
     end
@@ -1516,8 +1542,8 @@ module Cassandra
     # @return [Cassandra::Types::Set] set type
     def set(value_type)
       Util.assert_instance_of(Cassandra::Type, value_type,
-        "set type must be a Cassandra::Type, #{value_type.inspect} given"
-      )
+                              "set type must be a Cassandra::Type, #{value_type.inspect} given"
+                             )
 
       Set.new(value_type)
     end
@@ -1525,12 +1551,12 @@ module Cassandra
     # @param members [*Cassandra::Type] types of members of this tuple
     # @return [Cassandra::Types::Tuple] tuple type
     def tuple(*members)
-      Util.assert_not_empty(members, "tuple must contain at least one member")
+      Util.assert_not_empty(members, 'tuple must contain at least one member')
       members.each do |member|
         Util.assert_instance_of(Cassandra::Type, member,
-          "each tuple member must be a Cassandra::Type, " \
-          "#{member.inspect} given"
-        )
+                                'each tuple member must be a Cassandra::Type, ' \
+                                            "#{member.inspect} given"
+                               )
       end
 
       Tuple.new(*members)
@@ -1540,13 +1566,25 @@ module Cassandra
     # @example Various ways of defining the same UDT
     #   include Cassandra::Types
     #
-    #   udt('simplex', 'address', {'street' => varchar, 'city' => varchar, 'state' => varchar, 'zip' => varchar}) #=> simplex.address
+    #   udt('simplex', 'address', {'street' => varchar,
+    #                              'city' => varchar,
+    #                              'state' => varchar,
+    #                              'zip' => varchar}) #=> simplex.address
     #
-    #   udt('simplex', 'address', [['street', varchar], ['city', varchar], ['state', varchar], ['zip', varchar]]) #=> simplex.address
+    #   udt('simplex', 'address', [['street', varchar],
+    #                              ['city', varchar],
+    #                              ['state', varchar],
+    #                              ['zip', varchar]]) #=> simplex.address
     #
-    #   udt('simplex', 'address', ['street', varchar], ['city', varchar], ['state', varchar], ['zip', varchar]) #=> simplex.address
+    #   udt('simplex', 'address', ['street', varchar],
+    #                             ['city', varchar],
+    #                             ['state', varchar],
+    #                             ['zip', varchar]) #=> simplex.address
     #
-    #   udt('simplex', 'address', 'street', varchar, 'city', varchar, 'state', varchar, 'zip', varchar) #=> simplex.address
+    #   udt('simplex', 'address', 'street', varchar,
+    #                             'city', varchar,
+    #                             'state', varchar,
+    #                             'zip', varchar) #=> simplex.address
     # @param keyspace [String] name of the keyspace that this UDT is defined in
     # @param name     [String] name of this UDT
     # @param fields   [Hash<String, Cassandra::Type>,
@@ -1556,44 +1594,44 @@ module Cassandra
     # @return [Cassandra::Types::UserDefined] user defined type
     def udt(keyspace, name, *fields)
       keyspace = String(keyspace)
-      name     = String(name)
-      fields   = Array(fields.first) if fields.one?
+      name = String(name)
+      fields = Array(fields.first) if fields.one?
 
       Util.assert_not_empty(fields,
-        "user-defined type must contain at least one field"
-      )
+                            'user-defined type must contain at least one field'
+                           )
 
       if fields.first.is_a?(::Array)
         fields = fields.map do |pair|
           Util.assert(pair.size == 2,
-            "fields of a user-defined type must be an Array of name and " \
-            "value pairs, #{pair.inspect} given"
-          )
+                      'fields of a user-defined type must be an Array of name and ' \
+                                  "value pairs, #{pair.inspect} given"
+                     )
           Util.assert_instance_of(::String, pair[0],
-            "each field name for a user-defined type must be a String, " \
-            "#{pair[0].inspect} given"
-          )
+                                  'each field name for a user-defined type must be a String, ' \
+                                              "#{pair[0].inspect} given"
+                                 )
           Util.assert_instance_of(Cassandra::Type, pair[1],
-            "each field type for a user-defined type must be a " \
-            "Cassandra::Type, #{pair[1].inspect} given"
-          )
+                                  'each field type for a user-defined type must be a ' \
+                                              "Cassandra::Type, #{pair[1].inspect} given"
+                                 )
 
           UserDefined::Field.new(*pair)
         end
       else
-        Util.assert((fields.size % 2) == 0,
-          "fields of a user-defined type must be an Array of alternating " \
-          "names and values pairs, #{fields.inspect} given"
-        )
+        Util.assert(fields.size.even?,
+                    'fields of a user-defined type must be an Array of alternating ' \
+                                "names and values pairs, #{fields.inspect} given"
+                   )
         fields = fields.each_slice(2).map do |field_name, field_type|
           Util.assert_instance_of(::String, field_name,
-            "each field name for a user-defined type must be a String, " \
-            "#{field_name.inspect} given"
-          )
+                                  'each field name for a user-defined type must be a String, ' \
+                                              "#{field_name.inspect} given"
+                                 )
           Util.assert_instance_of(Cassandra::Type, field_type,
-            "each field type for a user-defined type must be a " \
-            "Cassandra::Type, #{field_type.inspect} given"
-          )
+                                  'each field type for a user-defined type must be a ' \
+                                              "Cassandra::Type, #{field_type.inspect} given"
+                                 )
 
           UserDefined::Field.new(field_name, field_type)
         end