cql-rb 1.0.6 → 1.1.0.pre0

data/lib/cql/time_uuid.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+
+module Cql
+  # A variant of UUID which can extract its time component.
+  #
+  class TimeUuid < Uuid
+    # Returns the time component from this UUID as a Time.
+    #
+    # @return [Time]
+    #
+    def to_time
+      n = (value >> 64)
+      t = 0
+      t |= (n & 0x0000000000000fff) << 48
+      t |= (n & 0x00000000ffff0000) << 16
+      t |= (n & 0xffffffff00000000) >> 32
+      t -= GREGORIAN_OFFSET
+      seconds = t/10_000_000
+      microseconds = (t - seconds * 10_000_000)/10.0
+      Time.at(seconds, microseconds).utc
+    end
+
+    # A UUID version 1, variant 1 generator. It can generate a sequence of UUIDs
+    # with reasonable uniqueness guarantees:
+    #
+    # * The clock ID and node ID components are set to random numbers when the
+    #   generator is created.
+    # * If two calls to {#next} happen within the time afforded by the system
+    #   clock resolution a counter is incremented and added to the time
+    #   component.
+    # * If the clock moves backwards the clock ID is reset to a new random
+    #   number.
+    #
+    # Instances of this class are absolutely not threadsafe. You should
+    # never share instances between threads.
+    #
+    class Generator
+      # Create a new UUID generator.
+      #
+      # @param [Integer] node_id an alternate node ID (defaults to a random number)
+      # @param [Integer] clock_id an alternate clock ID (defaults to a random number)
+      #
+      def initialize(node_id=nil, clock_id=nil, clock=Time)
+        @node_id = node_id || (rand(2**47) | 0x010000000000)
+        @clock_id = clock_id || rand(2**16)
+        @clock = clock
+      end
+
+      # Returns a new UUID with a time component that is the current time.
+      #
+      # @return [Cql::TimeUuid] a new UUID
+      #
+      def next
+        now = @clock.now
+        usecs = now.to_i * 1_000_000 + now.usec
+        if @last_usecs && @last_usecs - @sequence <= usecs && usecs <= @last_usecs
+          @sequence += 1
+        elsif @last_usecs && @last_usecs > usecs
+          @sequence = 0
+          @clock_id = rand(2**16)
+        else
+          @sequence = 0
+        end
+        @last_usecs = usecs + @sequence
+        from_usecs(@last_usecs)
+      end
+
+      # Returns a new UUID with a time component based on the specified Time.
+      # A piece of jitter is added to ensure that multiple calls with the same
+      # time do not generate the same UUID (if you want determinism you can set
+      # the second parameter to zero).
+      #
+      # @param [Time] time the time to encode into the UUID
+      # @param [Integer] jitter a number of microseconds to add to the time to make it unique
+      # @return [Cql::TimeUuid] a new UUID
+      #
+      def from_time(time, jitter=rand(2**16))
+        usecs = time.to_i * 1_000_000 + time.usec + jitter
+        from_usecs(usecs)
+      end
+
+      # @private
+      def from_usecs(usecs)
+        t = GREGORIAN_OFFSET + usecs * 10
+        time_hi  = t & 0x0fff000000000000
+        time_mid = t & 0x0000ffff00000000
+        time_low = t & 0x00000000ffffffff
+        version = 1
+        clock_id = @clock_id & 0x3fff
+        node_id = @node_id & 0xffffffffffff
+        variant = 0x8000
+        n = (time_low << 96) | (time_mid << 48) | (time_hi << 16)
+        n |= version << 76
+        n |= (clock_id | variant) << 48
+        n |= node_id
+        TimeUuid.new(n)
+      end
+    end
+
+    private
+
+    GREGORIAN_OFFSET = 122192928000000000
+  end
+end

data/lib/cql/uuid.rb

@@ -6,6 +6,8 @@ module Cql
   # This is a very basic implementation of UUIDs and exists more or less just
   # to encode and decode UUIDs from and to Cassandra.
   #
+  # If you want to generate UUIDs see {Cql::TimeUuid::Generator}.
+  #
   class Uuid
     # Creates a new UUID either from a string (expected to be on the standard
     # 8-4-4-4-12 form, or just 32 characters without hyphens), or from a
@@ -50,7 +52,7 @@ module Cql
 
     # @private
     def eql?(other)
-      other.kind_of?(Uuid) && self.value == other.value
+      self.value == other.value
     end
     alias_method :==, :eql?
 
@@ -69,4 +71,4 @@ module Cql
       n
     end
   end
-end
+end

data/lib/cql/version.rb

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

data/spec/cql/client/asynchronous_client_spec.rb

@@ -39,10 +39,15 @@ module Cql
           client.connect.get.should equal(client)
         end
 
-        it 'forwards the host and port' do
+        it 'connects to the right host and port' do
           client.connect.get
-          connection[:host].should == 'example.com'
-          connection[:port].should == 12321
+          last_connection.host.should == 'example.com'
+          last_connection.port.should == 12321
+        end
+
+        it 'connects with the default connection timeout' do
+          client.connect.get
+          last_connection.timeout.should == 10
         end
 
         it 'sends a startup request' do
@@ -58,7 +63,7 @@ module Cql
           c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
           c.connect.get
           connections.each do |cc|
-            cc[:requests].last.should be_a(Protocol::StartupRequest)
+            cc.requests.last.should be_a(Protocol::StartupRequest)
           end
         end
 
@@ -80,12 +85,12 @@ module Cql
         end
 
         it 're-raises any errors raised' do
-          io_reactor.stub(:add_connection).and_raise(ArgumentError)
+          io_reactor.stub(:connect).and_raise(ArgumentError)
           expect { client.connect.get }.to raise_error(ArgumentError)
         end
 
         it 'is not connected if an error is raised' do
-          io_reactor.stub(:add_connection).and_raise(ArgumentError)
+          io_reactor.stub(:connect).and_raise(ArgumentError)
           client.connect.get rescue nil
           client.should_not be_connected
           io_reactor.should_not be_running
@@ -97,18 +102,18 @@ module Cql
         end
 
         it 'is not connected while connecting' do
-          pending 'the fake reactor needs to be made asynchronous' do
-            io_reactor.stop.get
-            f = client.connect
-            client.should_not be_connected
-            io_reactor.start.get
-            f.get
-          end
+          io_reactor.stop.get
+          f = client.connect
+          client.should_not be_connected
+          io_reactor.start.get
+          f.get
         end
 
         context 'when the server requests authentication' do
           before do
-            io_reactor.queue_response(Protocol::AuthenticateResponse.new('com.example.Auth'))
+            io_reactor.on_connection do |connection|
+              connection.queue_response(Protocol::AuthenticateResponse.new('com.example.Auth'))
+            end
           end
 
           it 'sends credentials' do
@@ -123,13 +128,17 @@ module Cql
           end
 
           it 'raises an error when the server responds with an error to the credentials request' do
-            io_reactor.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
+            io_reactor.on_connection do |connection|
+              connection.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
+            end
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
             expect { client.connect.get }.to raise_error(AuthenticationError)
           end
 
           it 'shuts down the client when there is an authentication error' do
-            io_reactor.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
+            io_reactor.on_connection do |connection|
+              connection.queue_response(Protocol::ErrorResponse.new(256, 'No way, José'))
+            end
             client = described_class.new(connection_options.merge(credentials: {'username' => 'foo', 'password' => 'bar'}))
             client.connect.get rescue nil
             client.should_not be_connected
@@ -171,7 +180,9 @@ module Cql
         end
 
         it 'executes a USE query' do
-          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          io_reactor.on_connection do |connection|
+            connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          end
           client.use('system').get
           last_request.should == Protocol::QueryRequest.new('USE system', :one)
         end
@@ -185,7 +196,7 @@ module Cql
           c.connect.get
 
           c.use('system').get
-          last_requests = connections.select { |c| c[:host] =~ /^h\d\.example\.com$/ }.sort_by { |c| c[:host] }.map { |c| c[:requests].last }
+          last_requests = connections.select { |c| c.host =~ /^h\d\.example\.com$/ }.sort_by(&:host).map { |c| c.requests.last }
           last_requests.should == [
             Protocol::QueryRequest.new('USE system', :one),
             Protocol::QueryRequest.new('USE system', :one),
@@ -194,7 +205,7 @@ module Cql
         end
 
         it 'knows which keyspace it changed to' do
-          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+          last_connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
           client.use('system').get
           client.keyspace.should == 'system'
         end
@@ -202,13 +213,6 @@ module Cql
         it 'raises an error if the keyspace name is not valid' do
           expect { client.use('system; DROP KEYSPACE system').get }.to raise_error(InvalidKeyspaceNameError)
         end
-
-        it 'allows the keyspace name to be quoted' do
-          io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
-          client.connect.get
-          client.use('"system"').get
-          client.keyspace.should == "system"
-        end
       end
 
       describe '#execute' do
@@ -228,7 +232,7 @@ module Cql
 
         context 'with a void CQL query' do
           it 'returns nil' do
-            io_reactor.queue_response(Protocol::VoidResultResponse.new)
+            last_connection.queue_response(Protocol::VoidResultResponse.new)
             result = client.execute('UPDATE stuff SET thing = 1 WHERE id = 3').get
             result.should be_nil
           end
@@ -236,13 +240,13 @@ module Cql
 
         context 'with a USE query' do
           it 'returns nil' do
-            io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            last_connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
             result = client.execute('USE system').get
             result.should be_nil
           end
 
           it 'knows which keyspace it changed to' do
-            io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            last_connection.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
             client.execute('USE system').get
             client.keyspace.should == 'system'
           end
@@ -255,14 +259,14 @@ module Cql
             c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
             c.connect.get
 
-            io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h1.example.com' }[:host])
-            io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h2.example.com' }[:host])
-            io_reactor.queue_response(Protocol::SetKeyspaceResultResponse.new('system'), connections.find { |c| c[:host] == 'h3.example.com' }[:host])
+            connections.find { |c| c.host == 'h1.example.com' }.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            connections.find { |c| c.host == 'h2.example.com' }.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
+            connections.find { |c| c.host == 'h3.example.com' }.queue_response(Protocol::SetKeyspaceResultResponse.new('system'))
 
             c.execute('USE system', :one).get
             c.keyspace.should == 'system'
 
-            last_requests = connections.select { |c| c[:host] =~ /^h\d\.example\.com$/ }.sort_by { |c| c[:host] }.map { |c| c[:requests].last }
+            last_requests = connections.select { |c| c.host =~ /^h\d\.example\.com$/ }.sort_by(&:host).map { |c| c.requests.last }
             last_requests.should == [
               Protocol::QueryRequest.new('USE system', :one),
               Protocol::QueryRequest.new('USE system', :one),
@@ -281,7 +285,7 @@ module Cql
           end
 
           let :result do
-            io_reactor.queue_response(Protocol::RowsResultResponse.new(rows, metadata))
+            last_connection.queue_response(Protocol::RowsResultResponse.new(rows, metadata))
             client.execute('SELECT * FROM things').get
           end
 
@@ -324,12 +328,12 @@ module Cql
 
         context 'when the response is an error' do
           it 'raises an error' do
-            io_reactor.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
+            last_connection.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
             expect { client.execute('SELECT * FROM things').get }.to raise_error(QueryError, 'Blurgh')
           end
 
           it 'decorates the error with the CQL that caused it' do
-            io_reactor.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
+            last_connection.queue_response(Protocol::ErrorResponse.new(0xabcd, 'Blurgh'))
             begin
               client.execute('SELECT * FROM things').get
             rescue QueryError => e
@@ -360,59 +364,31 @@ module Cql
         end
 
         it 'returns a prepared statement' do
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, [['stuff', 'things', 'item', :varchar]]))
+          last_connection.queue_response(Protocol::PreparedResultResponse.new('A' * 32, [['stuff', 'things', 'item', :varchar]]))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.should_not be_nil
         end
 
         it 'executes a prepared statement' do
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
+          last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.execute('foo').get
           last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['foo'], :quorum)
         end
 
         it 'returns a prepared statement that knows the metadata' do
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
+          last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.metadata['item'].type == :varchar
         end
 
         it 'executes a prepared statement with a specific consistency level' do
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
+          last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
           statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
           statement.execute('thing', :local_quorum).get
           last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['thing'], :local_quorum)
         end
 
-        it 'executes a prepared statement using the right connection' do
-          client.close.get
-          io_reactor.stop.get
-          io_reactor.start.get
-
-          c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
-          c.connect.get
-
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, metadata))
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new('B' * 32, metadata))
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new('C' * 32, metadata))
-
-          statement1 = c.prepare('SELECT * FROM stuff.things WHERE item = ?').get
-          statement1_connection = io_reactor.last_used_connection
-          statement2 = c.prepare('SELECT * FROM stuff.things WHERE item = ?').get
-          statement2_connection = io_reactor.last_used_connection
-          statement3 = c.prepare('SELECT * FROM stuff.things WHERE item = ?').get
-          statement3_connection = io_reactor.last_used_connection
-
-          io_reactor.queue_response(Protocol::RowsResultResponse.new([{'thing' => 'foo1'}], metadata), statement1_connection[:host])
-          io_reactor.queue_response(Protocol::RowsResultResponse.new([{'thing' => 'foo2'}], metadata), statement2_connection[:host])
-          io_reactor.queue_response(Protocol::RowsResultResponse.new([{'thing' => 'foo3'}], metadata), statement3_connection[:host])
-
-          statement1.execute('foo').get.first.should == {'thing' => 'foo1'}
-          statement2.execute('foo').get.first.should == {'thing' => 'foo2'}
-          statement3.execute('foo').get.first.should == {'thing' => 'foo3'}
-        end
-
         context 'when there is an error creating the request' do
           it 'returns a failed future' do
             f = client.prepare(nil)
@@ -422,7 +398,7 @@ module Cql
 
         context 'when there is an error preparing the request' do
           it 'returns a failed future' do
-            io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
+            last_connection.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
             statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?').get
             f = statement.execute
             expect { f.get }.to raise_error(ArgumentError)
@@ -473,7 +449,7 @@ module Cql
 
         it 'complains when #execute of a prepared statement is called after #close' do
           client.connect.get
-          io_reactor.queue_response(Protocol::PreparedResultResponse.new('A' * 32, []))
+          last_connection.queue_response(Protocol::PreparedResultResponse.new('A' * 32, []))
           statement = client.prepare('DELETE FROM stuff WHERE id = 3').get
           client.close.get
           expect { statement.execute.get }.to raise_error(NotConnectedError)
@@ -481,4 +457,4 @@ module Cql
       end
     end
   end
-end
+end

data/spec/cql/client/asynchronous_prepared_statement_spec.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Client
+    describe AsynchronousPreparedStatement do
+      let :statement do
+        described_class.new(connection, statement_id, raw_metadata)
+      end
+
+      let :connection do
+        stub(:connection)
+      end
+
+      let :statement_id do
+        "\x2a"
+      end
+
+      let :raw_metadata do
+        [
+          ['my_keyspace', 'my_table', 'my_column', :int],
+          ['my_keyspace', 'my_table', 'my_other_column', :text],
+        ]
+      end
+
+      let :rows do
+        [
+          {'my_column' => 11, 'my_other_column' => 'hello'},
+          {'my_column' => 22, 'my_other_column' => 'foo'},
+          {'my_column' => 33, 'my_other_column' => 'bar'},
+        ]
+      end
+
+      describe '#metadata' do
+        it 'returns the interpreted metadata' do
+          statement.metadata.should be_a(ResultMetadata)
+          statement.metadata['my_column'].should be_a(ColumnMetadata)
+        end
+      end
+
+      describe '#execute' do
+        it 'creates and sends an EXECUTE request' do
+          expected_request = Cql::Protocol::ExecuteRequest.new(statement_id, raw_metadata, [11, 'hello'], :one)
+          connection.should_receive(:send_request).with(expected_request)
+          statement.execute(11, 'hello', :one)
+        end
+
+        it 'returns a future that resolves to a QueryResult' do
+          request = Cql::Protocol::ExecuteRequest.new(statement_id, raw_metadata, [11, 'hello'], :two)
+          response = Cql::Protocol::RowsResultResponse.new(rows, raw_metadata)
+          connection.stub(:send_request).with(request).and_return(Future.completed(response))
+          result = statement.execute(11, 'hello', :two).get
+          result.metadata['my_other_column'].should == ColumnMetadata.new('my_keyspace', 'my_table', 'my_other_column', :text)
+          result.first.should == {'my_column' => 11, 'my_other_column' => 'hello'}
+        end
+
+        it 'returns a failed future when the number of arguments is wrong' do
+          f1 = statement.execute(11, :one)
+          f2 = statement.execute(11, 'foo', 22, :one)
+          expect { f1.get }.to raise_error
+          expect { f2.get }.to raise_error
+        end
+      end
+    end
+  end
+end