cql-rb 2.1.0.pre1 → 2.1.0.pre2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a2e1e800f2f73c9c9dd0c2beedaf55851174362
-  data.tar.gz: bf02fef5b52739fd1954f3ffcc4322a5c7ff1c01
+  metadata.gz: 5feed4b6caaa0042eda3f44328ce6f2132519fad
+  data.tar.gz: 975d84488e3f0e023d1846e9facd8c293a43634f
 SHA512:
-  metadata.gz: edfc218ddb4b1b5b1ca3f8d0a4fd0888e9bfa9bdc9b1ac974cf881e1dc9b853adc44d5b940fe3f953d6647beac297f99d8614fd36e1dc8ad1892fde752f2e9f1
-  data.tar.gz: f6ced79805a70ea44f4b3844480f56dbbd82bcbaaacbe86c2ad75725e9563d5c5f2d78a08d15bfd763ec4964251c1461eadb9f4cfde4112b0841729deba7bfc5
+  metadata.gz: f9b8860656c26696c6ac5447e02385b56096ba65b400fc686d77fd66682c74a85f135c98d1364e106f9f2b7a3e8dbb4f0ece9512c2be2ac62fc15452c40724e4
+  data.tar.gz: 4fa9ce7ca66ea3e84a99206fb11df31a5acbee4e4efdbc7bee346af64709cd65520d692d33dbd930b38b342824f3b3c635d25e0d82b00249c0269524eb872c9f

data/lib/cql.rb

@@ -17,6 +17,7 @@ module Cql
   Io = Ione::Io
 end
 
+require 'cql/error_codes'
 require 'cql/uuid'
 require 'cql/time_uuid'
 require 'cql/compression'

data/lib/cql/client.rb

@@ -6,6 +6,8 @@ module Cql
   # if any. `message` contains the human readable error message sent by the
   # server.
   class QueryError < CqlError
+    include ErrorCodes
+
     attr_reader :code, :cql, :details
 
     def initialize(code, message, cql=nil, details=nil)

data/lib/cql/client/client.rb

@@ -367,7 +367,7 @@ module Cql
       def connect_with_protocol_version_fallback
         f = create_cluster_connector.connect_all(@hosts, @connections_per_node)
         f.fallback do |error|
-          if error.is_a?(QueryError) && error.code == 0x0a && @protocol_version > 1
+          if error.is_a?(QueryError) && error.code == QueryError::PROTOCOL_ERROR && @protocol_version > 1
             @logger.warn('Could not connect using protocol version %d (will try again with %d): %s' % [@protocol_version, @protocol_version - 1, error.message])
             @protocol_version -= 1
             connect_with_protocol_version_fallback

data/lib/cql/client/connection_manager.rb

@@ -7,17 +7,17 @@ module Cql
       include Enumerable
 
       def initialize
-        @connections = []
+        @connections = [].freeze
         @lock = Mutex.new
       end
 
       def add_connections(connections)
         @lock.synchronize do
-          @connections.concat(connections)
+          @connections = (@connections + connections).freeze
           connections.each do |connection|
             connection.on_closed do
               @lock.synchronize do
-                @connections.delete(connection)
+                @connections = (@connections - [connection]).freeze
               end
             end
           end
@@ -25,30 +25,31 @@ module Cql
       end
 
       def connected?
-        @lock.synchronize do
-          @connections.any?
-        end
+        !snapshot.empty?
       end
 
       def snapshot
-        @lock.synchronize do
-          @connections.dup
+        connections = nil
+        @lock.lock
+        begin
+          connections = @connections
+        ensure
+          @lock.unlock
         end
+        connections
       end
 
       def random_connection
-        raise NotConnectedError unless connected?
-        @lock.synchronize do
-          @connections.sample
-        end
+        connections = snapshot
+        raise NotConnectedError if connections.empty?
+        connections.sample
       end
 
       def each_connection(&callback)
         return self unless block_given?
-        raise NotConnectedError unless connected?
-        @lock.synchronize do
-          @connections.each(&callback)
-        end
+        connections = snapshot
+        raise NotConnectedError if connections.empty?
+        connections.each(&callback)
       end
       alias_method :each, :each_connection
     end

data/lib/cql/client/connector.rb

@@ -24,7 +24,7 @@ module Cql
           connected_connections = connections.select(&:connected?)
           if connected_connections.empty?
             e = connections.first.error
-            if e.is_a?(Cql::QueryError) && e.code == 0x100
+            if e.is_a?(QueryError) && e.code == QueryError::BAD_CREDENTIALS
               e = AuthenticationError.new(e.message)
             end
             raise e

data/lib/cql/client/prepared_statement.rb

@@ -150,7 +150,13 @@ module Cql
       def execute(*args)
         connection = @connection_manager.random_connection
         if connection[self]
-          run(args, connection)
+          f = run(args, connection)
+          f.fallback do |e|
+            raise e unless e.is_a?(QueryError) && e.code == QueryError::UNPREPARED
+            prepare(connection).flat_map do
+              run(args, connection)
+            end
+          end
         else
           prepare(connection).flat_map do
             run(args, connection)
@@ -216,11 +222,12 @@ module Cql
       private
 
       def run(args, connection)
-        bound_args = args.shift(@raw_metadata.size)
-        unless bound_args.size == @raw_metadata.size && args.size <= 1
+        bound_args = args.take(@raw_metadata.size)
+        remaining_args = args.drop(@raw_metadata.size)
+        unless bound_args.size == @raw_metadata.size && remaining_args.size <= 1
           raise ArgumentError, "Expected #{@raw_metadata.size} arguments, got #{bound_args.size}"
         end
-        options = @execute_options_decoder.decode_options(args.last)
+        options = @execute_options_decoder.decode_options(remaining_args.last)
         statement_id = connection[self]
         request_metadata = @raw_result_metadata.nil?
         request = Protocol::ExecuteRequest.new(statement_id, @raw_metadata, bound_args, request_metadata, options[:consistency], options[:serial_consistency], options[:page_size], options[:paging_state], options[:trace])

data/lib/cql/error_codes.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+module Cql
+  module ErrorCodes
+    # Something unexpected happened. This indicates a server-side bug.
+    SERVER_ERROR = 0x0000
+
+    # Some client message triggered a protocol violation (for instance a QUERY
+    # message is sent before a STARTUP one has been sent).
+    PROTOCOL_ERROR = 0x000A
+
+    # CREDENTIALS request failed because Cassandra did not accept the provided credentials.
+    BAD_CREDENTIALS = 0x0100
+
+    # Unavailable exception.
+    #
+    # Details:
+    #
+    # * `:cl` - The consistency level of the query having triggered the exception.
+    # * `:required` - An int representing the number of nodes that should be alive to respect `:cl`.
+    # * `:alive` - An int representing the number of replica that were known to be
+    #   alive when the request has been processed (since an unavailable
+    #   exception has been triggered, there will be `:alive` < `:required`.
+    UNAVAILABLE = 0x1000
+
+    # The request cannot be processed because the coordinator node is overloaded.
+    OVERLOADED = 0x1001
+
+    # The request was a read request but the coordinator node is bootstrapping.
+    IS_BOOTSTRAPPING = 0x1002
+
+    # Error during a truncation error.
+    TRUNCATE_ERROR = 0x1003
+
+    # Timeout exception during a write request.
+    #
+    # Details:
+    #
+    # * `:cl` - The consistency level of the query having triggered the exception.
+    # * `:received` - An int representing the number of nodes having acknowledged the request.
+    # * `:blockfor` - The number of replica whose acknowledgement is required to achieve `:cl`.
+    # * `:write_type` - A string that describe the type of the write that timeouted. The value of that string can be one of:
+    #   - `"SIMPLE"`: the write was a non-batched non-counter write.
+    #   - `"BATCH"`: the write was a (logged) batch write. If this type is received, it means the batch log
+    #     has been successfully written (otherwise a `"BATCH_LOG"` type would have been send instead).
+    #   - `"UNLOGGED_BATCH"`: the write was an unlogged batch. Not batch log write has been attempted.
+    #   - `"COUNTER"`: the write was a counter write (batched or not).
+    #   - `"BATCH_LOG"`: the timeout occured during the write to the batch log when a (logged) batch write was requested.
+    WRITE_TIMEOUT = 0x1100
+
+    # Timeout exception during a read request.
+    #
+    # Details:
+    #
+    # * `:cl` - The consistency level of the query having triggered the exception
+    # * `:received` -  An int representing the number of nodes having answered the request.
+    # * `:blockfor` -  The number of replica whose response is required to achieve `:cl`.
+    #   Please note that it is possible to have `:received` >= `:blockfor` if
+    #   `:data_present` is false. And also in the (unlikely) case were `:cl` is
+    #   achieved but the coordinator node timeout while waiting for read-repair
+    #   acknowledgement.
+    # * `:data_present` - If `true`, it means the replica that was asked for data has not responded.
+    READ_TIMEOUT = 0x1200
+
+    # The submitted query has a syntax error.
+    SYNTAX_ERROR = 0x2000
+
+    # The logged user doesn't have the right to perform the query.
+    UNAUTHORIZED = 0x2100
+
+    # The query is syntactically correct but invalid.
+    INVALID = 0x2200
+
+    # The query is invalid because of some configuration issue.
+    CONFIG_ERROR = 0x2300
+
+    # The query attempted to create a keyspace or a table that was already existing.
+    #
+    # Details:
+    #
+    # * `:ks` - A string representing either the keyspace that already exists, or the
+    #   keyspace in which the table that already exists is.
+    # * `:table` -  A string representing the name of the table that already exists. If the
+    #   query was attempting to create a keyspace, `:table` will be present but
+    #   will be the empty string.
+    ALREADY_EXISTS = 0x2400
+
+    # Can be thrown while a prepared statement tries to be executed if the
+    # provide prepared statement ID is not known by this host.
+    #
+    # Details:
+    #
+    # * `:id` - The unknown ID.
+    UNPREPARED = 0x2500
+  end
+end

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -26,6 +26,7 @@ module Cql
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
         @promises = Array.new(128) { nil }
+        @free_promises = (0...@promises.size).to_a
         @read_buffer = CqlByteBuffer.new
         @frame_encoder = FrameEncoder.new(protocol_version, @compressor)
         @frame_decoder = FrameDecoder.new(@compressor)
@@ -128,7 +129,7 @@ module Cql
         id = nil
         @lock.lock
         begin
-          if (id = next_stream_id)
+          if (id = @free_promises.pop)
             @promises[id] = promise
           end
         ensure
@@ -195,15 +196,25 @@ module Cql
       def receive_data(data)
         @read_buffer << data
         @current_frame = @frame_decoder.decode_frame(@read_buffer, @current_frame)
+        promise_responses = []
         while @current_frame.complete?
           id = @current_frame.stream_id
+          body = @current_frame.body
           if id == -1
-            notify_event_listeners(@current_frame.body)
+            notify_event_listeners(body)
           else
-            complete_request(id, @current_frame.body)
+            promise_responses << complete_request(id, body)
           end
           @current_frame = @frame_decoder.decode_frame(@read_buffer)
         end
+        unless promise_responses.empty?
+          flush_request_queue
+          promise_responses.each do |(promise, response)|
+            unless promise.timed_out?
+              promise.fulfill(response)
+            end
+          end
+        end
       end
 
       def notify_event_listeners(event_response)
@@ -211,12 +222,11 @@ module Cql
         @lock.lock
         begin
           event_listeners = @event_listeners
-          return if event_listeners.empty?
         ensure
           @lock.unlock
         end
         event_listeners.each do |listener|
-          listener.call(@current_frame.body) rescue nil
+          listener.call(event_response) rescue nil
         end
       end
 
@@ -226,16 +236,14 @@ module Cql
         begin
           promise = @promises[id]
           @promises[id] = nil
+          @free_promises << id
         ensure
           @lock.unlock
         end
         if response.is_a?(Protocol::SetKeyspaceResultResponse)
           @keyspace = response.keyspace
         end
-        flush_request_queue
-        unless promise.timed_out?
-          promise.fulfill(response)
-        end
+        [promise, response]
       end
 
       def flush_request_queue
@@ -253,9 +261,10 @@ module Cql
           frame = nil
           @lock.lock
           begin
-            if @request_queue_out.any? && (id = next_stream_id)
+            if @request_queue_out.any? && (id = @free_promises.pop)
               promise = @request_queue_out.shift
               if promise.timed_out?
+                @free_promises << id
                 next
               else
                 frame = promise.frame
@@ -282,6 +291,7 @@ module Cql
           promises_to_fail.concat(@request_queue_in)
           promises_to_fail.concat(@request_queue_out)
           @promises.fill(nil)
+          @free_promises = (0...@promises.size).to_a
           @request_queue_in.clear
           @request_queue_out.clear
         end
@@ -294,14 +304,6 @@ module Cql
           @closed_promise.fulfill
         end
       end
-
-      def next_stream_id
-        if (stream_id = @promises.index(nil))
-          stream_id
-        else
-          nil
-        end
-      end
     end
   end
 end

data/lib/cql/protocol/responses/detailed_error_response.rb

@@ -13,24 +13,24 @@ module Cql
       def self.decode(code, message, protocol_version, buffer, length, trace_id=nil)
         details = {}
         case code
-        when 0x1000 # unavailable
+        when UNAVAILABLE
           details[:cl] = buffer.read_consistency
           details[:required] = buffer.read_int
           details[:alive] = buffer.read_int
-        when 0x1100 # write_timeout
+        when WRITE_TIMEOUT
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
           details[:blockfor] = buffer.read_int
           details[:write_type] = buffer.read_string
-        when 0x1200 # read_timeout
+        when READ_TIMEOUT
           details[:cl] = buffer.read_consistency
           details[:received] = buffer.read_int
           details[:blockfor] = buffer.read_int
           details[:data_present] = buffer.read_byte != 0
-        when 0x2400 # already_exists
+        when ALREADY_EXISTS
           details[:ks] = buffer.read_string
           details[:table] = buffer.read_string
-        when 0x2500
+        when UNPREPARED
           details[:id] = buffer.read_short_bytes
         end
         new(code, message, details)

data/lib/cql/protocol/responses/error_response.rb

@@ -3,6 +3,8 @@
 module Cql
   module Protocol
     class ErrorResponse < Response
+      include ErrorCodes
+
       attr_reader :code, :message
 
       def initialize(*args)
@@ -13,7 +15,7 @@ module Cql
         code = buffer.read_int
         message = buffer.read_string
         case code
-        when 0x1000, 0x1100, 0x1200, 0x2400, 0x2500
+        when UNAVAILABLE, WRITE_TIMEOUT, READ_TIMEOUT, ALREADY_EXISTS, UNPREPARED
           new_length = length - 4 - 4 - message.bytesize
           DetailedErrorResponse.decode(code, message, protocol_version, buffer, new_length)
         else

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '2.1.0.pre1'.freeze
+  VERSION = '2.1.0.pre2'.freeze
 end

data/spec/cql/client/prepared_statement_spec.rb

@@ -295,6 +295,25 @@ module Cql
           statement.execute(11, 'hello', trace: true).value
           tracing.should be_true
         end
+
+        it 'prepares the statement again when it is lost' do
+          prepare_requests = 0
+          connections.each do |c|
+            c[:num_prepare] = 0
+            c.handle_request do |r, t|
+              if r.is_a?(Protocol::ExecuteRequest) && c[:num_prepare] == 1
+                Protocol::ErrorResponse.new(0x2500, 'Unprepared')
+              else
+                if r == Protocol::PrepareRequest.new(cql)
+                  c[:num_prepare] += 1
+                end
+                handle_request(c, r, t)
+              end
+            end
+          end
+          statement.execute(11, 'hello').value
+          connections.map { |c| c[:num_prepare] }.should include(2)
+        end
       end
 
       describe '#batch' do

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -69,20 +69,40 @@ module Cql
 
       describe '#send_request' do
         before do
-          connection.stub(:write).and_yield(buffer)
+          connection.stub(:write) do |*args, &block|
+            if block
+              block.call(buffer)
+            else
+              buffer.append(*args)
+            end
+          end
           connection.stub(:closed?).and_return(false)
           connection.stub(:connected?).and_return(true)
         end
 
         it 'encodes a request frame and writes to the socket handler' do
           protocol_handler.send_request(request)
-          buffer.to_s.should == [1, 0, 0, 5, 0].pack('C4N')
+          version, flags, stream_id, opcode, size, body = *buffer.to_s.unpack('C4Na*')
+          version.should eq(1)
+          flags.should eq(0)
+          stream_id.should be_between(0, 127)
+          opcode.should eq(5)
+          size.should eq(0)
+          body.should be_empty
         end
 
         it 'encodes a frame with the next available stream ID' do
           protocol_handler.send_request(request)
           protocol_handler.send_request(request)
-          buffer.to_s.should == [1, 0, 0, 5, 0].pack('C4N') + [1, 0, 1, 5, 0].pack('C4N')
+          version1, flags1, stream_id1, opcode1, size1,
+          version2, flags2, stream_id2, opcode2, size2, body2 = *buffer.to_s.unpack('C4NC4Na*')
+          version2.should eq(version1)
+          flags2.should eq(flags1)
+          stream_id2.should be_between(0, 127)
+          stream_id2.should_not eq(stream_id1)
+          opcode2.should eq(opcode1)
+          size2.should eq(size1)
+          body2.should be_empty
         end
 
         it 'returns a future' do
@@ -91,34 +111,40 @@ module Cql
 
         it 'succeeds the future when it receives a response frame with the corresponding stream ID' do
           3.times { protocol_handler.send_request(request) }
+          buffer.discard(buffer.size)
           future = protocol_handler.send_request(request)
-          connection.data_listener.call([0x81, 0, 3, 2, 0].pack('C4N'))
+          stream_id = buffer.to_s.getbyte(2)
+          connection.data_listener.call([0x81, 0, stream_id, 2, 0].pack('C4N'))
           await(0.1) { future.resolved? }
         end
 
         it 'handles multiple response frames in the same data packet' do
           futures = Array.new(4) { protocol_handler.send_request(request) }
-          connection.data_listener.call([0x81, 0, 2, 2, 0].pack('C4N') + [0x81, 0, 3, 2, 0].pack('C4N'))
+          stream_ids = buffer.to_s.unpack('C4NC4NC4NC4N').values_at(2, 7, 12, 17)
+          connection.data_listener.call([0x81, 0, stream_ids[2], 2, 0].pack('C4N') + [0x81, 0, stream_ids[3], 2, 0].pack('C4N'))
           await(0.1) { futures[2].resolved? && futures[3].resolved? }
         end
 
         it 'queues the request when there are too many in flight, sending it as soon as a stream is available' do
-          connection.stub(:write)
-          futures = Array.new(130) { protocol_handler.send_request(request) }
-          128.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
-          futures[127].should be_resolved
-          futures[128].should_not be_resolved
-          2.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
-          futures[128].should be_resolved
+          futures = Array.new(128) { protocol_handler.send_request(request) }
+          buffer.discard(buffer.size)
+          delayed = Array.new(2) { protocol_handler.send_request(request) }
+          futures.size.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
+          futures.each { |future| future.should be_resolved }
+          delayed.each { |future| future.should_not be_resolved }
+          stream_ids = buffer.to_s.unpack('C4NC4N').values_at(2, 7)
+          stream_ids.each { |id| connection.data_listener.call([0x81, 0, id, 2, 0].pack('C4N')) }
+          delayed.each { |future| future.should be_resolved }
         end
 
         it 'flushes the request queue before it resolves the future of the just completed request' do
-          connection.stub(:write)
-          futures = Array.new(130) { protocol_handler.send_request(request) }
-          f = futures[0].map do
+          f = protocol_handler.send_request(request)
+          stream_id = buffer.to_s.getbyte(2)
+          129.times { protocol_handler.send_request(request) }
+          f = f.map do
             connection.should have_received(:write).exactly(129).times
           end
-          connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N'))
+          connection.data_listener.call([0x81, 0, stream_id, 2, 0].pack('C4N'))
           f.value
         end
 
@@ -142,7 +168,13 @@ module Cql
 
           it 'compresses request frames' do
             protocol_handler.send_request(request)
-            buffer.to_s.should == [1, 1, 0, 9, 18].pack('C4N') + 'FAKECOMPRESSEDBODY'
+            version, flags, stream_id, opcode, size, body = *buffer.to_s.unpack('C4Na*')
+            version.should eq(1)
+            flags.should eq(1)
+            stream_id.should be_between(0, 127)
+            opcode.should eq(9)
+            size.should eq(18)
+            body.should eq('FAKECOMPRESSEDBODY')
           end
 
           it 'compresses queued request frames' do
@@ -155,8 +187,10 @@ module Cql
             compressor.stub(:decompress).with('FAKECOMPRESSEDBODY').and_return("\x00\x00\x00\x04" + "\x00\x10" + id + "\x00\x00\x00\x01\x00\x00\x00\x01\x00\ncql_rb_911\x00\x05users\x00\tuser_name\x00\r")
             f1 = protocol_handler.send_request(request)
             f2 = protocol_handler.send_request(request)
-            connection.data_listener.call("\x81\x01\x00\x08\x00\x00\x00\x12FAKECOMPRESSEDBODY")
-            connection.data_listener.call("\x81\x01\x01\x08\x00\x00\x00\x12FAKECOMPRESSEDBODY")
+            stream_ids = buffer.to_s.unpack('C4Na18C4N').values_at(2, 8)
+            stream_ids.each do |id|
+              connection.data_listener.call([0x81, 1, id, 8, 18, 'FAKECOMPRESSEDBODY'].pack('C4Na*'))
+            end
             f1.value.should == Protocol::PreparedResultResponse.new(id, [["cql_rb_911", "users", "user_name", :varchar]], nil, nil)
             f2.value.should == Protocol::PreparedResultResponse.new(id, [["cql_rb_911", "users", "user_name", :varchar]], nil, nil)
           end
@@ -189,7 +223,8 @@ module Cql
           it 'fails all requests with ConnectionClosedError if there is no specific error' do
             protocol_handler.send_request(request)
             future = protocol_handler.send_request(request)
-            connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N'))
+            stream_id = buffer.to_s.getbyte(2)
+            connection.data_listener.call([0x81, 0, stream_id, 2, 0].pack('C4N'))
             connection.closed_listener.call(nil)
             begin
               future.value
@@ -234,8 +269,9 @@ module Cql
 
           it 'does not attempt to fulfill the promise when the request has already timed out' do
             f = protocol_handler.send_request(request, 3)
+            stream_id = buffer.to_s.getbyte(2)
             timer_promise.fulfill
-            expect { connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N')) }.to_not raise_error
+            expect { connection.data_listener.call([0x81, 0, stream_id, 2, 0].pack('C4N')) }.to_not raise_error
           end
 
           it 'never sends a request when it has already timed out' do
@@ -300,7 +336,7 @@ module Cql
         before do
           connection.stub(:closed?).and_return(false)
           connection.stub(:connected?).and_return(true)
-          connection.stub(:write)
+          connection.stub(:write).and_yield(buffer)
         end
 
         it 'is not in a keyspace initially' do
@@ -309,7 +345,8 @@ module Cql
 
         it 'registers the keyspace it has changed to' do
           f = protocol_handler.send_request(Protocol::QueryRequest.new('USE hello', nil, nil, :one))
-          connection.data_listener.call([0x81, 0, 0, 8, 4 + 2 + 5, 3, 5].pack('C4N2n') + 'hello')
+          stream_id = buffer.to_s.getbyte(2)
+          connection.data_listener.call([0x81, 0, stream_id, 8, 4 + 2 + 5, 3, 5].pack('C4N2n') + 'hello')
           f.value
           protocol_handler.keyspace.should == 'hello'
         end

data/spec/integration/client_spec.rb

@@ -112,6 +112,13 @@ describe 'A CQL client' do
       counters = result.each_with_object({}) { |row, acc| acc[row['id']] = row['count'] }
       counters.should eql('foo' => 11, 'bar' => 3)
     end
+
+    it 'handles altered tables' do
+      result1 = statement.execute('sue')
+      client.execute('ALTER TABLE users ADD password VARCHAR')
+      result2 = statement.execute('sue')
+      result2.to_a.should eql(result1.to_a)
+    end
   end
 
   context 'with multiple connections' do
@@ -512,7 +519,7 @@ describe 'A CQL client' do
     end
 
     it 'fails gracefully when connecting to something that does not run C*' do
-      expect { Cql::Client.connect(host: 'google.com') }.to raise_error(Cql::Io::ConnectionTimeoutError)
+      expect { Cql::Client.connect(host: 'yahoo.com') }.to raise_error(Cql::Io::ConnectionTimeoutError)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 2.1.0.pre1
+  version: 2.1.0.pre2
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-26 00:00:00.000000000 Z
+date: 2016-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0.pre3
+        version: 1.3.0.pre2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0.pre3
+        version: 1.3.0.pre2
 description: A pure Ruby CQL3 driver for Cassandra
 email:
 - theo@iconara.net
@@ -54,6 +54,7 @@ files:
 - lib/cql/compression.rb
 - lib/cql/compression/lz4_compressor.rb
 - lib/cql/compression/snappy_compressor.rb
+- lib/cql/error_codes.rb
 - lib/cql/protocol.rb
 - lib/cql/protocol/cql_byte_buffer.rb
 - lib/cql/protocol/cql_protocol_handler.rb