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

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -92,6 +92,13 @@ module Cassandra
               "Not enough bytes available to decode a double: #{e.message}", e.backtrace
       end
 
+      def read_double_le
+        read(8).unpack(Formats::DOUBLE_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+      end
+
       def read_float
         read(4).unpack(Formats::FLOAT_FORMAT).first
       rescue RangeError => e
@@ -108,6 +115,13 @@ module Cassandra
               "Not enough bytes available to decode an int: #{e.message}", e.backtrace
       end
 
+      def read_unsigned_int_le
+        read(4).unpack(Formats::INT_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+      end
+
       def read_unsigned_short
         read_short
       rescue RangeError => e
@@ -115,6 +129,13 @@ module Cassandra
               "Not enough bytes available to decode a short: #{e.message}", e.backtrace
       end
 
+      def read_unsigned_short_le
+        read(2).unpack(Formats::SHORT_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+      end
+
       def read_string
         length = read_unsigned_short
         string = read(length)
@@ -324,10 +345,6 @@ module Cassandra
         self
       end
 
-      def append_timestamp(timestamp)
-        append_long(timestamp.tv_sec * 1000000 + timestamp.tv_usec)
-      end
-
       def append_long(n)
         top = n >> 32
         bottom = n & 0xffffffff

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -46,7 +46,8 @@ module Cassandra
                      compressor = nil,
                      heartbeat_interval = 30,
                      idle_timeout = 60,
-                     requests_per_connection = 128)
+                     requests_per_connection = 128,
+                     custom_type_handlers = {})
         @protocol_version = protocol_version
         @connection = connection
         @scheduler = scheduler
@@ -60,7 +61,7 @@ module Cassandra
 
         if protocol_version > 3
           @frame_encoder = V4::Encoder.new(@compressor, protocol_version)
-          @frame_decoder = V4::Decoder.new(self, @compressor)
+          @frame_decoder = V4::Decoder.new(self, @compressor, custom_type_handlers)
         elsif protocol_version > 2
           @frame_encoder = V3::Encoder.new(@compressor, protocol_version)
           @frame_decoder = V3::Decoder.new(self, @compressor)

data/lib/cassandra/protocol/requests/batch_request.rb

@@ -81,7 +81,7 @@ module Cassandra
 
           buffer.append(flags.chr)
           buffer.append_consistency(@serial_consistency) if @serial_consistency
-          buffer.append_timestamp(@timestamp) if @timestamp
+          buffer.append_long(@timestamp) if @timestamp
         end
 
         buffer

data/lib/cassandra/protocol/requests/execute_request.rb

@@ -78,7 +78,7 @@ module Cassandra
           buffer.append_int(@page_size) if @page_size
           buffer.append_bytes(@paging_state) if @paging_state
           buffer.append_consistency(@serial_consistency) if @serial_consistency
-          buffer.append_timestamp(@timestamp) if protocol_version > 2 && @timestamp
+          buffer.append_long(@timestamp) if protocol_version > 2 && @timestamp
         else
           encoder.write_parameters(buffer, @values, @metadata)
           buffer.append_consistency(@consistency)

data/lib/cassandra/protocol/requests/query_request.rb

@@ -71,7 +71,7 @@ module Cassandra
           buffer.append_int(@page_size) if @page_size
           buffer.append_bytes(@paging_state) if @paging_state
           buffer.append_consistency(@serial_consistency) if @serial_consistency
-          buffer.append_timestamp(@timestamp) if protocol_version > 2 && @timestamp
+          buffer.append_long(@timestamp) if protocol_version > 2 && @timestamp
         end
         buffer
       end

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

@@ -24,17 +24,19 @@ module Cassandra
                      protocol_version,
                      raw_rows,
                      paging_state,
-                     trace_id)
+                     trace_id,
+                     custom_type_handlers = nil)
         super(custom_payload, warnings, nil, nil, paging_state, trace_id)
         @protocol_version = protocol_version
         @raw_rows = raw_rows
+        @custom_type_handlers = custom_type_handlers
       end
 
       def materialize(metadata)
         @metadata = metadata
 
         @rows = if @protocol_version == 4
-                  Coder.read_values_v4(@raw_rows, @metadata)
+                  Coder.read_values_v4(@raw_rows, @metadata, @custom_type_handlers)
                 elsif @protocol_version == 3
                   Coder.read_values_v3(@raw_rows, @metadata)
                 else

data/lib/cassandra/protocol/v1.rb

@@ -241,7 +241,8 @@ module Cassandra
                                           protocol_version,
                                           remaining_bytes,
                                           paging_state,
-                                          trace_id)
+                                          trace_id,
+                                          nil)
               else
                 RowsResultResponse.new(nil,
                                        nil,

data/lib/cassandra/protocol/v3.rb

@@ -275,7 +275,8 @@ module Cassandra
                                           protocol_version,
                                           remaining_bytes,
                                           paging_state,
-                                          trace_id)
+                                          trace_id,
+                                          nil)
               else
                 RowsResultResponse.new(nil,
                                        nil,

data/lib/cassandra/protocol/v4.rb

@@ -59,7 +59,7 @@ module Cassandra
       end
 
       class Decoder
-        def initialize(handler, compressor = nil)
+        def initialize(handler, compressor = nil, custom_type_handlers = {})
           @handler    = handler
           @compressor = compressor
           @state      = :initial
@@ -68,6 +68,7 @@ module Cassandra
           @code       = nil
           @length     = nil
           @buffer     = CqlByteBuffer.new
+          @custom_type_handlers = custom_type_handlers
         end
 
         def <<(data)
@@ -325,11 +326,12 @@ module Cassandra
                                           protocol_version,
                                           remaining_bytes,
                                           paging_state,
-                                          trace_id)
+                                          trace_id,
+                                          @custom_type_handlers)
               else
                 RowsResultResponse.new(custom_payload,
                                        warnings,
-                                       Coder.read_values_v4(buffer, column_specs),
+                                       Coder.read_values_v4(buffer, column_specs, @custom_type_handlers),
                                        column_specs,
                                        paging_state,
                                        trace_id)

data/lib/cassandra/result.rb

@@ -76,8 +76,8 @@ module Cassandra
     #
     # @note `:paging_state` option will be ignored.
     #
-    # @return [Cassandra::Future<Cassandra::Result, nil>] `nil` if last
-    #   page
+    # @return [Cassandra::Future<Cassandra::Result>] a future that resolves to a new Result if there is a new page,
+    #   `nil` otherwise.
     #
     # @see Cassandra::Session#execute
     def next_page_async(options = nil)

data/lib/cassandra/session.rb

@@ -89,20 +89,13 @@ module Cassandra
 
       case statement
       when ::String
-        @client.query(Statements::Simple.new(statement,
-                                             options.arguments,
-                                             options.type_hints,
-                                             options.idempotent?),
-                      options)
-      when Statements::Simple
-        @client.query(statement, options)
-      when Statements::Prepared
-        @client.execute(statement.bind(options.arguments), options)
-      when Statements::Bound
-        @client.execute(statement, options)
-      when Statements::Batch
-        Util.assert_not_empty(statement.statements) { 'batch cannot be empty' }
-        @client.batch(statement, options)
+        Statements::Simple.new(statement,
+                               options.arguments,
+                               options.type_hints,
+                               options.idempotent?).accept(@client,
+                                                           options)
+      when Statement
+        statement.accept(@client, options)
       else
         @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
       end
@@ -238,7 +231,9 @@ module Cassandra
 
     # @private
     def inspect
-      "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+      "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+      "@keyspace=#{keyspace.inspect}, " \
+      "@options=#{@options.inspect}>"
     end
   end
 end

data/lib/cassandra/statement.rb

@@ -23,5 +23,10 @@ module Cassandra
     def idempotent?
       !!@idempotent
     end
+
+    # @private
+    def accept(client, options)
+      raise NotImplementedError, "#{self.class} must implement :accept method"
+    end
   end
 end

data/lib/cassandra/statements/batch.rb

@@ -113,6 +113,12 @@ module Cassandra
         self
       end
 
+      # @private
+      def accept(client, options)
+        Util.assert_not_empty(statements) { 'batch cannot be empty' }
+        client.batch(self, options)
+      end
+
       # Determines whether or not the statement is safe to retry on timeout
       # Batches are idempotent only when all statements in a batch are.
       # @return [Boolean] whether the statement is safe to retry on timeout

data/lib/cassandra/statements/bound.rb

@@ -46,6 +46,11 @@ module Cassandra
         @idempotent      = idempotent
       end
 
+      # @private
+      def accept(client, options)
+        client.execute(self, options)
+      end
+
       # @return [String] a CLI-friendly bound statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \

data/lib/cassandra/statements/prepared.rb

@@ -155,6 +155,11 @@ module Cassandra
                                           nil)
       end
 
+      # @private
+      def accept(client, options)
+        client.execute(bind(options.arguments), options)
+      end
+
       # @return [String] a CLI-friendly prepared statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect}>"
@@ -180,7 +185,9 @@ module Cassandra
                                    'the partition key and must be present.'
           end
 
-          if @connection_options.protocol_version >= 3
+          if @connection_options.protocol_version >= 4
+            Protocol::Coder.write_value_v4(buffer, value, type)
+          elsif @connection_options.protocol_version >= 3
             Protocol::Coder.write_value_v3(buffer, value, type)
           else
             Protocol::Coder.write_value_v1(buffer, value, type)
@@ -200,7 +207,9 @@ module Cassandra
                                      'the partition key and must be present.'
             end
 
-            if @connection_options.protocol_version >= 3
+            if @connection_options.protocol_version >= 4
+              Protocol::Coder.write_value_v4(buf, value, type)
+            elsif @connection_options.protocol_version >= 3
               Protocol::Coder.write_value_v3(buf, value, type)
             else
               Protocol::Coder.write_value_v1(buf, value, type)

data/lib/cassandra/statements/simple.rb

@@ -93,6 +93,11 @@ module Cassandra
         @idempotent   = idempotent
       end
 
+      # @private
+      def accept(client, options)
+        client.query(self, options)
+      end
+
       # @return [String] a CLI-friendly simple statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \

data/lib/cassandra/statements/void.rb

@@ -23,6 +23,11 @@ module Cassandra
     class Void
       include Statement
 
+      # @private
+      def accept(client, options)
+        nil
+      end
+
       # Returns nothing
       # @return [nil] there is no cql for the void statement
       def cql

data/lib/cassandra/table.rb

@@ -80,14 +80,14 @@ module Cassandra
         else
           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
@@ -97,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
@@ -118,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

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