cql-rb 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de475cb52182f982ae799799efa2666839c515eb
-  data.tar.gz: 6d736d939d31b342a732c7e47708b39329cce374
+  metadata.gz: e88f9a36365441fa61492560764b32e62d390c77
+  data.tar.gz: 19a2ea3a083d33044364d7bed38fe7ba6edb8d28
 SHA512:
-  metadata.gz: 087c4fb13f332dd30744a2b7e11a180a23043383b637221895723a9e5cbc9ccf12e56d7fbe30ec95f09d54ce5092338670b46bf1130b815c864b672c13f6b37b
-  data.tar.gz: 066cb8bb0af5e671443acc12b68b0c6975fcd22da11ec4236299f19ea34d41558bae878f64ebddcb7b1801075df3cfa0b1815de15a728614ed11d3b3313ec49a
+  metadata.gz: bae2fb550cae96e4c2451f33a9637094365e351649555b95a09a683454ead2a49cb4d7f3f48b1082848b2647083de3743e3aa6874dc56e34ddddcdd78d7b7c9e
+  data.tar.gz: c81ce3639c98d94b6f294ff6e10316251f45b720f533af245f34b745d29f5b4905a34725fd8b378e2aea3ecfc763c011d3cdb38a9c727f52bc5a727f4104e131

data/lib/cql/client/batch.rb

@@ -35,7 +35,7 @@ module Cql
       #
       # Execute the batch and return the result.
       #
-      # @param options [Hash] an options hash or a symbol (as a shortcut for
+      # @param [Hash] options an options hash or a symbol (as a shortcut for
       #   specifying the consistency), see {Cql::Client::Client#execute} for
       #   full details about how this value is interpreted.
       # @raise [Cql::QueryError] raised when there is an error on the server side
@@ -86,33 +86,35 @@ module Cql
 
       def execute(options=nil)
         options = @execute_options_decoder.decode_options(@options, options)
-        connection = nil
-        attempts = 0
-        begin
-          connection = @connection_manager.random_connection
-          request = Protocol::BatchRequest.new(BATCH_TYPES[@type], options[:consistency], options[:trace])
-          @parts.each do |cql_or_statement, *bound_args|
-            if cql_or_statement.is_a?(String)
-              type_hints = nil
-              if bound_args.last.is_a?(Hash) && bound_args.last.include?(:type_hints)
-                bound_args = bound_args.dup
-                type_hints = bound_args.pop[:type_hints]
-              end
-              request.add_query(cql_or_statement, bound_args, type_hints)
+        connection = @connection_manager.random_connection
+        request = Protocol::BatchRequest.new(BATCH_TYPES[@type], options[:consistency], options[:trace])
+        unprepared_statements = nil
+        @parts.each do |part, *bound_args|
+          if part.is_a?(String) || part.prepared?(connection)
+            add_part(connection, request, part, bound_args)
+          else
+            unprepared_statements ||= []
+            unprepared_statements << [part, bound_args]
+          end
+        end
+        @parts = []
+        if unprepared_statements.nil?
+          @request_runner.execute(connection, request, options[:timeout])
+        else
+          fs = unprepared_statements.map do |statement, _|
+            if statement.respond_to?(:async)
+              statement.async.prepare(connection)
             else
-              cql_or_statement.add_to_batch(request, connection, bound_args)
+              statement.prepare(connection)
             end
           end
-        rescue NotPreparedError
-          attempts += 1
-          if attempts < 3
-            retry
-          else
-            raise
+          Future.all(*fs).flat_map do
+            unprepared_statements.each do |statement, bound_args|
+              add_part(connection, request, statement, bound_args)
+            end
+            @request_runner.execute(connection, request, options[:timeout])
           end
         end
-        @parts = []
-        @request_runner.execute(connection, request, options[:timeout])
       end
 
       private
@@ -122,6 +124,19 @@ module Cql
         :unlogged => Protocol::BatchRequest::UNLOGGED_TYPE,
         :counter => Protocol::BatchRequest::COUNTER_TYPE,
       }.freeze
+
+      def add_part(connection, request, part, bound_args)
+        if part.is_a?(String)
+          type_hints = nil
+          if bound_args.last.is_a?(Hash) && bound_args.last.include?(:type_hints)
+            bound_args = bound_args.dup
+            type_hints = bound_args.pop[:type_hints]
+          end
+          request.add_query(part, bound_args, type_hints)
+        else
+          part.add_to_batch(request, connection, bound_args)
+        end
+      end
     end
 
     # @private

data/lib/cql/client/prepared_statement.rb

@@ -196,6 +196,11 @@ module Cql
         f.map(self)
       end
 
+      # @private
+      def prepared?(connection)
+        !!connection[self]
+      end
+
       # @private
       def add_to_batch(batch, connection, bound_args)
         statement_id = connection[self]
@@ -263,6 +268,11 @@ module Cql
         @async_statement
       end
 
+      # @private
+      def prepared?(connection)
+        @async_statement.prepared?(connection)
+      end
+
       # @private
       def add_to_batch(batch, connection, bound_arguments)
         @async_statement.add_to_batch(batch, connection, bound_arguments)

data/lib/cql/protocol/cql_byte_buffer.rb

@@ -29,7 +29,7 @@ module Cql
       def read_decimal(len=bytesize)
         size = read_signed_int
         number_string = read_varint(len - 4).to_s
-        if number_string.length < size
+        if number_string.length <= size
           if number_string.start_with?(MINUS)
             number_string = number_string[1, number_string.length - 1]
             fraction_string = MINUS + ZERO << DECIMAL_POINT
@@ -251,15 +251,10 @@ module Cql
       def append_varint(n)
         num = n
         bytes = []
-        if num == 0
-          bytes << 0
-        else
-          until num == 0
-            bytes << (num & 0xff)
-            num = num >> 8
-            break if num == -1
-          end
-        end
+        begin
+          bytes << (num & 0xff)
+          num >>= 8
+        end until (num == 0 || num == -1) && (bytes.last[7] == num[7])
         append(bytes.reverse.pack(Formats::BYTES_FORMAT))
       end
 

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '2.0.2'.freeze
+  VERSION = '2.0.3'.freeze
 end

data/spec/cql/client/batch_spec.rb

@@ -64,6 +64,10 @@ module Cql
           end
         end
 
+        before do
+          prepared_statement.stub(:prepared?).and_return(true)
+        end
+
         it 'creates a BATCH request and executes it on a random connection' do
           batch.execute.value
           connection.should have_received(:send_request).with(an_instance_of(Protocol::BatchRequest), nil)
@@ -104,22 +108,36 @@ module Cql
           encoded_frame.to_s.should include(Protocol::QueryRequest.encode_values(Protocol::CqlByteBuffer.new, [3], [:int]))
         end
 
-        it 'tries again when a prepared statement raises NotPreparedError' do
-          connection1 = double(:connection1)
-          connection2 = double(:connection2)
-          connection2.stub(:send_request).and_return(Cql::Future.resolved(Protocol::VoidResultResponse.new(nil)))
-          connection_manager.stub(:random_connection).and_return(connection1, connection2)
-          prepared_statement.stub(:add_to_batch).with(anything, connection1, anything).and_raise(NotPreparedError)
-          prepared_statement.stub(:add_to_batch).with(anything, connection2, anything)
-          batch.add(prepared_statement, 3, 'foo')
-          expect { batch.execute.value }.to_not raise_error
-        end
+        context 'when the statement has not been prepared on the selected connection' do
+          let :connection do
+            double(:connection)
+          end
 
-        it 'gives up when the prepared statement has raised NotPreparedError three times' do
-          prepared_statement.stub(:add_to_batch).with(anything, connection, anything).and_raise(NotPreparedError)
-          batch.add(prepared_statement, 3, 'foo')
-          expect { batch.execute.value }.to raise_error(NotPreparedError)
-          prepared_statement.should have_received(:add_to_batch).exactly(3).times
+          before do
+            connection.stub(:send_request).and_return(Cql::Future.resolved(Protocol::VoidResultResponse.new(nil)))
+            connection_manager.stub(:random_connection).and_return(connection)
+            prepared_statement.stub(:prepared?).with(connection).and_return(false)
+            prepared_statement.stub(:add_to_batch)
+            prepared_statement.stub(:prepare) do |c|
+              c.should equal(connection), 'expected #prepare to be called with the connection returned by the connection manager'
+              prepared_statement.stub(:prepared?).with(connection).and_return(true)
+              Future.resolved(prepared_statement)
+            end
+          end
+
+          it 'prepares the statement before sending the request' do
+            batch.add(prepared_statement, 3, 'foo')
+            batch.execute.value.should be_a(VoidResult)
+          end
+
+          it 'supports synchronous prepared statements' do
+            synchronous_prepared_statement = double(:synchronous_prepared_statement)
+            synchronous_prepared_statement.stub(:async).and_return(prepared_statement)
+            synchronous_prepared_statement.stub(:prepared?) { |c| prepared_statement.prepared?(c) }
+            synchronous_prepared_statement.stub(:add_to_batch) { |*args| prepared_statement.add_to_batch(*args) }
+            batch.add(synchronous_prepared_statement, 3, 'foo')
+            batch.execute.value.should be_a(VoidResult)
+          end
         end
 
         it 'returns a future that resolves to the response' do

data/spec/cql/protocol/cql_byte_buffer_spec.rb

@@ -81,6 +81,11 @@ module Cql
           buffer.read_decimal.should == BigDecimal.new('-0.0012095473475870063')
         end
 
+        it 'decodes a small negative decimal' do
+          buffer = described_class.new("\x00\x00\x00\x12\x91z\xE1\xAF\x06c\x5A")
+          buffer.read_decimal.should == BigDecimal.new('-0.031108612692221094')
+        end
+
         it 'consumes the bytes' do
           buffer << 'HELLO'
           buffer.read_decimal(buffer.length - 5)
@@ -815,6 +820,16 @@ module Cql
           buffer.should eql_bytes("\x00")
         end
 
+        it 'encodes with zero padding when number is positive and sign bit is on' do
+          buffer.append_varint(128)
+          buffer.should eql_bytes("\x00\x80")
+        end
+
+        it 'encodes without zero padding when number is negative and sign bit is on' do
+          buffer.append_varint(-128)
+          buffer.should eql_bytes("\x80")
+        end
+
         it 'encodes a variable length integer' do
           buffer.append_varint(1231312312331283012830129382342342412123)
           buffer.should eql_bytes("\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a[")
@@ -825,6 +840,11 @@ module Cql
           buffer.should eql_bytes("\xC9v\x8D:\x86")
         end
 
+        it 'encodes a small negative variable length integer' do
+          buffer.append_varint(-39911)
+          buffer.should eql_bytes("\xFFd\x19")
+        end
+
         it 'encodes a negative variable length integer' do
           buffer.append_varint(-1)
           buffer.should eql_bytes("\xff")
@@ -863,6 +883,11 @@ module Cql
           buffer.should eql_bytes("\x00\x00\x00\x01\x01\xD4\xC0")
         end
 
+        it 'encodes a BigDecimal with zero padding when sign bit is on' do
+          buffer.append_decimal(BigDecimal.new('25.0'))
+          buffer.should eql_bytes("\x00\x00\x00\x01\x00\xFA")
+        end
+
         it 'appends to the buffer' do
           buffer << "\x99"
           buffer.append_decimal(BigDecimal.new('1042342234234.123423435647768234'))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-04 00:00:00.000000000 Z
+date: 2014-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione