cassandra-driver 1.2.0-java → 2.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4d3013280c22a0d22b0bf77340c1c27c3fc0bbc
-  data.tar.gz: 19450149da8ffdd4eeeb53962ddc3640dc25a1d5
+  metadata.gz: ac564e933a3a1b1d04c14f96afa1ac994b458791
+  data.tar.gz: 3b1dcfad7d8ef21c9aa36636315a7cb04c881c6b
 SHA512:
-  metadata.gz: ca9a5a0b9801ba7bfa4ac53cbcd697c45a5dfdc4febb1da959ae4a7b476d2883c0206233d53fa0dc3ab2e0e17c0417776c3302199a4f46dd55887a15ba470476
-  data.tar.gz: 55149c4d71b6b7c2cb544d4267b30438d6d261c20a6ecb4d14327620ff5bed9d9bb4b5111da4d2c1adac59fc4b4cd25b73c3a7edc0d21f7d1460a5fc32bac9f8
+  metadata.gz: e74e1b2f03f7b3c5d144018e5d50c290894369c01ee9d57afc072d1a75aed0a248bc931b56c941263ec754fb00e82c9d5ae024908ab00209b06eff30149d8a57
+  data.tar.gz: 09f253218bf4355dba7c321565124800cdef73b3c764aa84d51f09b21f270c9cbe971c9b7e668e4871ca1390ad6f8acd0a573c50d827665e3d6a020397a4fd4b

data/README.md

@@ -93,12 +93,12 @@ __Note__: if you want to use compression you should also install [snappy](http:/
 
 Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API. In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/master/examples/cql-rb-wrapper.rb) to assist you with gradual upgrade.
 
-## What's new in v1.2.0
+## What's new in v2.0.0
 
-Bug Fixes:
+Current release lays groundwork for the upcoming support of native protocol v3 and Apache Cassandra 2.1. This release introduces the following major public API changes:
 
-* [RUBY-83] Timestamps loses microseconds when retrieved from database
-* [RUBY-85] Driver doesn't always reconnect
+* Positional arguments to `Session#execute` must be passed via `:arguments` option key.
+* `Batch#add` and `Prepared#bind` accept an array of arguments instead of variable arguments (`args` instead of `*args`).
 
 ## Code examples
 

data/lib/cassandra.rb

@@ -503,11 +503,15 @@ module Cassandra
     driver = Driver.new(options)
     driver.connect(hosts)
   end
+
+  # @private
+  EMPTY_LIST = [].freeze
 end
 
-require 'cassandra/errors'
 require 'cassandra/uuid'
 require 'cassandra/time_uuid'
+
+require 'cassandra/errors'
 require 'cassandra/compression'
 require 'cassandra/protocol'
 require 'cassandra/auth'
@@ -548,6 +552,4 @@ module Cassandra
   VOID_OPTIONS   = Execution::Options.new({:consistency => :one})
   # @private
   NO_HOSTS       = Errors::NoHostsAvailable.new
-  # @private
-  EMPTY_LIST = [].freeze
 end

data/lib/cassandra/cluster/client.rb

@@ -199,7 +199,7 @@ module Cassandra
 
 
       def query(statement, options)
-        request = Protocol::QueryRequest.new(statement.cql, statement.params, nil, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?)
+        request = Protocol::QueryRequest.new(statement.cql, statement.params, statement.params_types, options.consistency, options.serial_consistency, options.page_size, options.paging_state, options.trace?)
         timeout = options.timeout
         promise = @futures.promise
 
@@ -228,7 +228,7 @@ module Cassandra
       def execute(statement, options)
         timeout         = options.timeout
         result_metadata = statement.result_metadata
-        request         = Protocol::ExecuteRequest.new(nil, statement.params_metadata, 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?)
         promise         = @futures.promise
 
         keyspace = @keyspace
@@ -276,8 +276,8 @@ module Cassandra
       BOOTSTRAPPING_ERROR_CODE = 0x1002
       UNPREPARED_ERROR_CODE    = 0x2500
 
-      SELECT_SCHEMA_PEERS = Protocol::QueryRequest.new("SELECT peer, rpc_address, schema_version FROM system.peers", nil, nil, :one)
-      SELECT_SCHEMA_LOCAL = Protocol::QueryRequest.new("SELECT schema_version FROM system.local WHERE key='local'", nil, nil, :one)
+      SELECT_SCHEMA_PEERS = Protocol::QueryRequest.new("SELECT peer, rpc_address, schema_version FROM system.peers", EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_SCHEMA_LOCAL = Protocol::QueryRequest.new("SELECT schema_version FROM system.local WHERE key='local'", EMPTY_LIST, EMPTY_LIST, :one)
 
       def connected(f)
         if f.resolved?
@@ -545,12 +545,12 @@ module Cassandra
             id = synchronize { @prepared_statements[host][cql] }
 
             if id
-              request.add_prepared(id, statement.params_metadata, statement.params)
+              request.add_prepared(id, statement.params, statement.params_types)
             else
               unprepared[cql] << statement
             end
           else
-            request.add_query(cql, statement.params)
+            request.add_query(cql, statement.params, statement.params_types)
           end
         end
 
@@ -567,7 +567,7 @@ module Cassandra
               prepared_ids = f.value
               to_prepare.each_with_index do |(_, statements), i|
                 statements.each do |statement|
-                  request.add_prepared(prepared_ids[i], statement.params_metadata, statement.params)
+                  request.add_prepared(prepared_ids[i], statement.params, statement.params_types)
                 end
               end
 
@@ -640,54 +640,92 @@ module Cassandra
         f.on_complete do |f|
           if f.resolved?
             r = f.value
-            case r
-            when Protocol::DetailedErrorResponse
-              details  = r.details
-              decision = begin
-                case r.code
-                when UNAVAILABLE_ERROR_CODE
-                  @retry_policy.unavailable(statement, details[:cl], details[:required], details[:alive], retries)
-                when WRITE_TIMEOUT_ERROR_CODE
-                  @retry_policy.write_timeout(statement, details[:cl], details[:write_type], details[:blockfor], details[:received], retries)
-                when READ_TIMEOUT_ERROR_CODE
-                  @retry_policy.read_timeout(statement, details[:cl], details[:blockfor], details[:received], details[:data_present], retries)
-                when UNPREPARED_ERROR_CODE
-                  cql = statement.cql
-
-                  synchronize do
-                    @preparing_statements[host].delete(cql)
-                    @prepared_statements[host].delete(cql)
-                  end
 
-                  prepare = prepare_statement(host, connection, cql, timeout)
-                  prepare.on_complete do |_|
-                    if prepare.resolved?
-                      request.id = prepare.value
-                      do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
-                    else
-                      prepare.on_failure do |e|
-                        case e
-                        when Errors::HostError
-                          errors ||= {}
-                          errors[host] = e
-                          execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
-                        else
-                          promise.break(e)
-                        end
+            begin
+              decision = nil
+
+              case r
+              when Protocol::UnavailableErrorResponse
+                decision = @retry_policy.unavailable(statement, r.consistency, r.required, r.alive, retries)
+              when Protocol::WriteTimeoutErrorResponse
+                decision = @retry_policy.write_timeout(statement, r.consistency, r.write_type, r.blockfor, r.received, retries)
+              when Protocol::ReadTimeoutErrorResponse
+                decision = @retry_policy.read_timeout(statement, r.consistency, r.blockfor, r.received, r.data_present, retries)
+              when Protocol::UnpreparedErrorResponse
+                cql = statement.cql
+
+                synchronize do
+                  @preparing_statements[host].delete(cql)
+                  @prepared_statements[host].delete(cql)
+                end
+
+                prepare = prepare_statement(host, connection, cql, timeout)
+                prepare.on_complete do |_|
+                  if prepare.resolved?
+                    request.id = prepare.value
+                    do_send_request_by_plan(host, connection, promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  else
+                    prepare.on_failure do |e|
+                      case e
+                      when Errors::HostError
+                        errors ||= {}
+                        errors[host] = e
+                        execute_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                      else
+                        promise.break(e)
                       end
                     end
                   end
+                end
+              when Protocol::ErrorResponse
+                error = r.to_error(statement)
 
-                  nil
+                case error
+                when Errors::HostError
+                  errors ||= {}
+                  errors[host] = error
+
+                  case request
+                  when Protocol::QueryRequest, Protocol::PrepareRequest
+                    send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
+                  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)
+                  end
                 else
-                  promise.break(r.to_error(statement))
-
-                  nil
+                  promise.break(error)
+                end
+              when Protocol::SetKeyspaceResultResponse
+                @keyspace = r.keyspace
+                promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+              when Protocol::PreparedResultResponse
+                cql = request.cql
+                synchronize do
+                  @prepared_statements[host][cql] = r.id
+                  @preparing_statements[host].delete(cql)
                 end
-              rescue => e
-                promise.break(e)
 
-                nil
+                promise.fulfill(Statements::Prepared.new(cql, r.metadata, r.result_metadata, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures, @schema))
+              when Protocol::RawRowsResultResponse
+                r.materialize(statement.result_metadata)
+                promise.fulfill(Results::Paged.new(r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+              when Protocol::RowsResultResponse
+                promise.fulfill(Results::Paged.new(r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+              when Protocol::SchemaChangeResultResponse
+                @schema.delete_keyspace(r.keyspace) if r.change == 'DROPPED' && r.table.empty?
+
+                @logger.debug('Waiting for schema to propagate to all hosts after a change')
+                wait_for_schema_agreement(connection, @reconnection_policy.schedule).on_complete do |f|
+                  unless f.resolved?
+                    f.on_failure do |e|
+                      @logger.error("Schema agreement failure (#{e.class.name}: #{e.message})")
+                    end
+                  end
+                  promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+                end
+              else
+                promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
               end
 
               if decision
@@ -703,53 +741,8 @@ module Cassandra
                   promise.break(r.to_error(statement))
                 end
               end
-            when Protocol::ErrorResponse
-              case r.code
-              when OVERLOADED_ERROR_CODE, SERVER_ERROR_CODE, BOOTSTRAPPING_ERROR_CODE
-                errors ||= {}
-                errors[host] = r.to_error(statement)
-
-                case request
-                when Protocol::QueryRequest, Protocol::PrepareRequest
-                  send_request_by_plan(promise, keyspace, statement, options, request, plan, timeout, errors, hosts)
-                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)
-                end
-              else
-                promise.break(r.to_error(statement))
-              end
-            when Protocol::SetKeyspaceResultResponse
-              @keyspace = r.keyspace
-              promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-            when Protocol::PreparedResultResponse
-              cql = request.cql
-              synchronize do
-                @prepared_statements[host][cql] = r.id
-                @preparing_statements[host].delete(cql)
-              end
-
-              promise.fulfill(Statements::Prepared.new(cql, r.metadata, r.result_metadata, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures, @schema))
-            when Protocol::RawRowsResultResponse
-              r.materialize(statement.result_metadata)
-              promise.fulfill(Results::Paged.new(r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-            when Protocol::RowsResultResponse
-              promise.fulfill(Results::Paged.new(r.rows, r.paging_state, r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-            when Protocol::SchemaChangeResultResponse
-              @schema.delete_keyspace(r.keyspace) if r.change == 'DROPPED' && r.table.empty?
-
-              @logger.debug('Waiting for schema to propagate to all hosts after a change')
-              wait_for_schema_agreement(connection, @reconnection_policy.schedule).on_complete do |f|
-                unless f.resolved?
-                  f.on_failure do |e|
-                    @logger.error("Schema agreement failure (#{e.class.name}: #{e.message})")
-                  end
-                end
-                promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
-              end
-            else
-              promise.fulfill(Results::Void.new(r.trace_id, keyspace, statement, options, hosts, request.consistency, retries, self, @futures))
+            rescue => e
+              promise.break(e)
             end
           else
             f.on_failure do |e|
@@ -820,7 +813,7 @@ module Cassandra
 
         return pending_switch || Ione::Future.resolved if pending_keyspace == keyspace
 
-        request = Protocol::QueryRequest.new("USE #{Util.escape_name(keyspace)}", nil, nil, :one)
+        request = Protocol::QueryRequest.new("USE #{Util.escape_name(keyspace)}", EMPTY_LIST, EMPTY_LIST, :one)
 
         f = connection.send_request(request, timeout).map do |r|
           case r

data/lib/cassandra/cluster/control_connection.rb

@@ -152,11 +152,12 @@ module Cassandra
 
       private
 
-      SELECT_LOCAL     = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, release_version, tokens, partitioner FROM system.local', nil, nil, :one)
-      SELECT_PEERS     = Protocol::QueryRequest.new('SELECT peer, rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers', nil, nil, :one)
-      SELECT_KEYSPACES = Protocol::QueryRequest.new('SELECT * FROM system.schema_keyspaces', nil, nil, :one)
-      SELECT_TABLES    = Protocol::QueryRequest.new('SELECT * FROM system.schema_columnfamilies', nil, nil, :one)
-      SELECT_COLUMNS   = Protocol::QueryRequest.new('SELECT * FROM system.schema_columns', nil, nil, :one)
+      SELECT_LOCAL     = Protocol::QueryRequest.new('SELECT rack, data_center, host_id, release_version, tokens, partitioner FROM system.local', EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_PEERS     = Protocol::QueryRequest.new('SELECT peer, rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers', EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_KEYSPACES = Protocol::QueryRequest.new('SELECT * FROM system.schema_keyspaces', EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_TABLES    = Protocol::QueryRequest.new('SELECT * FROM system.schema_columnfamilies', EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_COLUMNS   = Protocol::QueryRequest.new('SELECT * FROM system.schema_columns', EMPTY_LIST, EMPTY_LIST, :one)
+      SELECT_TYPES     = Protocol::QueryRequest.new('SELECT * FROM system.schema_usertypes', EMPTY_LIST, EMPTY_LIST, :one)
 
       def reconnect_async(schedule)
         timeout = schedule.next
@@ -314,9 +315,9 @@ module Cassandra
 
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
-        keyspaces = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_keyspaces WHERE keyspace_name = '%s'" % keyspace, nil, nil, :one))
-        tables    = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '%s'" % keyspace, nil, nil, :one))
-        columns   = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = '%s'" % keyspace, nil, nil, :one))
+        keyspaces = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_keyspaces WHERE keyspace_name = '%s'" % keyspace, EMPTY_LIST, EMPTY_LIST, :one))
+        tables    = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '%s'" % keyspace, EMPTY_LIST, EMPTY_LIST, :one))
+        columns   = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = '%s'" % keyspace, EMPTY_LIST, EMPTY_LIST, :one))
 
         Ione::Future.all(keyspaces, tables, columns).map do |(keyspaces, tables, columns)|
           host = @registry.host(connection.host)
@@ -369,8 +370,8 @@ module Cassandra
         return Ione::Future.failed(Errors::ClientError.new('Not connected')) if connection.nil?
 
         params   = [keyspace, table]
-        tables   = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '%s' AND columnfamily_name = '%s'" % params, nil, nil, :one))
-        columns  = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = '%s' AND columnfamily_name = '%s'" % params, nil, nil, :one))
+        tables   = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columnfamilies WHERE keyspace_name = '%s' AND columnfamily_name = '%s'" % params, EMPTY_LIST, EMPTY_LIST, :one))
+        columns  = send_select_request(connection, Protocol::QueryRequest.new("SELECT * FROM system.schema_columns WHERE keyspace_name = '%s' AND columnfamily_name = '%s'" % params, EMPTY_LIST, EMPTY_LIST, :one))
 
         Ione::Future.all(tables, columns).map do |(tables, columns)|
           host = @registry.host(connection.host)
@@ -541,7 +542,7 @@ module Cassandra
         if ip == connection.host
           request = SELECT_LOCAL
         else
-          request = Protocol::QueryRequest.new("SELECT rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers WHERE peer = '%s'" % address, nil, nil, :one)
+          request = Protocol::QueryRequest.new("SELECT rack, data_center, host_id, rpc_address, release_version, tokens FROM system.peers WHERE peer = '%s'" % address, EMPTY_LIST, EMPTY_LIST, :one)
         end
 
         send_select_request(connection, request).map do |rows|
@@ -661,12 +662,12 @@ Control connection failed and is unlikely to recover.
 
         futures = ::Array.new
 
-        refresh_keyspaces.each do |(keyspace, _)|
+        refresh_keyspaces.each_key do |keyspace|
           futures << refresh_keyspace_async_maybe_retry(keyspace)
         end
 
         refresh_tables.each do |(keyspace, tables)|
-          tables.each do |(table, _)|
+          tables.each_key do |table|
             futures << refresh_table_async_maybe_retry(keyspace, table)
           end
         end

data/lib/cassandra/column.rb

@@ -65,15 +65,7 @@ module Cassandra
 
     # @return [String] a cql representation of this column
     def to_cql
-      type = case @type
-      when Array
-        type, *args = @type
-        "#{type.to_s}<#{args.map(&:to_s).join(', ')}>"
-      else
-        @type.to_s
-      end
-
-      cql = "#{@name} #{type}"
+      cql = "#{@name} #{Util.type_to_cql(@type)}"
       cql << ' static' if @static
       cql
     end

data/lib/cassandra/execution/options.rb

@@ -30,6 +30,8 @@ module Cassandra
       attr_reader :page_size
       # @return [Numeric] request timeout interval
       attr_reader :timeout
+      # @return [Array] positional arguments for the statement
+      attr_reader :arguments
 
       # @return [String] paging state
       #
@@ -53,6 +55,7 @@ module Cassandra
         timeout            = options[:timeout]
         serial_consistency = options[:serial_consistency]
         paging_state       = options[:paging_state]
+        arguments          = options[:arguments]
 
         Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
 
@@ -75,12 +78,19 @@ module Cassandra
           Util.assert_not_empty(paging_state) { ":paging_state must not be empty" }
         end
 
+        if arguments.nil?
+          arguments = EMPTY_LIST
+        else
+          Util.assert_instance_of(::Array, arguments) { ":arguments must be an Array, #{arguments.inspect} given" }
+        end
+
         @consistency        = consistency
         @page_size          = page_size
         @trace              = !!trace
         @timeout            = timeout
         @serial_consistency = serial_consistency
         @paging_state       = paging_state
+        @arguments          = arguments
       end
 
       # @return [Boolean] whether request tracing was enabled
@@ -88,6 +98,18 @@ module Cassandra
         @trace
       end
 
+      def eql?(other)
+        other.is_a?(Options) &&
+          other.consistency == @consistency &&
+          other.page_size == @page_size &&
+          other.trace? == @trace &&
+          other.timeout == @timeout &&
+          other.serial_consistency == @serial_consistency &&
+          other.paging_state == @paging_state &&
+          other.arguments == @arguments
+      end
+      alias :== :eql?
+
       # @private
       def override(*options)
         merged = options.unshift(to_h).inject do |base, opts|
@@ -106,7 +128,8 @@ module Cassandra
           :page_size          => @page_size,
           :trace              => @trace,
           :timeout            => @timeout,
-          :serial_consistency => @serial_consistency
+          :serial_consistency => @serial_consistency,
+          :arguments          => @arguments || EMPTY_LIST
         }
       end
     end