cql-rb 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fddc76ac77bf418eab2dfd497c342b5104481a99
-  data.tar.gz: f8b91abc145bf42ff716fb0af17b50d3a24b19cd
+  metadata.gz: e3f3bbe6a70ee126fc4ebcf7a33fcd19812bbc69
+  data.tar.gz: 28c7bf1d6d92bd3ac5fb8e38155a7ea6ee06eef5
 SHA512:
-  metadata.gz: 8af6c7c7acc157843d1f0f0c101a2a42da30e8f0433f7d53f870a1ceadbf233416dfa2254af425a35ecc6a3c8aa2b6a54e4ad82c3cb0b342526d792e9b7ea06d
-  data.tar.gz: 7f3472cda89cccb1674424a7bcef58bd52cdaacfa579eba56c83c6dbf2d826b4fe2ca0707c8b94eff2009e6b6377f514655ba49c8a80286adacb4b691c8c3185
+  metadata.gz: fd921b73960d9bd46289cfe98d3a18239b09df793b1eed9cf87f7d7e211e0d71716aed118ef1a536149722f0939d8466a24aed27b063e8819325e4286262b300
+  data.tar.gz: 95de3b5aaf74d6c7a072ebe054fd4cd73b92b16a6ecb1d02e629d73b675df04e00d8fec3cd8c646ab47c060a08bd4962c6f4df2c4edae0f5efc1909f07050148

data/README.md

@@ -14,9 +14,7 @@ Cassandra 1.2 or later with the native transport protocol turned on and a modern
 
     gem install cql-rb
 
-if you want to use compression you should also install the [snappy gem](http://rubygems.org/gems/snappy):
-
-    gem install snappy
+if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). See below for more information about compression.
 
 # Quick start
 
@@ -270,7 +268,7 @@ Consistency is ignored for `USE`, `TRUNCATE`, `CREATE` and `ALTER` statements, a
 
 The CQL protocol supports frame compression, which can give you a performance boost if your requests or responses are big. To enable it you can pass a compressor object when you connect.
 
-Cassandra currently supports two compression algorithms: Snappy and LZ4. Support for Snappy compression ships with cql-rb, but in order to use it you will have to install the [snappy](http://rubygems.org/gems/snappy) gem separately. Once it's installed you can enable compression like this:
+Cassandra currently supports two compression algorithms: Snappy and LZ4. cql-rb supports both, but in order to use them you will have to install the [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby) gems separately. Once it's installed you can enable compression like this:
 
 ```ruby
 require 'cql/compression/snappy_compressor'
@@ -279,6 +277,17 @@ compressor = Cql::Compression::SnappyCompressor.new
 client = Cql::Client.connect(hosts: %w[localhost], compressor: compressor)
 ```
 
+or
+
+```ruby
+require 'cql/compression/lz4_compressor'
+
+compressor = Cql::Compression::Lz4Compressor.new
+client = Cql::Client.connect(hosts: %w[localhost], compressor: compressor)
+```
+
+Which one should you choose? On paper the LZ4 algorithm is more efficient and the one Cassandra defaults to for SSTable compression. They both achieve roughly the same compression ratio, but LZ4 does it quicker.
+
 ## Logging
 
 You can pass a standard Ruby logger to the client to get some more information about what is going on:

data/lib/cql/client/query_result.rb

@@ -187,10 +187,13 @@ module Cql
 
       def ensure_materialized
         unless @rows
-          @lock.synchronize do
+          @lock.lock
+          begin
             unless @rows
               @rows = @lazy_rows.materialize(@raw_metadata)
             end
+          ensure
+            @lock.unlock
           end
         end
       end

data/lib/cql/compression/lz4_compressor.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+begin
+  require 'lz4-ruby'
+rescue LoadError => e
+  raise LoadError, %[LZ4 support requires the "lz4-ruby" gem: #{e.message}], e.backtrace
+end
+
+module Cql
+  module Compression
+    # A compressor that uses the LZ4 compression library.
+    #
+    # @note This compressor requires the [lz4-ruby](http://rubygems.org/gems/lz4-ruby)
+    #   gem (v0.3.2 or later required).
+    class Lz4Compressor
+      # @return [String]
+      attr_reader :algorithm
+
+      # @param [Integer] min_size (64) Don't compress frames smaller than
+      #   this size (see {#compress?}).
+      def initialize(min_size=64)
+        @algorithm = 'lz4'.freeze
+        @min_size = min_size
+      end
+
+      # @return [true, false] will return false for frames smaller than the
+      #   `min_size` given to the constructor.
+      def compress?(str)
+        str.bytesize > @min_size
+      end
+
+      def compress(str)
+        [str.bytesize, LZ4::Raw.compress(str.to_s).first].pack(BUFFER_FORMAT)
+      end
+
+      def decompress(str)
+        decompressed_size, compressed_data = str.to_s.unpack(BUFFER_FORMAT)
+        LZ4::Raw.decompress(compressed_data, decompressed_size).first
+      end
+
+      private
+
+      BUFFER_FORMAT = 'Na*'.freeze
+    end
+  end
+end

data/lib/cql/protocol/cql_byte_buffer.rb

@@ -251,10 +251,14 @@ module Cql
       def append_varint(n)
         num = n
         bytes = []
-        until num == 0
-          bytes << (num & 0xff)
-          num = num >> 8
-          break if num == -1
+        if num == 0
+          bytes << 0
+        else
+          until num == 0
+            bytes << (num & 0xff)
+            num = num >> 8
+            break if num == -1
+          end
         end
         append(bytes.reverse.pack(Formats::BYTES_FORMAT))
       end

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -58,13 +58,19 @@ module Cql
       # connection has been set up, or to keep statistics specific to the
       # connection this protocol handler wraps.
       def []=(key, value)
-        @lock.synchronize { @data[key] = value }
+        @lock.lock
+        @data[key] = value
+      ensure
+        @lock.unlock
       end
 
       # @see {#[]=}
       # @return the value associated with the key
       def [](key)
-        @lock.synchronize { @data[key] }
+        @lock.lock
+        @data[key]
+      ensure
+        @lock.unlock
       end
 
       # @return [true, false] true if the underlying connection is connected
@@ -94,9 +100,10 @@ module Cql
       #
       # @yieldparam event [Cql::Protocol::EventResponse] an event sent by the server
       def on_event(&listener)
-        @lock.synchronize do
-          @event_listeners += [listener]
-        end
+        @lock.lock
+        @event_listeners += [listener]
+      ensure
+        @lock.unlock
       end
 
       # Serializes and send a request over the underlying connection.
@@ -119,19 +126,25 @@ module Cql
         return Future.failed(NotConnectedError.new) if closed?
         promise = RequestPromise.new(request, @frame_encoder)
         id = nil
-        @lock.synchronize do
+        @lock.lock
+        begin
           if (id = next_stream_id)
             @promises[id] = promise
           end
+        ensure
+          @lock.unlock
         end
         if id
           @connection.write do |buffer|
             @frame_encoder.encode_frame(request, id, buffer)
           end
         else
-          @lock.synchronize do
+          @lock.lock
+          begin
             promise.encode_frame
             @request_queue_in << promise
+          ensure
+            @lock.unlock
           end
         end
         if timeout
@@ -196,9 +209,12 @@ module Cql
 
       def notify_event_listeners(event_response)
         event_listeners = nil
-        @lock.synchronize do
+        @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
@@ -206,10 +222,13 @@ module Cql
       end
 
       def complete_request(id, response)
-        promise = @lock.synchronize do
+        promise = nil
+        @lock.lock
+        begin
           promise = @promises[id]
           @promises[id] = nil
-          promise
+        ensure
+          @lock.unlock
         end
         if response.is_a?(Protocol::SetKeyspaceResultResponse)
           @keyspace = response.keyspace
@@ -220,16 +239,20 @@ module Cql
       end
 
       def flush_request_queue
-        @lock.synchronize do
+        @lock.lock
+        begin
           if @request_queue_out.empty? && !@request_queue_in.empty?
             @request_queue_out = @request_queue_in
             @request_queue_in = []
           end
+        ensure
+          @lock.unlock
         end
         while true
           id = nil
           frame = nil
-          @lock.synchronize do
+          @lock.lock
+          begin
             if @request_queue_out.any? && (id = next_stream_id)
               promise = @request_queue_out.shift
               if promise.timed_out?
@@ -239,6 +262,8 @@ module Cql
                 @promises[id] = promise
               end
             end
+          ensure
+            @lock.unlock
           end
           if id
             @frame_encoder.change_stream_id(id, frame)
@@ -271,10 +296,11 @@ module Cql
       end
 
       def next_stream_id
-        @promises.each_with_index do |task, index|
-          return index if task.nil?
+        if (stream_id = @promises.index(nil))
+          stream_id
+        else
+          nil
         end
-        nil
       end
     end
   end

data/lib/cql/time_uuid.rb

@@ -18,9 +18,9 @@ module Cql
     end
 
     def <=>(other)
-      c = self.time_bits <=> other.time_bits
-      return c unless c == 0
-      (self.value & LOWER_HALF_MASK) <=> (other.value & LOWER_HALF_MASK)
+      c = self.value <=> other.value
+      return c if c == 0
+      self.time_bits <=> other.time_bits
     end
 
     protected

data/lib/cql/version.rb

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

data/spec/cql/compression/compression_common.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 
-shared_examples 'compressor' do |algorithm|
+shared_examples 'compressor' do |algorithm, compressed_string|
   describe '#algorithm' do
     it %(returns "#{algorithm}") do
       described_class.new.algorithm.should == algorithm
@@ -36,8 +36,20 @@ shared_examples 'compressor' do |algorithm|
       compressed.bytesize.should be < input.bytesize
     end
 
+    it 'compresses byte buffers' do
+      input = Cql::Protocol::CqlByteBuffer.new('hello' * 100)
+      compressed = compressor.compress(input)
+      compressed.should == compressor.compress(input.to_s)
+    end
+
     it 'decompresses compressed strings' do
-      input = "\x19\x10helloN\x05\x00"
+      input = compressed_string
+      decompressed = compressor.decompress(input)
+      decompressed.should == 'hellohellohellohellohello'
+    end
+
+    it 'decompresses byte buffers' do
+      input = Cql::Protocol::CqlByteBuffer.new(compressed_string)
       decompressed = compressor.decompress(input)
       decompressed.should == 'hellohellohellohellohello'
     end

data/spec/cql/compression/lz4_compressor_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'cql/compression/compression_common'
+
+
+module Cql
+  module Compression
+    begin
+      require 'cql/compression/lz4_compressor'
+
+      describe Lz4Compressor do
+        include_examples 'compressor', 'lz4', "\x00\x00\x01\xF4[hello\x05\x00Phello"
+      end
+    rescue LoadError => e
+      describe 'Lz4Compressor' do
+        it 'supports LZ4' do
+          pending e.message
+        end
+      end
+    end
+  end
+end

data/spec/cql/compression/snappy_compressor_spec.rb

@@ -10,7 +10,7 @@ module Cql
       require 'cql/compression/snappy_compressor'
     
       describe SnappyCompressor do
-        include_examples 'compressor', 'snappy'
+        include_examples 'compressor', 'snappy', "\x19\x10helloN\x05\x00"
       end
     rescue LoadError => e
       describe 'SnappyCompressor' do

data/spec/cql/protocol/cql_byte_buffer_spec.rb

@@ -810,6 +810,11 @@ module Cql
       end
 
       describe '#append_varint' do
+        it 'encodes zero' do
+          buffer.append_varint(0)
+          buffer.should eql_bytes("\x00")
+        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[")
@@ -843,6 +848,11 @@ module Cql
           buffer.should eql_bytes("\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA")
         end
 
+        it 'encodes a 0.0 BigDecimal' do
+          buffer.append_decimal(BigDecimal.new('0.0'))
+          buffer.should eql_bytes("\x00\x00\x00\x01\x00")
+        end
+
         it 'appends to the buffer' do
           buffer << "\x99"
           buffer.append_decimal(BigDecimal.new('1042342234234.123423435647768234'))

data/spec/cql/time_uuid_spec.rb

@@ -32,6 +32,12 @@ module Cql
       it 'sorts by the time component' do
         uuids.shuffle.sort.should == uuids
       end
+
+      it 'allows comparison of UUID and TimeUUID' do
+        x = generator.next
+        y = Uuid.new(x.value)
+        x.should == y
+      end
     end
   end
 

data/spec/integration/client_spec.rb

@@ -252,29 +252,45 @@ describe 'A CQL client' do
     end
   end
 
-  context 'with compression' do
-    begin
-      require 'cql/compression/snappy_compressor'
+  shared_examples 'with_compressor' do |compressor_impl|
+    let :client do
+      Cql::Client.connect(connection_options.merge(compressor: compressor))
+    end
 
-      let :client do
-        Cql::Client.connect(connection_options.merge(compressor: compressor))
-      end
+    let :compressor do
+      compressor_impl.new(0)
+    end
 
-      let :compressor do
-        Cql::Compression::SnappyCompressor.new(0)
-      end
+    it 'compresses requests and decompresses responses' do
+      compressor.stub(:compress).and_call_original
+      compressor.stub(:decompress).and_call_original
+      client.execute('SELECT * FROM system.schema_keyspaces')
+      compressor.should have_received(:compress).at_least(1).times
+      compressor.should have_received(:decompress).at_least(1).times
+    end
+  end
 
-      it 'compresses requests and decompresses responses' do
-        compressor.stub(:compress).and_call_original
-        compressor.stub(:decompress).and_call_original
-        client.execute('SELECT * FROM system.schema_keyspaces')
-        compressor.should have_received(:compress).at_least(1).times
-        compressor.should have_received(:decompress).at_least(1).times
-      end
+  shared_examples 'no_compressor' do
+    it 'compresses requests and decompresses responses' do
+      pending 'No compressor available for the current platform'
+    end
+  end
+
+  context 'with Snappy compression' do
+    begin
+      require 'cql/compression/snappy_compressor'
+      include_examples 'with_compressor', Cql::Compression::SnappyCompressor
     rescue LoadError
-      it 'compresses requests and decompresses responses' do
-        pending 'No compressor available for the current platform'
-      end
+      include_examples 'no_compressor'
+    end
+  end
+
+  context 'with LZ4 compression' do
+    begin
+      require 'cql/compression/lz4_compressor'
+      include_examples 'with_compressor', Cql::Compression::Lz4Compressor
+    rescue LoadError
+      include_examples 'no_compressor'
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-23 00:00:00.000000000 Z
+date: 2014-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
@@ -52,6 +52,7 @@ files:
 - lib/cql/client/result_metadata.rb
 - lib/cql/client/void_result.rb
 - lib/cql/compression.rb
+- lib/cql/compression/lz4_compressor.rb
 - lib/cql/compression/snappy_compressor.rb
 - lib/cql/protocol.rb
 - lib/cql/protocol/cql_byte_buffer.rb
@@ -105,6 +106,7 @@ files:
 - spec/cql/client/request_runner_spec.rb
 - spec/cql/client/void_result_spec.rb
 - spec/cql/compression/compression_common.rb
+- spec/cql/compression/lz4_compressor_spec.rb
 - spec/cql/compression/snappy_compressor_spec.rb
 - spec/cql/protocol/cql_byte_buffer_spec.rb
 - spec/cql/protocol/cql_protocol_handler_spec.rb
@@ -187,6 +189,7 @@ test_files:
 - spec/cql/client/request_runner_spec.rb
 - spec/cql/client/void_result_spec.rb
 - spec/cql/compression/compression_common.rb
+- spec/cql/compression/lz4_compressor_spec.rb
 - spec/cql/compression/snappy_compressor_spec.rb
 - spec/cql/protocol/cql_byte_buffer_spec.rb
 - spec/cql/protocol/cql_protocol_handler_spec.rb