cassandra-driver 2.1.3-java → 2.1.4-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 345d45fb0e82aa5c218cbc343971f1f9067825e5
-  data.tar.gz: 64d3a7ca35bda6993cf5d220a53b6aa4cfbc8afc
+  metadata.gz: 32c86970c749f6a1afe3c4af85e2d16eb62c11f9
+  data.tar.gz: 97c1cacbbffa03e9d1162dce3bbf0a1929b02af2
 SHA512:
-  metadata.gz: 9dc189fe0f294bfddbdde8e6c38815a64292c365b92b367ab85861b22745aea870dfb360385489380ec3aec9ac187f1db3227f129adfd17c7a14912530c925ca
-  data.tar.gz: f10710d0fc9d98169b42ab50b6175b7ede11a317a17c5994526fd6db6130123b04405840cba3852b55fece86f876e2b27b555aab35ce55c5f5d7fc592e48f2de
+  metadata.gz: 52a010f2c3254b953ff1d9af072ecba957def21236fafa3467029ef1fa4a50428c8179a5ee9cc5b9a421082347ad45da07966512bc8cf012fa687578eabcada9
+  data.tar.gz: 85094e7b051ae8c91c1b6caf8669383e4671ccb18095f6265c6aff8270f47fe0debde9465042e2bb1ec8070f29e8fd66d5bd6f6d6dd132ea5d54a1e99e5cf121

data/README.md

@@ -154,7 +154,7 @@ Please [refer to the usage documentation for more information on common pitfalls
 
 ## Contributing
 
-For contributing read [CONTRIBUTING.md](https://github.com/datastax/ruby-driver/blob/master/README.md)
+For contributing read [CONTRIBUTING.md](https://github.com/datastax/ruby-driver/blob/master/CONTRIBUTING.md)
 
 ## Credits
 

data/lib/cassandra.rb

@@ -59,6 +59,9 @@ module Cassandra
   #
   # @option options [Integer] :port (9042) cassandra native protocol port.
   #
+  # @option options [Boolean] :nodelay (false) when set to `true`, disables
+  #   nagle algorithm.
+  #
   # @option options [String] :datacenter (nil) name of current datacenter.
   #   First datacenter found will be assumed current by default. Note that you
   #   can skip this option if you specify only hosts from the local datacenter
@@ -122,6 +125,12 @@ module Cassandra
   #   address resolver to use. Must be one of `:none` or
   #   `:ec2_multi_region`.
   #
+  # @option options [Boolean] :client_timestamps (false) whether the driver
+  #   should send timestamps for each executed statement. Enabling this setting
+  #   allows mitigating Cassandra cluster clock skew because the timestamp of
+  #   the client machine will be used. This does not help mitigate application
+  #   cluster clock skew.
+  #
   # @option options [Boolean] :synchronize_schema (true) whether the driver
   #   should automatically keep schema metadata synchronized. When enabled, the
   #   driver updates schema metadata after receiving schema change
@@ -217,7 +226,7 @@ module Cassandra
         :connect_timeout, :futures_factory, :datacenter, :address_resolution,
         :address_resolution_policy, :idle_timeout, :heartbeat_interval, :timeout,
         :synchronize_schema, :schema_refresh_delay, :schema_refresh_timeout,
-        :shuffle_replicas
+        :shuffle_replicas, :client_timestamps
       ].include?(key)
     end
 
@@ -315,10 +324,8 @@ module Cassandra
 
       case compression
       when :snappy
-        require 'cassandra/compression/compressors/snappy'
         options[:compressor] = Compression::Compressors::Snappy.new
       when :lz4
-        require 'cassandra/compression/compressors/lz4'
         options[:compressor] = Compression::Compressors::Lz4.new
       else
         raise ::ArgumentError, ":compression must be either :snappy or :lz4, #{compression.inspect} given"
@@ -429,6 +436,10 @@ module Cassandra
       Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
     end
 
+    if options.has_key?(:nodelay)
+      options[:nodelay] = !!options[:nodelay]
+    end
+
     if options.has_key?(:trace)
       options[:trace] = !!options[:trace]
     end
@@ -476,6 +487,10 @@ module Cassandra
       options[:synchronize_schema] = !!options[:synchronize_schema]
     end
 
+    if options.has_key?(:client_timestamps)
+      options[:client_timestamps] = !!options[:client_timestamps]
+    end
+
     hosts = []
 
     Array(options.fetch(:hosts, '127.0.0.1')).each do |host|
@@ -497,7 +512,7 @@ module Cassandra
 
     hosts.shuffle!
   rescue => e
-    futures = options.fetch(:futures_factory) { Driver.new.futures_factory }
+    futures = options.fetch(:futures_factory) { return Future::Error.new(e) }
     futures.error(e)
   else
     driver = Driver.new(options)

data/lib/cassandra/cluster/client.rb

@@ -207,9 +207,11 @@ module Cassandra
       def query(statement, options)
         return @futures.error(Errors::ClientError.new("Positional arguments are not supported by the current version of Apache Cassandra")) if !statement.params.empty? && @connection_options.protocol_version == 1
 
-        request = Protocol::QueryRequest.new(statement.cql, statement.params, statement.params_types, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?, statement.params_names)
-        timeout = options.timeout
-        promise = @futures.promise
+        timestamp = nil
+        timestamp = Time.now if @connection_options.client_timestamps? && @connection_options.protocol_version > 2
+        request   = Protocol::QueryRequest.new(statement.cql, statement.params, statement.params_types, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?, statement.params_names, timestamp)
+        timeout   = options.timeout
+        promise   = @futures.promise
 
         keyspace = @keyspace
         plan     = @load_balancing_policy.plan(keyspace, statement, options)
@@ -234,9 +236,11 @@ module Cassandra
       end
 
       def execute(statement, options)
+        timestamp       = nil
+        timestamp       = Time.now if @connection_options.client_timestamps? && @connection_options.protocol_version > 2
         timeout         = options.timeout
         result_metadata = statement.result_metadata
-        request         = Protocol::ExecuteRequest.new(nil, statement.params_types, statement.params, result_metadata.nil?, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?)
+        request         = Protocol::ExecuteRequest.new(nil, statement.params_types, statement.params, result_metadata.nil?, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?, timestamp)
         promise         = @futures.promise
 
         keyspace = @keyspace
@@ -250,12 +254,15 @@ module Cassandra
       def batch(statement, options)
         return @futures.error(Errors::ClientError.new("Batch statements are not supported by the current version of Apache Cassandra")) if @connection_options.protocol_version < 2
 
-        timeout  = options.timeout
-        keyspace = @keyspace
-        plan     = @load_balancing_policy.plan(keyspace, statement, options)
-        promise  = @futures.promise
+        timestamp = nil
+        timestamp = Time.now if @connection_options.client_timestamps? && @connection_options.protocol_version > 2
+        timeout   = options.timeout
+        request   = Protocol::BatchRequest.new(BATCH_TYPES[statement.type], options.consistency, options.trace?, options.serial_consistency, timestamp)
+        keyspace  = @keyspace
+        plan      = @load_balancing_policy.plan(keyspace, statement, options)
+        promise   = @futures.promise
 
-        batch_by_plan(promise, keyspace, statement, options, plan, timeout)
+        batch_by_plan(promise, keyspace, statement, options, request, plan, timeout)
 
         promise.future
       end
@@ -509,7 +516,7 @@ module Cassandra
         end
       end
 
-      def batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors = nil, hosts = [])
+      def batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors = nil, hosts = [])
         unless plan.has_next?
           promise.break(Errors::NoHostsAvailable.new(errors))
           return
@@ -522,7 +529,7 @@ module Cassandra
         unless pool
           errors ||= {}
           errors[host] = NOT_CONNECTED
-          return batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+          return batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
         end
 
         connection = pool.random_connection
@@ -531,14 +538,14 @@ module Cassandra
           switch = switch_keyspace(connection, keyspace, timeout)
           switch.on_complete do |s|
             if s.resolved?
-              batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, plan, timeout, errors, hosts)
+              batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, request, options, plan, timeout, errors, hosts)
             else
               s.on_failure do |e|
                 case e
                 when Errors::HostError
                   errors ||= {}
                   errors[host] = e
-                  batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                  batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
                 else
                   promise.break(e)
                 end
@@ -546,16 +553,16 @@ module Cassandra
             end
           end
         else
-          batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, plan, timeout, errors, hosts)
+          batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, request, options, plan, timeout, errors, hosts)
         end
       rescue => e
         errors ||= {}
         errors[host] = e
-        batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+        batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
       end
 
-      def batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, options, plan, timeout, errors, hosts)
-        request    = Protocol::BatchRequest.new(BATCH_TYPES[statement.type], options.consistency, options.trace?)
+      def batch_and_send_request_by_plan(host, connection, promise, keyspace, statement, request, options, plan, timeout, errors, hosts)
+        request.clear
         unprepared = Hash.new {|hash, cql| hash[cql] = []}
 
         statement.statements.each do |statement|
@@ -598,7 +605,7 @@ module Cassandra
                 when Errors::HostError
                   errors ||= {}
                   errors[host] = e
-                  batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                  batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
                 else
                   promise.break(e)
                 end
@@ -711,7 +718,7 @@ module Cassandra
                   when Protocol::ExecuteRequest
                     execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
                   when Protocol::BatchRequest
-                    batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                    batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
                   end
                 else
                   promise.break(error)
@@ -774,7 +781,7 @@ module Cassandra
               when Protocol::ExecuteRequest
                 execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
               when Protocol::BatchRequest
-                batch_by_plan(promise, keyspace, statement, options, plan, timeout, errors, hosts)
+                batch_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
               else
                 promise.break(e)
               end

data/lib/cassandra/cluster/connector.rb

@@ -114,6 +114,13 @@ module Cassandra
       def do_connect(host)
         @reactor.connect(host.ip.to_s, @connection_options.port, {:timeout => @connection_options.connect_timeout, :ssl => @connection_options.ssl}) do |connection|
           raise Errors::ClientError, 'Not connected, reactor stopped' unless connection
+
+          if @connection_options.nodelay?
+            connection.to_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+          else
+            connection.to_io.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 0)
+          end
+
           Protocol::CqlProtocolHandler.new(connection, @reactor, @connection_options.protocol_version, @connection_options.compressor, @connection_options.heartbeat_interval, @connection_options.idle_timeout)
         end.flat_map do |connection|
           f = request_options(connection)

data/lib/cassandra/cluster/control_connection.rb

@@ -242,6 +242,8 @@ module Cassandra
       def refresh_schema_async
         connection = @connection
 
+        @logger.info("Refreshing schema")
+
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         keyspaces = send_select_request(connection, SELECT_KEYSPACES)
@@ -259,6 +261,7 @@ module Cassandra
 
           @schema.update_keyspaces(host, keyspaces, tables, columns, types)
           @metadata.rebuild_token_map
+          @logger.info("Schema refreshed")
         end
       end
 
@@ -674,7 +677,7 @@ Control connection failed and is unlikely to recover.
           register_async
         end
         f = f.flat_map { refresh_hosts_async_maybe_retry }
-        f = f.flat_map { refresh_schema_async_maybe_retry }
+        f = f.flat_map { refresh_schema_async_maybe_retry } if @connection_options.synchronize_schema?
         f = f.fallback do |error|
           @logger.debug("Connection to #{host.ip} failed (#{error.class.name}: #{error.message})")
 

data/lib/cassandra/cluster/metadata.rb

@@ -80,16 +80,22 @@ module Cassandra
 
         token_ring     = tokens.to_a
         token_replicas = ::Hash.new
+        token_maps     = ::Hash.new
 
         @schema.each_keyspace do |keyspace|
           replication = keyspace.replication
-          strategy    = @strategies[replication.klass] || @default_strategy
+          key         = replication_key(replication.klass, replication.options)
+
+          unless token_maps.include?(key)
+            strategy        = @strategies[replication.klass] || @default_strategy
+            token_maps[key] = strategy.replication_map(
+              token_to_host,
+              token_ring,
+              replication.options
+            )
+          end
 
-          token_replicas[keyspace.name] = strategy.replication_map(
-            token_to_host,
-            token_ring,
-            replication.options
-          )
+          token_replicas[keyspace.name] = token_maps[key]
         end
 
         @token_replicas = token_replicas
@@ -100,6 +106,10 @@ module Cassandra
 
       private
 
+      def replication_key(klass, options)
+        (klass + ':' + options.keys.sort.map {|k| "#{k}=#{options[k]}"}.join(',')).hash
+      end
+
       def insertion_point(list, item)
         min = 0
         max = list.size - 1

data/lib/cassandra/cluster/options.rb

@@ -25,7 +25,7 @@ module Cassandra
                   :schema_refresh_delay, :schema_refresh_timeout
       attr_accessor :protocol_version
 
-      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout, synchronize_schema, schema_refresh_delay, schema_refresh_timeout)
+      def initialize(protocol_version, credentials, auth_provider, compressor, port, connect_timeout, ssl, connections_per_local_node, connections_per_remote_node, heartbeat_interval, idle_timeout, synchronize_schema, schema_refresh_delay, schema_refresh_timeout, client_timestamps, nodelay)
         @protocol_version       = protocol_version
         @credentials            = credentials
         @auth_provider          = auth_provider
@@ -38,6 +38,8 @@ module Cassandra
         @synchronize_schema     = synchronize_schema
         @schema_refresh_delay   = schema_refresh_delay
         @schema_refresh_timeout = schema_refresh_timeout
+        @client_timestamps      = client_timestamps
+        @nodelay                = nodelay
 
         @connections_per_local_node  = connections_per_local_node
         @connections_per_remote_node = connections_per_remote_node
@@ -47,6 +49,14 @@ module Cassandra
         @synchronize_schema
       end
 
+      def client_timestamps?
+        @client_timestamps
+      end
+
+      def nodelay?
+        @nodelay
+      end
+
       def compression
         @compressor && @compressor.algorithm
       end

data/lib/cassandra/cluster/schema.rb

@@ -385,7 +385,7 @@ module Cassandra
           index   = Column::Index.new(column['index_name'])
         else
           options = ::JSON.load(column['index_options'])
-          index   = Column::Index.new(column['index_name'], options['class_name'])
+          index   = Column::Index.new(column['index_name'], options && options['class_name'])
         end
 
         Column.new(name, type, order, index, is_static, is_frozen)

data/lib/cassandra/cluster/schema/replication_strategies/network_topology.rb

@@ -24,56 +24,65 @@ module Cassandra
         # @private
         class NetworkTopology
           def replication_map(token_hosts, token_ring, replication_options)
-            size  = token_ring.size
-            racks = ::Hash.new
-            token_hosts.each_value do |host|
+            racks                  = ::Hash.new
+            datacenter_token_rings = ::Hash.new
+            size                   = token_ring.size
+
+            token_ring.each_with_index do |token, i|
+              host = token_hosts[token]
+
               racks[host.datacenter] ||= ::Set.new
               racks[host.datacenter].add(host.rack)
+
+              datacenter_token_rings[host.datacenter]  ||= Hash.new
+              datacenter_token_rings[host.datacenter][i] = token
             end
 
             replication_map = ::Hash.new
 
             token_ring.each_with_index do |token, i|
-              all_replicas = ::Hash.new
-              visited = ::Hash.new
-              skipped_datacenter_hosts = ::Hash.new
               replicas = ::Set.new
+              visited  = ::Hash.new
+              skipped  = ::Hash.new
 
-              size.times do |j|
-                break if all_replicas.size == racks.size && !all_replicas.any? {|(datacenter, r)| r.size < Integer(replication_options[datacenter])}
-
-                host       = token_hosts[token_ring[(i + j) % size]]
-                datacenter = host.datacenter
-                next if datacenter.nil?
+              replication_options.each do |datacenter, factor|
+                ring = datacenter_token_rings[datacenter]
+                next unless ring
+                factor = [Integer(factor), ring.size].min rescue next
 
-                factor = replication_options[datacenter]
-                next unless factor
 
-                factor = Integer(factor) rescue next
+                total_racks    = racks[datacenter].size
+                visited_racks  = visited[datacenter] ||= ::Set.new
+                skipped_hosts  = skipped[datacenter] ||= ::Set.new
+                added_replicas = ::Set.new
 
-                replicas_in_datacenter = all_replicas[datacenter] ||= ::Set.new
-                next if replicas_in_datacenter.size >= factor
+                size.times do |j|
+                  break if added_replicas.size >= factor
 
-                rack = host.rack
-                visited_racks = visited[datacenter] ||= ::Set.new
+                  tk = ring[(i + j) % size]
+                  next unless tk
+                  host = token_hosts[tk]
+                  rack = host.rack
 
-                if rack.nil? || visited_racks.size == racks[datacenter].size
-                  replicas << host
-                  replicas_in_datacenter << host
-                else
-                  if visited_racks.include?(rack)
-                    skipped_hosts = skipped_datacenter_hosts[datacenter] ||= ::Set.new
-                    skipped_hosts << host
-                  else
+                  # unknown rack or seen all racks
+                  if rack.nil? || visited_racks.size == total_racks
                     replicas << host
-                    replicas_in_datacenter << host
-                    visited_racks << rack
-
-                    if visited_racks.size == racks[datacenter].size && (skipped_hosts = skipped_datacenter_hosts[datacenter]) && replicas_in_datacenter.size < factor
-                      skipped_hosts.each do |skipped_host|
-                        replicas << skipped_host
-                        replicas_in_datacenter << skipped_host
-                        break if replicas_in_datacenter.size >= factor
+                    added_replicas << host
+                  else
+                    if visited_racks.include?(rack)
+                      skipped_hosts << host
+                    else
+                      replicas << host
+                      visited_racks << rack
+                      added_replicas << host
+
+                      if visited_racks.size == total_racks
+                        skipped_hosts.each do |skipped_host|
+                          break if added_replicas.size >= factor
+
+                          replicas << skipped_host
+                          added_replicas << host
+                        end
                       end
                     end
                   end

data/lib/cassandra/cluster/schema/type_parser.rb

@@ -108,7 +108,7 @@ module Cassandra
             return lookup_type(node.children.first)
           end
 
-          type = @@types[node.name]
+          type = @@types.fetch(node.name) { return Cassandra::Types.custom(dump_node(node)) }
 
           case type
           when :set, :list
@@ -159,6 +159,12 @@ module Cassandra
 
           root
         end
+
+        def dump_node(node)
+          str = node.name
+          str << '(' + node.children.map {|n| dump_node(n)}.join(',') + ')' unless node.children.empty?
+          str
+        end
       end
     end
   end

data/lib/cassandra/compression.rb

@@ -64,3 +64,6 @@ module Cassandra
     end
   end
 end
+
+require 'cassandra/compression/compressors/snappy'
+require 'cassandra/compression/compressors/lz4'

data/lib/cassandra/compression/compressors/lz4.rb

@@ -16,12 +16,6 @@
 # limitations under the License.
 #++
 
-begin
-  require 'lz4-ruby'
-rescue LoadError => e
-  raise LoadError, %[LZ4 support requires the "lz4-ruby" gem: #{e.message}], e.backtrace
-end
-
 module Cassandra
   module Compression
     module Compressors
@@ -40,6 +34,14 @@ module Cassandra
         # @param [Integer] min_size (64) Don't compress frames smaller than
         #   this size (see {#compress?}).
         def initialize(min_size=64)
+          unless defined?(::LZ4::Raw)
+            begin
+              require 'lz4-ruby'
+            rescue LoadError => e
+              raise LoadError, %[LZ4 support requires the "lz4-ruby" gem: #{e.message}], e.backtrace
+            end
+          end
+
           @algorithm = 'lz4'.freeze
           @min_size = min_size
         end

data/lib/cassandra/compression/compressors/snappy.rb

@@ -16,12 +16,6 @@
 # limitations under the License.
 #++
 
-begin
-  require 'snappy'
-rescue LoadError => e
-  raise LoadError, %[Snappy support requires the "snappy" gem: #{e.message}], e.backtrace
-end
-
 module Cassandra
   module Compression
     module Compressors
@@ -40,6 +34,14 @@ module Cassandra
         # @param [Integer] min_size (64) Don't compress frames smaller than
         #   this size (see {#compress?}).
         def initialize(min_size=64)
+          unless defined?(::Snappy)
+            begin
+              require 'snappy'
+            rescue LoadError => e
+              raise LoadError, %[Snappy support requires the "snappy" gem: #{e.message}], e.backtrace
+            end
+          end
+
           @algorithm = 'snappy'.freeze
           @min_size = min_size
         end

data/lib/cassandra/driver.rb

@@ -86,7 +86,9 @@ module Cassandra
         idle_timeout,
         synchronize_schema,
         schema_refresh_delay,
-        schema_refresh_timeout
+        schema_refresh_timeout,
+        client_timestamps,
+        nodelay
       )
     end
 
@@ -114,6 +116,8 @@ module Cassandra
     let(:schema_refresh_timeout)    { 10 }
     let(:thread_pool_size)          { 4 }
     let(:shuffle_replicas)          { true }
+    let(:client_timestamps)         { false }
+    let(:nodelay)                   { false }
 
     let(:connections_per_local_node)  { 2 }
     let(:connections_per_remote_node) { 1 }
@@ -143,7 +147,11 @@ module Cassandra
         if f.resolved?
           promise.fulfill(cluster)
         else
-          f.on_failure {|e| promise.break(e)}
+          f.on_failure do |e|
+            cluster.close_async.on_complete do |_, _|
+              promise.break(e)
+            end
+          end
         end
       end
 

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -258,6 +258,10 @@ 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/requests/batch_request.rb

@@ -23,14 +23,21 @@ module Cassandra
       UNLOGGED_TYPE = 1
       COUNTER_TYPE = 2
 
-      attr_reader :type
+      attr_reader :type, :timestamp
       attr_accessor :consistency, :retries
 
-      def initialize(type, consistency, trace=false)
+      def initialize(type, consistency, trace=false, serial_consistency = nil, timestamp = nil)
         super(0x0D, trace)
         @type  = type
         @parts = []
         @consistency = consistency
+        @serial_consistency = serial_consistency
+        @timestamp = timestamp
+      end
+
+      def clear
+        @parts.clear
+        nil
       end
 
       def add_query(cql, values, types)
@@ -54,9 +61,13 @@ module Cassandra
         buffer.append_consistency(@consistency)
 
         if protocol_version > 2
-          flags = 0
+          flags  = 0
+          flags |= 0x10 if @serial_consistency
+          flags |= 0x20 if @timestamp
 
           buffer.append(flags.chr)
+          buffer.append_consistency(@serial_consistency) if @serial_consistency
+          buffer.append_timestamp(@timestamp) if @timestamp
         end
 
         buffer

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

@@ -19,10 +19,10 @@
 module Cassandra
   module Protocol
     class ExecuteRequest < Request
-      attr_reader :metadata, :values, :request_metadata, :serial_consistency, :page_size, :paging_state
+      attr_reader :metadata, :values, :request_metadata, :serial_consistency, :page_size, :paging_state, :timestamp
       attr_accessor :consistency, :retries, :id
 
-      def initialize(id, metadata, values, request_metadata, consistency, serial_consistency=nil, page_size=nil, paging_state=nil, trace=false)
+      def initialize(id, metadata, values, request_metadata, consistency, serial_consistency=nil, page_size=nil, paging_state=nil, trace=false, timestamp = nil)
         raise ArgumentError, "Metadata for #{metadata.size} columns, but #{values.size} values given" if metadata.size != values.size
         raise ArgumentError, %(No such consistency: #{consistency.inspect}) if consistency.nil? || !CONSISTENCIES.include?(consistency)
         raise ArgumentError, %(No such consistency: #{serial_consistency.inspect}) unless serial_consistency.nil? || CONSISTENCIES.include?(serial_consistency)
@@ -36,6 +36,7 @@ module Cassandra
         @serial_consistency = serial_consistency
         @page_size = page_size
         @paging_state = paging_state
+        @timestamp = timestamp
       end
 
       def write(buffer, protocol_version, encoder)
@@ -48,6 +49,9 @@ module Cassandra
           flags |= 0x04 if @page_size
           flags |= 0x08 if @paging_state
           flags |= 0x10 if @serial_consistency
+          if protocol_version > 2
+            flags |= 0x20 if @timestamp
+          end
           buffer.append(flags.chr)
           if @values.size > 0
             encoder.write_parameters(buffer, @values, @metadata)
@@ -55,6 +59,9 @@ 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
+          if protocol_version > 2
+            buffer.append_timestamp(@timestamp) if @timestamp
+          end
         else
           encoder.write_parameters(buffer, @values, @metadata)
           buffer.append_consistency(@consistency)

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

@@ -19,10 +19,10 @@
 module Cassandra
   module Protocol
     class QueryRequest < Request
-      attr_reader :cql, :values, :type_hints, :serial_consistency, :page_size, :paging_state
+      attr_reader :cql, :values, :type_hints, :serial_consistency, :page_size, :paging_state, :timestamp
       attr_accessor :consistency, :retries
 
-      def initialize(cql, values, type_hints, consistency, serial_consistency = nil, page_size = nil, paging_state = nil, trace = false, names = EMPTY_LIST)
+      def initialize(cql, values, type_hints, consistency, serial_consistency = nil, page_size = nil, paging_state = nil, trace = false, names = EMPTY_LIST, timestamp = nil)
         super(7, trace)
         @cql = cql
         @values = values
@@ -32,6 +32,7 @@ module Cassandra
         @page_size = page_size
         @paging_state = paging_state
         @names = names
+        @timestamp = timestamp
       end
 
       def write(buffer, protocol_version, encoder)
@@ -42,9 +43,14 @@ module Cassandra
           flags |= 0x04 if @page_size
           flags |= 0x08 if @paging_state
           flags |= 0x10 if @serial_consistency
+          if protocol_version > 2
+            flags |= 0x20 if @timestamp
+          end
           if @values && @values.size > 0
             flags |= 0x01
-            flags |= 0x40 unless @names.empty?
+            if protocol_version > 2
+              flags |= 0x40 unless @names.empty?
+            end
             buffer.append(flags.chr)
             encoder.write_parameters(buffer, @values, @type_hints, @names)
           else
@@ -53,6 +59,9 @@ 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
+          if protocol_version > 2
+            buffer.append_timestamp(@timestamp) if @timestamp
+          end
         end
         buffer
       end

data/lib/cassandra/types.rb

@@ -1199,8 +1199,13 @@ module Cassandra
 
       # @return [String] a cassandra representation of this type
       def to_s
-        "custom: #{@name}"
+        "'#{@name}'"
       end
+
+      def eql?(other)
+        other.is_a?(Custom) && @name == other.name
+      end
+      alias :== :eql?
     end
 
     # @return [Cassandra::Types::Varchar] varchar type

data/lib/cassandra/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Cassandra
-  VERSION = '2.1.3'.freeze
+  VERSION = '2.1.4'.freeze
 end

data/lib/datastax/cassandra.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2015 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 DataStax
+  @base = __FILE__ + '/../..'
+
+  def self.require(path)
+    if path.start_with?('cassandra/')
+      include(path)
+    else
+      ::Kernel.require(path)
+    end
+  end
+
+  def self.include(path)
+    path = File.expand_path(path + '.rb', @base)
+    class_eval(File.read(path), path, 1)
+  end
+
+  previous = nil
+  if defined?(::Cassandra)
+    previous = ::Cassandra
+    Object.send(:remove_const, :Cassandra)
+  end
+  include 'cassandra'
+  DataStax::Cassandra::Murmur3 = ::Cassandra::Murmur3
+  Object.send(:remove_const, :Cassandra)
+  ::Cassandra = previous if previous
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra-driver
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.1.4
 platform: java
 authors:
 - Theo Hultberg
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-13 00:00:00.000000000 Z
+date: 2015-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -180,6 +180,7 @@ files:
 - lib/cassandra/uuid/generator.rb
 - lib/cassandra/version.rb
 - lib/cassandra_murmur3.jar
+- lib/datastax/cassandra.rb
 homepage: http://datastax.github.io/ruby-driver
 licenses:
 - Apache License 2.0