cql-rb 1.0.3 → 1.0.4

data/lib/cql/protocol/decoding.rb

@@ -31,7 +31,20 @@ module Cql
       def read_decimal!(buffer, length=buffer.length)
         size = read_int!(buffer)
         number_string = read_varint!(buffer, length - 4).to_s
-        fraction_string = number_string[0, number_string.length - size] << DECIMAL_POINT << number_string[number_string.length - size, number_string.length]
+        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
+          else
+            fraction_string = ZERO + DECIMAL_POINT
+          end
+          (size - number_string.length).times { fraction_string << ZERO }
+          fraction_string << number_string
+        else
+          fraction_string = number_string[0, number_string.length - size]
+          fraction_string << DECIMAL_POINT
+          fraction_string << number_string[number_string.length - size, number_string.length]
+        end
         BigDecimal.new(fraction_string)
       rescue RangeError => e
         raise DecodingError, e.message, e.backtrace
@@ -171,6 +184,8 @@ module Cql
 
       private
 
+      MINUS = '-'.freeze
+      ZERO = '0'.freeze
       DECIMAL_POINT = '.'.freeze
     end
   end

data/lib/cql/protocol/type_converter.rb

@@ -36,27 +36,35 @@ module Cql
       def to_bytes(io, type, value, size_bytes=4)
         case type
         when Array
-          unless value.is_a?(Enumerable)
+          unless value.nil? || value.is_a?(Enumerable)
             raise InvalidValueError, 'Value for collection must be enumerable'
           end
           case type.first
           when :list, :set
             _, sub_type = type
-            raw = ''
-            write_short(raw, value.size)
-            value.each do |element|
-              to_bytes(raw, sub_type, element, 2)
+            if value
+              raw = ''
+              write_short(raw, value.size)
+              value.each do |element|
+                to_bytes(raw, sub_type, element, 2)
+              end
+              write_bytes(io, raw)
+            else
+              nil_to_bytes(io, size_bytes)
             end
-            write_bytes(io, raw)
           when :map
             _, key_type, value_type = type
-            raw = ''
-            write_short(raw, value.size)
-            value.each do |key, value|
-              to_bytes(raw, key_type, key, 2)
-              to_bytes(raw, value_type, value, 2)
+            if value
+              raw = ''
+              write_short(raw, 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)
+            else
+              nil_to_bytes(io, size_bytes)
             end
-            write_bytes(io, raw)
           else
             raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
           end
@@ -224,7 +232,7 @@ module Cql
       end
 
       def ascii_to_bytes(io, value, size_bytes)
-        v = value.encode(::Encoding::ASCII)
+        v = value && value.encode(::Encoding::ASCII)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -233,16 +241,16 @@ module Cql
       end
 
       def bigint_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 8)
+        if value
+          size_to_bytes(io, 8, size_bytes)
+          write_long(io, value)
         else
-          write_short(io, 8)
+          nil_to_bytes(io, size_bytes)
         end
-        write_long(io, value)
       end
 
       def blob_to_bytes(io, value, size_bytes)
-        v = value.encode(::Encoding::BINARY)
+        v = value && value.encode(::Encoding::BINARY)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -251,16 +259,16 @@ module Cql
       end
 
       def boolean_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 1)
+        if !value.nil?
+          size_to_bytes(io, 1, size_bytes)
+          io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
         else
-          write_short(io, 1)
+          nil_to_bytes(io, size_bytes)
         end
-        io << (value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
       end
 
       def decimal_to_bytes(io, value, size_bytes)
-        raw = write_decimal('', value)
+        raw = value && write_decimal('', value)
         if size_bytes == 4
           write_bytes(io, raw)
         else
@@ -269,43 +277,43 @@ module Cql
       end
 
       def double_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 8)
+        if value
+          size_to_bytes(io, 8, size_bytes)
+          write_double(io, value)
         else
-          write_short(io, 8)
+          nil_to_bytes(io, size_bytes)
         end
-        write_double(io, value)
       end
 
       def float_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 4)
+        if value
+          size_to_bytes(io, 4, size_bytes)
+          write_float(io, value)
         else
-          write_short(io, 4)
+          nil_to_bytes(io, size_bytes)
         end
-        write_float(io, value)
       end
 
       def inet_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, value.ipv6? ? 16 : 4)
+        if value
+          size_to_bytes(io, value.ipv6? ? 16 : 4, size_bytes)
+          io << value.hton
         else
-          write_short(io, value.ipv6? ? 16 : 4)
+          nil_to_bytes(io, size_bytes)
         end
-        io << value.hton
       end
 
       def int_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 4)
+        if value
+          size_to_bytes(io, 4, size_bytes)
+          write_int(io, value)
         else
-          write_short(io, 4)
+          nil_to_bytes(io, size_bytes)
         end
-        write_int(io, value)
       end
 
       def varchar_to_bytes(io, value, size_bytes)
-        v = value.encode(::Encoding::UTF_8)
+        v = value && value.encode(::Encoding::UTF_8)
         if size_bytes == 4
           write_bytes(io, v)
         else
@@ -314,32 +322,48 @@ module Cql
       end
 
       def timestamp_to_bytes(io, value, size_bytes)
-        ms = (value.to_f * 1000).to_i
-        if size_bytes == 4
-          write_int(io, 8)
+        if value
+          ms = (value.to_f * 1000).to_i
+          size_to_bytes(io, 8, size_bytes)
+          write_long(io, ms)
         else
-          write_short(io, 8)
+          nil_to_bytes(io, size_bytes)
         end
-        write_long(io, ms)
       end
 
       def uuid_to_bytes(io, value, size_bytes)
-        if size_bytes == 4
-          write_int(io, 16)
+        if value
+          size_to_bytes(io, 16, size_bytes)
+          write_uuid(io, value)
         else
-          write_short(io, 16)
+          nil_to_bytes(io, size_bytes)
         end
-        write_uuid(io, value)
       end
 
       def varint_to_bytes(io, value, size_bytes)
-        raw = write_varint('', value)
+        raw = value && write_varint('', value)
         if size_bytes == 4
           write_bytes(io, raw)
         else
           write_short_bytes(io, raw)
         end
       end
+
+      def size_to_bytes(io, size, size_bytes)
+        if size_bytes == 4
+          write_int(io, size)
+        else
+          write_short(io, size)
+        end
+      end
+
+      def nil_to_bytes(io, size_bytes)
+        if size_bytes == 4
+          write_int(io, -1)
+        else
+          write_short(io, -1)
+        end
+      end
     end
   end
 end

data/lib/cql/version.rb

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

data/spec/cql/protocol/decoding_spec.rb

@@ -62,6 +62,21 @@ module Cql
           Decoding.read_decimal!(buffer).should == BigDecimal.new('1042342234234.123423435647768234')
         end
 
+        it 'decodes a negative decimal' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x12\xF2\xD8\x02\xB6R\x7F\x99\xEE\x98#\x99\xA9V")
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('-1042342234234.123423435647768234')
+        end
+
+        it 'decodes a positive decimal with only fractions' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x13*\xF8\xC4\xDF\xEB]o")
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('0.0012095473475870063')
+        end
+
+        it 'decodes a negative decimal with only fractions' do
+          buffer = ByteBuffer.new("\x00\x00\x00\x13\xD5\a;\x20\x14\xA2\x91")
+          Decoding.read_decimal!(buffer).should == BigDecimal.new('-0.0012095473475870063')
+        end
+
         it 'consumes the bytes' do
           buffer << 'HELLO'
           Decoding.read_decimal!(buffer, buffer.length - 5)

data/spec/cql/protocol/type_converter_spec.rb

@@ -0,0 +1,52 @@
+# encoding: ascii-8bit
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe TypeConverter do
+      let :converter do
+        described_class.new
+      end
+
+      let :buffer do
+        ''
+      end
+
+      TYPES = [:ascii, :bigint, :blob, :boolean, :decimal, :double, :float, :inet, :int, :text, :varchar, :timestamp, :timeuuid, :uuid, :varint].freeze
+
+      describe '#to_bytes' do
+        context 'when encoding normal value' do
+          TYPES.each do |type|
+            it "encodes a null #{type.upcase}" do
+              converter.to_bytes(buffer, type, nil, 4).should == "\xff\xff\xff\xff"
+            end
+          end
+
+          it 'encodes a null LIST' do
+            converter.to_bytes(buffer, [:list, :int], nil, 4).should == "\xff\xff\xff\xff"
+          end
+
+          it 'encodes a null MAP' do
+            converter.to_bytes(buffer, [:map, :text, :text], nil, 4).should == "\xff\xff\xff\xff"
+
+          end
+
+          it 'encodes a null SET' do
+            converter.to_bytes(buffer, [:set, :uuid], nil, 4).should == "\xff\xff\xff\xff"
+
+          end
+        end
+
+        context 'when encoding collection values' do
+          TYPES.each do |type|
+            it "encodes a null #{type.upcase}" do
+              converter.to_bytes(buffer, type, nil, 2).should == "\xff\xff"
+            end
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-04 00:00:00.000000000 Z
+date: 2013-08-06 00:00:00.000000000 Z
 dependencies: []
 description: A pure Ruby CQL3 driver for Cassandra
 email:
@@ -83,6 +83,7 @@ files:
 - spec/cql/protocol/requests/register_request_spec.rb
 - spec/cql/protocol/requests/startup_request_spec.rb
 - spec/cql/protocol/response_frame_spec.rb
+- spec/cql/protocol/type_converter_spec.rb
 - spec/cql/uuid_spec.rb
 - spec/integration/client_spec.rb
 - spec/integration/protocol_spec.rb
@@ -112,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3215276701075097941
+      hash: 16971366414174556
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -138,6 +139,7 @@ test_files:
 - spec/cql/protocol/requests/register_request_spec.rb
 - spec/cql/protocol/requests/startup_request_spec.rb
 - spec/cql/protocol/response_frame_spec.rb
+- spec/cql/protocol/type_converter_spec.rb
 - spec/cql/uuid_spec.rb
 - spec/integration/client_spec.rb
 - spec/integration/protocol_spec.rb