cql-rb 2.0.0.pre0 → 2.0.0.pre1

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

@@ -3,7 +3,7 @@
 module Cql
   module Protocol
     class VoidResultResponse < ResultResponse
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
         new(trace_id)
       end
 

data/lib/cql/protocol/type_converter.rb

@@ -7,9 +7,6 @@ require 'set'
 module Cql
   module Protocol
     class TypeConverter
-      include Decoding
-      include Encoding
-
       def initialize
         @from_bytes_converters = from_bytes_converters
         @to_bytes_converters = to_bytes_converters
@@ -33,7 +30,7 @@ module Cql
         end
       end
 
-      def to_bytes(io, type, value, size_bytes=4)
+      def to_bytes(buffer, type, value, size_bytes=4)
         case type
         when Array
           unless value.nil? || value.is_a?(Enumerable)
@@ -43,27 +40,27 @@ module Cql
           when :list, :set
             _, sub_type = type
             if value
-              raw = ''
-              write_short(raw, value.size)
+              raw = CqlByteBuffer.new
+              raw.append_short(value.size)
               value.each do |element|
                 to_bytes(raw, sub_type, element, 2)
               end
-              write_bytes(io, raw)
+              buffer.append_bytes(raw)
             else
-              nil_to_bytes(io, size_bytes)
+              nil_to_bytes(buffer, size_bytes)
             end
           when :map
             _, key_type, value_type = type
             if value
-              raw = ''
-              write_short(raw, value.size)
+              raw = CqlByteBuffer.new
+              raw.append_short(value.size)
               value.each do |key, value|
                 to_bytes(raw, key_type, key, 2)
                 to_bytes(raw, value_type, value, 2)
               end
-              write_bytes(io, raw)
+              buffer.append_bytes(raw)
             else
-              nil_to_bytes(io, size_bytes)
+              nil_to_bytes(buffer, size_bytes)
             end
           else
             raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
@@ -73,7 +70,7 @@ module Cql
           unless converter
             raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
           end
-          converter.call(io, value, size_bytes)
+          converter.call(buffer, value, size_bytes)
         end
       rescue TypeError => e
         raise TypeError, %("#{value}" cannot be encoded as #{type.to_s.upcase}: #{e.message}), e.backtrace
@@ -128,24 +125,24 @@ module Cql
           size = buffer.read_short
           return nil if size & 0x8000 == 0x8000
         else
-          size = buffer.read_int
+          size = buffer.read_signed_int
           return nil if size & 0x80000000 == 0x80000000
         end
         size
       end
 
       def bytes_to_ascii(buffer, size_bytes)
-        bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
+        bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
         bytes ? bytes.force_encoding(::Encoding::ASCII) : nil
       end
 
       def bytes_to_bigint(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        read_long!(buffer)
+        buffer.read_long
       end
 
       def bytes_to_blob(buffer, size_bytes)
-        bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
+        bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
         bytes ? bytes : nil
       end
 
@@ -157,49 +154,49 @@ module Cql
       def bytes_to_decimal(buffer, size_bytes)
         size = read_size(buffer, size_bytes)
         return nil unless size
-        read_decimal!(buffer, size)
+        buffer.read_decimal(size)
       end
 
       def bytes_to_double(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        read_double!(buffer)
+        buffer.read_double
       end
 
       def bytes_to_float(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        read_float!(buffer)
+        buffer.read_float
       end
 
       def bytes_to_int(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        read_int!(buffer)
+        buffer.read_signed_int
       end
 
       def bytes_to_timestamp(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        timestamp = read_long!(buffer)
+        timestamp = buffer.read_long
         Time.at(timestamp/1000.0)
       end
 
       def bytes_to_varchar(buffer, size_bytes)
-        bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
+        bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
         bytes ? bytes.force_encoding(::Encoding::UTF_8) : nil
       end
 
       def bytes_to_varint(buffer, size_bytes)
         size = read_size(buffer, size_bytes)
         return nil unless size
-        read_varint!(buffer, size)
+        buffer.read_varint(size)
       end
 
       def bytes_to_uuid(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        read_uuid!(buffer)
+        buffer.read_uuid
       end
 
       def bytes_to_timeuuid(buffer, size_bytes)
         return nil unless read_size(buffer, size_bytes)
-        read_uuid!(buffer, TimeUuid)
+        buffer.read_uuid(TimeUuid)
       end
 
       def bytes_to_inet(buffer, size_bytes)
@@ -237,137 +234,137 @@ module Cql
         set
       end
 
-      def ascii_to_bytes(io, value, size_bytes)
+      def ascii_to_bytes(buffer, value, size_bytes)
         v = value && value.encode(::Encoding::ASCII)
         if size_bytes == 4
-          write_bytes(io, v)
+          buffer.append_bytes(v)
         else
-          write_short_bytes(io, v)
+          buffer.append_short_bytes(v)
         end
       end
 
-      def bigint_to_bytes(io, value, size_bytes)
+      def bigint_to_bytes(buffer, value, size_bytes)
         if value
-          size_to_bytes(io, 8, size_bytes)
-          write_long(io, value)
+          size_to_bytes(buffer, 8, size_bytes)
+          buffer.append_long(value)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def blob_to_bytes(io, value, size_bytes)
+      def blob_to_bytes(buffer, value, size_bytes)
         v = value && value.encode(::Encoding::BINARY)
         if size_bytes == 4
-          write_bytes(io, v)
+          buffer.append_bytes(v)
         else
-          write_short_bytes(io, v)
+          buffer.append_short_bytes(v)
         end
       end
 
-      def boolean_to_bytes(io, value, size_bytes)
+      def boolean_to_bytes(buffer, value, size_bytes)
         if !value.nil?
-          size_to_bytes(io, 1, size_bytes)
-          io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
+          size_to_bytes(buffer, 1, size_bytes)
+          buffer.append(value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def decimal_to_bytes(io, value, size_bytes)
-        raw = value && write_decimal('', value)
+      def decimal_to_bytes(buffer, value, size_bytes)
+        raw = value && CqlByteBuffer.new.append_decimal(value)
         if size_bytes == 4
-          write_bytes(io, raw)
+          buffer.append_bytes(raw)
         else
-          write_short_bytes(io, raw)
+          buffer.append_short_bytes(raw)
         end
       end
 
-      def double_to_bytes(io, value, size_bytes)
+      def double_to_bytes(buffer, value, size_bytes)
         if value
-          size_to_bytes(io, 8, size_bytes)
-          write_double(io, value)
+          size_to_bytes(buffer, 8, size_bytes)
+          buffer.append_double(value)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def float_to_bytes(io, value, size_bytes)
+      def float_to_bytes(buffer, value, size_bytes)
         if value
-          size_to_bytes(io, 4, size_bytes)
-          write_float(io, value)
+          size_to_bytes(buffer, 4, size_bytes)
+          buffer.append_float(value)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def inet_to_bytes(io, value, size_bytes)
+      def inet_to_bytes(buffer, value, size_bytes)
         if value
-          size_to_bytes(io, value.ipv6? ? 16 : 4, size_bytes)
-          io << value.hton
+          size_to_bytes(buffer, value.ipv6? ? 16 : 4, size_bytes)
+          buffer.append(value.hton)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def int_to_bytes(io, value, size_bytes)
+      def int_to_bytes(buffer, value, size_bytes)
         if value
-          size_to_bytes(io, 4, size_bytes)
-          write_int(io, value)
+          size_to_bytes(buffer, 4, size_bytes)
+          buffer.append_int(value)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def varchar_to_bytes(io, value, size_bytes)
+      def varchar_to_bytes(buffer, value, size_bytes)
         v = value && value.encode(::Encoding::UTF_8)
         if size_bytes == 4
-          write_bytes(io, v)
+          buffer.append_bytes(v)
         else
-          write_short_bytes(io, v)
+          buffer.append_short_bytes(v)
         end
       end
 
-      def timestamp_to_bytes(io, value, size_bytes)
+      def timestamp_to_bytes(buffer, value, size_bytes)
         if value
           ms = (value.to_f * 1000).to_i
-          size_to_bytes(io, 8, size_bytes)
-          write_long(io, ms)
+          size_to_bytes(buffer, 8, size_bytes)
+          buffer.append_long(ms)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def uuid_to_bytes(io, value, size_bytes)
+      def uuid_to_bytes(buffer, value, size_bytes)
         if value
-          size_to_bytes(io, 16, size_bytes)
-          write_uuid(io, value)
+          size_to_bytes(buffer, 16, size_bytes)
+          buffer.append_uuid(value)
         else
-          nil_to_bytes(io, size_bytes)
+          nil_to_bytes(buffer, size_bytes)
         end
       end
 
-      def varint_to_bytes(io, value, size_bytes)
-        raw = value && write_varint('', value)
+      def varint_to_bytes(buffer, value, size_bytes)
+        raw = value && CqlByteBuffer.new.append_varint(value)
         if size_bytes == 4
-          write_bytes(io, raw)
+          buffer.append_bytes(raw)
         else
-          write_short_bytes(io, raw)
+          buffer.append_short_bytes(raw)
         end
       end
 
-      def size_to_bytes(io, size, size_bytes)
+      def size_to_bytes(buffer, size, size_bytes)
         if size_bytes == 4
-          write_int(io, size)
+          buffer.append_int(size)
         else
-          write_short(io, size)
+          buffer.append_short(size)
         end
       end
 
-      def nil_to_bytes(io, size_bytes)
+      def nil_to_bytes(buffer, size_bytes)
         if size_bytes == 4
-          write_int(io, -1)
+          buffer.append_int(-1)
         else
-          write_short(io, -1)
+          buffer.append_short(-1)
         end
       end
     end

data/lib/cql/time_uuid.rb

@@ -4,6 +4,8 @@ module Cql
   # A variant of UUID which can extract its time component.
   #
   class TimeUuid < Uuid
+    include Comparable
+
     # Returns the time component from this UUID as a Time.
     #
     # @return [Time]
@@ -20,6 +22,10 @@ module Cql
       Time.at(seconds, microseconds).utc
     end
 
+    def <=>(other)
+      self.value <=> other.value
+    end
+
     # A UUID version 1, variant 1 generator. It can generate a sequence of UUIDs
     # with reasonable uniqueness guarantees:
     #

data/lib/cql/uuid.rb

@@ -39,7 +39,7 @@ module Cql
     end
 
     def hash
-      @h = (@n & 0xffffffffffffffff) ^ ((@n >> 64) & 0xffffffffffffffff)
+      @h ||= 0x7fffffffffffffff - ((@n & 0xffffffffffffffff) ^ ((@n >> 64) & 0xffffffffffffffff))
     end
 
     # Returns the numerical representation of this UUID
@@ -49,6 +49,7 @@ module Cql
     def value
       @n
     end
+    alias_method :to_i, :value
 
     # @private
     def eql?(other)

data/lib/cql/version.rb

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

data/spec/cql/client/batch_spec.rb

@@ -78,19 +78,19 @@ module Cql
           batch.add('UPDATE x SET y = 2 WHERE z = ?', 3)
           batch.add(prepared_statement, 3, 'foo')
           batch.execute.value
-          encoded_frame = last_request.write(1, '')
-          encoded_frame.should include('UPDATE x SET y = 1 WHERE z = 2')
-          encoded_frame.should include('UPDATE x SET y = 2 WHERE z = ?')
-          encoded_frame.should include(Protocol::QueryRequest.encode_values('', [3], nil))
-          encoded_frame.should include('XXXXXXXXXXXXXXXX')
-          encoded_frame.should include(Protocol::ExecuteRequest.encode_values('', metadata, [3, 'foo']))
+          encoded_frame = last_request.write(1, Protocol::CqlByteBuffer.new)
+          encoded_frame.to_s.should include('UPDATE x SET y = 1 WHERE z = 2')
+          encoded_frame.to_s.should include('UPDATE x SET y = 2 WHERE z = ?')
+          encoded_frame.to_s.should include(Protocol::QueryRequest.encode_values(Protocol::CqlByteBuffer.new, [3], nil))
+          encoded_frame.to_s.should include('XXXXXXXXXXXXXXXX')
+          encoded_frame.to_s.should include(Protocol::ExecuteRequest.encode_values(Protocol::CqlByteBuffer.new, metadata, [3, 'foo']))
         end
 
         it 'uses the provided type hints' do
           batch.add('UPDATE x SET y = 2 WHERE z = ?', 3, type_hints: [:int])
           batch.execute.value
-          encoded_frame = last_request.write(1, '')
-          encoded_frame.should include(Protocol::QueryRequest.encode_values('', [3], [:int]))
+          encoded_frame = last_request.write(1, Protocol::CqlByteBuffer.new)
+          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

data/spec/cql/client/{asynchronous_client_spec.rb → client_spec.rb}

@@ -1460,5 +1460,167 @@ module Cql
         end
       end
     end
+
+    describe SynchronousClient do
+      let :client do
+        described_class.new(async_client)
+      end
+
+      let :async_client do
+        double(:async_client)
+      end
+
+      let :future do
+        double(:future, value: nil)
+      end
+
+      describe '#connect' do
+        it 'calls #connect on the async client and waits for the result' do
+          async_client.should_receive(:connect).and_return(future)
+          future.should_receive(:value)
+          client.connect
+        end
+
+        it 'returns self' do
+          async_client.stub(:connect).and_return(future)
+          client.connect.should equal(client)
+        end
+      end
+
+      describe '#close' do
+        it 'calls #close on the async client and waits for the result' do
+          async_client.should_receive(:close).and_return(future)
+          future.should_receive(:value)
+          client.close
+        end
+
+        it 'returns self' do
+          async_client.stub(:close).and_return(future)
+          client.close.should equal(client)
+        end
+      end
+
+      describe '#connected?' do
+        it 'delegates to the async client' do
+          async_client.stub(:connected?).and_return(true)
+          client.connected?.should be_true
+          async_client.stub(:connected?).and_return(false)
+          client.connected?.should be_false
+        end
+      end
+
+      describe '#keyspace' do
+        it 'delegates to the async client' do
+          async_client.stub(:keyspace).and_return('foo')
+          client.keyspace.should == 'foo'
+        end
+      end
+
+      describe '#use' do
+        it 'calls #use on the async client and waits for the result' do
+          async_client.should_receive(:use).with('foo').and_return(future)
+          future.should_receive(:value)
+          client.use('foo')
+        end
+      end
+
+      describe '#execute' do
+        it 'calls #execute on the async client and waits for, and returns the result' do
+          result = double(:result)
+          async_client.stub(:execute).with('SELECT * FROM something', :one).and_return(future)
+          future.stub(:value).and_return(result)
+          client.execute('SELECT * FROM something', :one).should equal(result)
+        end
+
+        it 'wraps AsynchronousPagedQueryResult in a synchronous wrapper' do
+          cql = 'SELECT * FROM something'
+          request = double(:request, cql: cql, values: [])
+          async_result = double(:result, paging_state: 'somepagingstate')
+          options = {:page_size => 10}
+          async_client.stub(:execute).and_return(Future.resolved(AsynchronousQueryPagedQueryResult.new(async_client, request, async_result, options)))
+          result1 = client.execute(cql, options)
+          result2 = result1.next_page
+          async_client.should have_received(:execute).with('SELECT * FROM something', page_size: 10, paging_state: 'somepagingstate')
+          result2.should be_a(SynchronousPagedQueryResult)
+        end
+      end
+
+      describe '#prepare' do
+        it 'calls #prepare on the async client, waits for the result and returns a SynchronousFuture' do
+          result = double(:result)
+          metadata = double(:metadata)
+          result_metadata = double(:result_metadata)
+          async_statement = double(:async_statement, metadata: metadata, result_metadata: result_metadata)
+          another_future = double(:another_future)
+          async_client.stub(:prepare).with('SELECT * FROM something').and_return(future)
+          future.stub(:value).and_return(async_statement)
+          statement = client.prepare('SELECT * FROM something')
+          async_statement.should_receive(:execute).and_return(another_future)
+          another_future.stub(:value).and_return(result)
+          statement.execute.should equal(result)
+          statement.metadata.should equal(metadata)
+        end
+      end
+
+      describe '#batch' do
+        let :batch do
+          double(:batch)
+        end
+
+        context 'when called without a block' do
+          it 'delegates to the asynchronous client and wraps the returned object in a synchronous wrapper' do
+            async_client.stub(:batch).with(:unlogged, trace: true).and_return(batch)
+            batch.stub(:execute).and_return(Cql::Future.resolved(VoidResult.new))
+            b = client.batch(:unlogged, trace: true)
+            b.execute.should be_a(VoidResult)
+          end
+        end
+
+        context 'when called with a block' do
+          it 'delegates to the asynchronous client' do
+            async_client.stub(:batch).with(:counter, trace: true).and_yield(batch).and_return(Cql::Future.resolved(VoidResult.new))
+            yielded_batch = nil
+            client.batch(:counter, trace: true) { |b| yielded_batch = b }
+            yielded_batch.should equal(batch)
+          end
+
+          it 'waits for the operation to complete' do
+            async_client.stub(:batch).with(:counter, {}).and_yield(batch).and_return(Cql::Future.resolved(VoidResult.new))
+            result = client.batch(:counter) { |b| }
+            result.should be_a(VoidResult)
+          end
+        end
+      end
+
+      describe '#async' do
+        it 'returns an asynchronous client' do
+          client.async.should equal(async_client)
+        end
+      end
+
+      context 'when exceptions are raised' do
+        it 'replaces the backtrace of the asynchronous call to make it less confusing' do
+          error = CqlError.new('Bork')
+          error.set_backtrace(['Hello', 'World'])
+          future.stub(:value).and_raise(error)
+          async_client.stub(:execute).and_return(future)
+          begin
+            client.execute('SELECT * FROM something')
+          rescue CqlError => e
+            e.backtrace.first.should match(%r{/client.rb:\d+:in `execute'})
+          end
+        end
+
+        it 'does not replace the backtrace of non-CqlError errors' do
+          future.stub(:value).and_raise('Bork')
+          async_client.stub(:execute).and_return(future)
+          begin
+            client.execute('SELECT * FROM something')
+          rescue => e
+            e.backtrace.first.should_not match(%r{/client.rb:\d+:in `execute'})
+          end
+        end
+      end
+    end
   end
 end