cql-rb 1.0.0.pre1 → 1.0.0.pre2

data/README.md

@@ -2,6 +2,7 @@
 
 _There has not yet been a stable release of this project._
 
+[![Build Status](https://travis-ci.org/iconara/cql-rb.png?branch=master)](https://travis-ci.org/iconara/cql-rb)
 
 # Requirements
 

data/lib/cql/client.rb

@@ -84,9 +84,6 @@ module Cql
     def start!
       @lock.synchronize do
         return if @started
-        @started = true
-      end
-      begin
         @io_reactor.start
         hosts = @host.split(',')
         start_request = Protocol::StartupRequest.new
@@ -96,11 +93,9 @@ module Cql
           end
         end
         @connection_ids = Future.combine(*connection_futures).get
-        use(@initial_keyspace) if @initial_keyspace
-      rescue
-        @started = false
-        raise
+        @started = true
       end
+      use(@initial_keyspace) if @initial_keyspace
       self
     end
 
@@ -110,7 +105,7 @@ module Cql
     #
     def shutdown!
       @lock.synchronize do
-        return if @shut_down
+        return if @shut_down || !@started
         @shut_down = true
         @started = false
       end
@@ -140,7 +135,7 @@ module Cql
     # @raise [Cql::NotConnectedError] raised when the client is not connected
     #
     def use(keyspace, connection_ids=@connection_ids)
-      raise NotConnectedError unless @started
+      raise NotConnectedError unless connected?
       if check_keyspace_name!(keyspace)
         @lock.synchronize do
           connection_ids = connection_ids.select { |id| @connection_keyspaces[id] != keyspace }
@@ -165,7 +160,8 @@ module Cql
     #   `nil`, but `SELECT` statements return an `Enumerable` of rows
     #   (see {QueryResult}).
     #
-    def execute(cql, consistency=:quorum)
+    def execute(cql, consistency=DEFAULT_CONSISTENCY_LEVEL)
+      raise NotConnectedError unless connected?
       result = execute_request(Protocol::QueryRequest.new(cql, consistency)).value
       ensure_keyspace!
       result
@@ -173,7 +169,8 @@ module Cql
 
     # @private
     def execute_statement(connection_id, statement_id, metadata, values, consistency)
-      execute_request(Protocol::ExecuteRequest.new(statement_id, metadata, values, consistency), connection_id).value
+      raise NotConnectedError unless connected?
+      execute_request(Protocol::ExecuteRequest.new(statement_id, metadata, values, consistency || DEFAULT_CONSISTENCY_LEVEL), connection_id).value
     end
 
     # Returns a prepared statement that can be run over and over again with
@@ -183,12 +180,14 @@ module Cql
     # @return [Cql::PreparedStatement] an object encapsulating the prepared statement
     #
     def prepare(cql)
+      raise NotConnectedError unless connected?
       execute_request(Protocol::PrepareRequest.new(cql)).value
     end
 
     private
 
     KEYSPACE_NAME_PATTERN = /^\w[\w\d_]*$/
+    DEFAULT_CONSISTENCY_LEVEL = :quorum
 
     def check_keyspace_name!(name)
       if name !~ KEYSPACE_NAME_PATTERN
@@ -198,7 +197,6 @@ module Cql
     end
 
     def execute_request(request, connection_id=nil)
-      raise NotConnectedError unless @started
       @io_reactor.queue_request(request, connection_id).map do |response, connection_id|
         interpret_response!(response, connection_id)
       end
@@ -233,6 +231,11 @@ module Cql
 
     public
 
+    # The representation of a prepared statement.
+    #
+    # Prepared statements are parsed once and stored on the server, allowing
+    # you to execute them over and over again but only send values for the bound
+    # parameters.
     #
     class PreparedStatement
       # @return [ResultMetadata]
@@ -245,8 +248,19 @@ module Cql
 
       # Execute the prepared statement with a list of values for the bound parameters.
       #
+      # The number of arguments must equal the number of bound parameters.
+      # To set the consistency level for the request you pass a consistency
+      # level (as a symbol) as the last argument. Needless to say, if you pass
+      # the value for one bound parameter too few, and then a consistency level,
+      # or if you pass too many values, you will get weird errors.
+      #
+      # @param args [Array] the values for the bound parameters, and optionally
+      #   the desired consistency level, as a symbol (defaults to :quorum)
+      #
       def execute(*args)
-        @client.execute_statement(@connection_id, @statement_id, @raw_metadata, args, :quorum)
+        bound_args = args.shift(@raw_metadata.size)
+        consistency_level = args.shift
+        @client.execute_statement(@connection_id, @statement_id, @raw_metadata, bound_args, consistency_level)
       end
     end
 

data/lib/cql/protocol/decoding.rb

@@ -12,7 +12,7 @@ module Cql
       end
 
       def read_varint!(buffer, length=buffer.length, signed=true)
-        raise DecodingError, "Length #{length} specifed but only #{buffer.size} bytes given" if buffer.size < length
+        raise DecodingError, "Length #{length} specifed but only #{buffer.bytesize} bytes given" if buffer.bytesize < length
         bytes = buffer.slice!(0, length)
         n = 0
         bytes.each_byte do |b|
@@ -25,7 +25,7 @@ module Cql
       end
 
       def read_decimal!(buffer, length=buffer.length)
-        raise DecodingError, "Length #{length} specifed but only #{buffer.size} bytes given" if buffer.size < length
+        raise DecodingError, "Length #{length} specifed but only #{buffer.bytesize} bytes given" if buffer.bytesize < length
         size = read_int!(buffer)
         number_bytes = buffer.slice!(0, length - 4)
         number_string = read_varint!(number_bytes).to_s
@@ -34,34 +34,34 @@ module Cql
       end
 
       def read_long!(buffer)
-        raise DecodingError, "Need eight bytes to decode long, only #{buffer.size} bytes given" if buffer.size < 8
+        raise DecodingError, "Need eight bytes to decode long, only #{buffer.bytesize} bytes given" if buffer.bytesize < 8
         top, bottom = buffer.slice!(0, 8).unpack(Formats::TWO_INTS_FORMAT)
         (top << 32) | bottom
       end
 
       def read_double!(buffer)
-        raise DecodingError, "Need eight bytes to decode double, only #{buffer.size} bytes given" if buffer.size < 8
+        raise DecodingError, "Need eight bytes to decode double, only #{buffer.bytesize} bytes given" if buffer.bytesize < 8
         buffer.slice!(0, 8).unpack(Formats::DOUBLE_FORMAT).first
       end
 
       def read_float!(buffer)
-        raise DecodingError, "Need four bytes to decode float, only #{buffer.size} bytes given" if buffer.size < 4
+        raise DecodingError, "Need four bytes to decode float, only #{buffer.bytesize} bytes given" if buffer.bytesize < 4
         buffer.slice!(0, 4).unpack(Formats::FLOAT_FORMAT).first
       end
 
       def read_int!(buffer)
-        raise DecodingError, "Need four bytes to decode an int, only #{buffer.size} bytes given" if buffer.size < 4
+        raise DecodingError, "Need four bytes to decode an int, only #{buffer.bytesize} bytes given" if buffer.bytesize < 4
         buffer.slice!(0, 4).unpack(Formats::INT_FORMAT).first
       end
 
       def read_short!(buffer)
-        raise DecodingError, "Need two bytes to decode a short, only #{buffer.size} bytes given" if buffer.size < 2
+        raise DecodingError, "Need two bytes to decode a short, only #{buffer.bytesize} bytes given" if buffer.bytesize < 2
         buffer.slice!(0, 2).unpack(Formats::SHORT_FORMAT).first
       end
 
       def read_string!(buffer)
         length = read_short!(buffer)
-        raise DecodingError, "String length is #{length}, but only #{buffer.size} bytes given" if buffer.size < length
+        raise DecodingError, "String length is #{length}, but only #{buffer.bytesize} bytes given" if buffer.bytesize < length
         string = buffer.slice!(0, length)
         string.force_encoding(::Encoding::UTF_8)
         string
@@ -69,14 +69,14 @@ module Cql
 
       def read_long_string!(buffer)
         length = read_int!(buffer)
-        raise DecodingError, "String length is #{length}, but only #{buffer.size} bytes given" if buffer.size < length
+        raise DecodingError, "String length is #{length}, but only #{buffer.bytesize} bytes given" if buffer.bytesize < length
         string = buffer.slice!(0, length)
         string.force_encoding(::Encoding::UTF_8)
         string
       end
 
       def read_uuid!(buffer)
-        raise DecodingError, "UUID requires 16 bytes, but only #{buffer.size} bytes given" if buffer.size < 16
+        raise DecodingError, "UUID requires 16 bytes, but only #{buffer.bytesize} bytes given" if buffer.bytesize < 16
         Uuid.new(read_varint!(buffer, 16, false))
       end
 
@@ -90,7 +90,7 @@ module Cql
       def read_bytes!(buffer)
         size = read_int!(buffer)
         return nil if size & 0x80000000 == 0x80000000
-        raise DecodingError, "Byte array length is #{size}, but only #{buffer.size} bytes given" if buffer.size < size
+        raise DecodingError, "Byte array length is #{size}, but only #{buffer.bytesize} bytes given" if buffer.bytesize < size
         bytes = buffer.slice!(0, size)
         bytes.force_encoding(::Encoding::BINARY)
         bytes
@@ -99,7 +99,7 @@ module Cql
       def read_short_bytes!(buffer)
         size = read_short!(buffer)
         return nil if size & 0x8000 == 0x8000
-        raise DecodingError, "Byte array length is #{size}, but only #{buffer.size} bytes given" if buffer.size < size
+        raise DecodingError, "Byte array length is #{size}, but only #{buffer.bytesize} bytes given" if buffer.bytesize < size
         bytes = buffer.slice!(0, size)
         bytes.force_encoding(::Encoding::BINARY)
         bytes
@@ -116,7 +116,7 @@ module Cql
 
       def read_inet!(buffer)
         size = read_byte!(buffer)
-        raise DecodingError, "Inet requires #{size} bytes, but only #{buffer.size} bytes given" if buffer.size < size
+        raise DecodingError, "Inet requires #{size} bytes, but only #{buffer.bytesize} bytes given" if buffer.bytesize < size
         ip_addr = IPAddr.new_ntoh(buffer.slice!(0, size))
         port = read_int!(buffer)
         [ip_addr, port]

data/lib/cql/protocol/encoding.rb

@@ -14,14 +14,16 @@ module Cql
       end
 
       def write_string(buffer, str)
-        buffer << [str.length].pack(Formats::SHORT_FORMAT)
+        buffer << [str.bytesize].pack(Formats::SHORT_FORMAT)
         buffer << str
+        buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 
       def write_long_string(buffer, str)
-        buffer << [str.length].pack(Formats::INT_FORMAT)
+        buffer << [str.bytesize].pack(Formats::INT_FORMAT)
         buffer << str
+        buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 
@@ -39,21 +41,23 @@ module Cql
 
       def write_bytes(buffer, bytes)
         if bytes
-          write_int(buffer, bytes.length)
+          write_int(buffer, bytes.bytesize)
           buffer << bytes
         else
           write_int(buffer, -1)
         end
+        buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 
       def write_short_bytes(buffer, bytes)
         if bytes
-          write_short(buffer, bytes.length)
+          write_short(buffer, bytes.bytesize)
           buffer << bytes
         else
           write_short(buffer, -1)
         end
+        buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 

data/lib/cql/version.rb

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

data/spec/cql/client_spec.rb

@@ -123,6 +123,10 @@ module Cql
         io_reactor.should_not be_running
       end
 
+      it 'does nothing when called before #start!' do
+        client.shutdown!
+      end
+
       it 'accepts multiple calls to #shutdown!' do
         client.start!
         client.shutdown!
@@ -286,6 +290,14 @@ module Cql
     end
 
     describe '#prepare' do
+      let :id do
+        'A' * 32
+      end
+
+      let :metadata do
+        [['stuff', 'things', 'item', :varchar]]
+      end
+
       before do
         client.start!
       end
@@ -302,8 +314,6 @@ module Cql
       end
 
       it 'executes a prepared statement' do
-        id = 'A' * 32
-        metadata = [['stuff', 'things', 'item', :varchar]]
         io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
         statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?')
         statement.execute('foo')
@@ -311,20 +321,23 @@ module Cql
       end
 
       it 'returns a prepared statement that knows the metadata' do
-        id = 'A' * 32
-        metadata = [['stuff', 'things', 'item', :varchar]]
         io_reactor.queue_response(Protocol::PreparedResultResponse.new(id, metadata))
         statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?')
         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))
+        statement = client.prepare('SELECT * FROM stuff.things WHERE item = ?')
+        statement.execute('thing', :local_quorum)
+        last_request.should == Protocol::ExecuteRequest.new(id, metadata, ['thing'], :local_quorum)
+      end
+
       it 'executes a prepared statement using the right connection' do
         client.shutdown!
         io_reactor.stop.get
         io_reactor.start.get
 
-        metadata = [['stuff', 'things', 'item', :varchar]]
-        
         c = described_class.new(connection_options.merge(host: 'h1.example.com,h2.example.com,h3.example.com'))
         c.start!
 

data/spec/cql/io/io_reactor_spec.rb

@@ -142,7 +142,7 @@ module Cql
           io_reactor.start
           io_reactor.add_connection(host, port).get
           io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
-          await { server.received_bytes.size > 0 }
+          await { server.received_bytes.bytesize > 0 }
           server.received_bytes[3, 1].should == "\x01"
         end
 
@@ -150,7 +150,7 @@ module Cql
           io_reactor.queue_request(Cql::Protocol::StartupRequest.new)
           io_reactor.start
           io_reactor.add_connection(host, port).get
-          await { server.received_bytes.size > 0 }
+          await { server.received_bytes.bytesize > 0 }
           server.received_bytes[3, 1].should == "\x01"
         end
 

data/spec/cql/protocol/encoding_spec.rb

@@ -52,6 +52,18 @@ module Cql
           buffer.should == "\x00\x05hello"
         end
 
+        it 'returns a binary string' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_string(buffer, str)
+          buffer.encoding.should == ::Encoding::BINARY
+        end
+
+        it 'encodes a string with multibyte characters' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_string(buffer, str)
+          buffer.should == "\x00\x09I love π"
+        end
+
         it 'encodes an empty string' do
           Encoding.write_string(buffer, '')
           buffer.should == "\x00\x00"
@@ -75,6 +87,18 @@ module Cql
           buffer.should start_with("\x00\x12\x4f\x80hello world hello world hello world hello")
         end
 
+        it 'returns a binary string' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_long_string(buffer, str)
+          buffer.encoding.should == ::Encoding::BINARY
+        end
+
+        it 'encodes a string with multibyte characters' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_long_string(buffer, str)
+          buffer.should == "\x00\x00\x00\x09I love π"
+        end
+
         it 'encodes an empty string' do
           Encoding.write_long_string(buffer, '')
           buffer.should == "\x00\x00\x00\x00"
@@ -120,6 +144,18 @@ module Cql
           buffer.should == "\x00\x04\x00\x03foo\x00\x03bar\x00\x05hello\x00\x05world"
         end
 
+        it 'returns a binary string' do
+          str = %w[I love π].map { |str| str.force_encoding(::Encoding::UTF_8) }
+          Encoding.write_string_list(buffer, str)
+          buffer.encoding.should == ::Encoding::BINARY
+        end
+
+        it 'encodes a string with multibyte characters' do
+          str = %w[I love π].map { |str| str.force_encoding(::Encoding::UTF_8) }
+          Encoding.write_string_list(buffer, str)
+          buffer.should == "\x00\x03\x00\x01I\x00\x04love\x00\x02π"
+        end
+
         it 'encodes an empty string list' do
           Encoding.write_string_list(buffer, [])
           buffer.should == "\x00\x00"
@@ -143,6 +179,18 @@ module Cql
           buffer.should == ("\x00\x00\x07\xd0" << ("\xaa" * 2000))
         end
 
+        it 'returns a binary string' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_bytes(buffer, str)
+          buffer.encoding.should == ::Encoding::BINARY
+        end
+
+        it 'encodes a string with multibyte characters' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_bytes(buffer, str)
+          buffer.should == "\x00\x00\x00\x09I love π"
+        end
+
         it 'encodes nil' do
           Encoding.write_bytes(buffer, nil)
           buffer.should == "\xff\xff\xff\xff"
@@ -166,6 +214,18 @@ module Cql
           buffer.should == "\x00\x03\xaa\xbb\xcc"
         end
 
+        it 'returns a binary string' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_short_bytes(buffer, str)
+          buffer.encoding.should == ::Encoding::BINARY
+        end
+
+        it 'encodes a string with multibyte characters' do
+          str = 'I love π'.force_encoding(::Encoding::UTF_8)
+          Encoding.write_short_bytes(buffer, str)
+          buffer.should == "\x00\x09I love π"
+        end
+
         it 'encodes nil' do
           Encoding.write_short_bytes(buffer, nil)
           buffer.should == "\xff\xff"

data/spec/integration/client_spec.rb

@@ -56,6 +56,8 @@ describe 'A CQL client' do
     statement = client.prepare('SELECT * FROM system.schema_keyspaces WHERE keyspace_name = ?')
     result = statement.execute('system')
     result.should have(1).item
+    result = statement.execute('system', :one)
+    result.should have(1).item
   end
 
   context 'with multiple connections' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre1
+  version: 1.0.0.pre2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-24 00:00:00.000000000 Z
+date: 2013-03-08 00:00:00.000000000 Z
 dependencies: []
 description: A pure Ruby CQL3 driver for Cassandra
 email: