cql-rb 2.0.5 → 2.1.0.pre0

data/lib/cql/version.rb

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

data/spec/cql/client/client_spec.rb

@@ -361,6 +361,13 @@ module Cql
           last_connection.timeout.should == 10
         end
 
+        it 'enables client/node encryption when the :ssl option is set' do
+          ssl_context = double(:ssl_context)
+          client = described_class.new(connection_options.merge(ssl: ssl_context))
+          client.connect.value
+          last_connection.options.should include(ssl: ssl_context)
+        end
+
         it 'is not in a keyspace' do
           client.connect.value
           client.keyspace.should be_nil

data/spec/cql/client/connector_spec.rb

@@ -204,7 +204,11 @@ module Cql
 
     describe ConnectStep do
       let :step do
-        described_class.new(io_reactor, protocol_handler_factory, 1111, 9, logger)
+        described_class.new(io_reactor, protocol_handler_factory, 1111, connection_options, logger)
+      end
+
+      let :connection_options do
+        {:timeout => 8}
       end
 
       let :pending_connection do
@@ -246,7 +250,7 @@ module Cql
 
         it 'connects using the connection details given' do
           step.run(pending_connection)
-          io_reactor.should have_received(:connect).with('example.com', 1111, 9)
+          io_reactor.should have_received(:connect).with('example.com', 1111, connection_options)
         end
 
         it 'appends the connection to the given argument and returns the result' do

data/spec/cql/client/peer_discovery_spec.rb

@@ -13,9 +13,9 @@ module Cql
       describe '#new_hosts' do
         let :seed_connections do
           [
-            FakeConnection.new('host0', 9042, 5, {:data_center => 'dc0', :host_id => Uuid.new('00000000-0000-0000-0000-000000000000')}),
-            FakeConnection.new('host1', 9042, 5, {:data_center => 'dc0', :host_id => Uuid.new('11111111-1111-1111-1111-111111111111')}),
-            FakeConnection.new('host2', 9042, 5, {:data_center => 'dc0', :host_id => Uuid.new('22222222-2222-2222-2222-222222222222')}),
+            FakeConnection.new('host0', 9042, {}, {:data_center => 'dc0', :host_id => Uuid.new('00000000-0000-0000-0000-000000000000')}),
+            FakeConnection.new('host1', 9042, {}, {:data_center => 'dc0', :host_id => Uuid.new('11111111-1111-1111-1111-111111111111')}),
+            FakeConnection.new('host2', 9042, {}, {:data_center => 'dc0', :host_id => Uuid.new('22222222-2222-2222-2222-222222222222')}),
           ]
         end
 

data/spec/cql/client/prepared_statement_spec.rb

@@ -55,9 +55,9 @@ module Cql
 
       let :connections do
         [
-          FakeConnection.new('h0.example.com', 1234, 42),
-          FakeConnection.new('h1.example.com', 1234, 42),
-          FakeConnection.new('h2.example.com', 1234, 42),
+          FakeConnection.new('h0.example.com', 1234),
+          FakeConnection.new('h1.example.com', 1234),
+          FakeConnection.new('h2.example.com', 1234),
         ]
       end
 
@@ -242,7 +242,7 @@ module Cql
 
         context 'when it receives a new connection from the connection manager' do
           let :new_connection do
-            FakeConnection.new('h3.example.com', 1234, 5)
+            FakeConnection.new('h3.example.com', 1234)
           end
 
           before do
@@ -295,25 +295,6 @@ module Cql
           statement.execute(11, 'hello', trace: true).value
           tracing.should be_true
         end
-
-        it 'prepares the statement again when it is lost' do
-          prepare_requests = 0
-          connections.each do |c|
-            c[:num_prepare] = 0
-            c.handle_request do |r, t|
-              if r.is_a?(Protocol::ExecuteRequest) && c[:num_prepare] == 1
-                Protocol::ErrorResponse.new(0x2500, 'Unprepared')
-              else
-                if r == Protocol::PrepareRequest.new(cql)
-                  c[:num_prepare] += 1
-                end
-                handle_request(c, r, t)
-              end
-            end
-          end
-          statement.execute(11, 'hello').value
-          connections.map { |c| c[:num_prepare] }.should include(2)
-        end
       end
 
       describe '#batch' do

data/spec/cql/protocol/cql_protocol_handler_spec.rb

@@ -112,16 +112,6 @@ module Cql
           futures[128].should be_resolved
         end
 
-        it 'flushes the request queue before it resolves the future of the just completed request' do
-          connection.stub(:write)
-          futures = Array.new(130) { protocol_handler.send_request(request) }
-          f = futures[0].map do
-            connection.should have_received(:write).exactly(129).times
-          end
-          connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N'))
-          f.value
-        end
-
         context 'when a compressor is specified' do
           let :protocol_handler do
             described_class.new(connection, scheduler, 1, compressor)
@@ -258,27 +248,6 @@ module Cql
             128.times { |i| connection.data_listener.call([0x81, 0, i, 2, 0].pack('C4N')) }
             write_count.should == 128
           end
-
-          it 'does not stop sending queued requests even when one has timed out' do
-            write_count = 0
-            connection.stub(:write) do |s, &h|
-              write_count += 1
-              if h
-                h.call(buffer)
-              else
-                buffer << s
-              end
-            end
-            128.times do
-              protocol_handler.send_request(request)
-            end
-            scheduler.stub(:schedule_timer).with(5).and_return(timer_promise.future)
-            f1 = protocol_handler.send_request(request, 5)
-            f2 = protocol_handler.send_request(request)
-            timer_promise.fulfill
-            connection.data_listener.call([0x81, 0, 0, 2, 0].pack('C4N'))
-            write_count.should == 129
-          end
         end
       end
 

data/spec/cql/protocol/custom_type_parser_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  module Protocol
+    describe CustomTypeParser do
+      let :parser do
+        described_class.new
+      end
+
+      describe '#type' do
+        it 'maps internal type names to protocol type names' do
+          type = parser.parse_type('org.apache.cassandra.db.marshal.DecimalType')
+          type.should == :decimal
+          type = parser.parse_type('org.apache.cassandra.db.marshal.LongType')
+          type.should == :bigint
+        end
+
+        it 'returns custom types as-is' do
+          type = parser.parse_type('com.acme.Foo')
+          type.should == [:custom, 'com.acme.Foo']
+        end
+
+        it 'parses flat user defined types' do
+          type = parser.parse_type('org.apache.cassandra.db.marshal.UserType(some_keyspace,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a6970:org.apache.cassandra.db.marshal.Int32Type)')
+          type.should == [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]
+        end
+
+        it 'parses nested user defined types' do
+          type = parser.parse_type('org.apache.cassandra.db.marshal.UserType(some_keyspace,636f6d70616e79,6e616d65:org.apache.cassandra.db.marshal.UTF8Type,616464726573736573:org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UserType(cql_rb_client_spec,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a6970:org.apache.cassandra.db.marshal.Int32Type)))')
+          type.should == [:udt, {'name' => :text, 'addresses' => [:list, [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]]}]
+        end
+
+        it 'parses nested user defined types where the inner UDT is a map key' do
+          type = parser.parse_type('org.apache.cassandra.db.marshal.UserType(some_keyspace,636f6d70616e79,6e616d65:org.apache.cassandra.db.marshal.UTF8Type,616464726573736573:org.apache.cassandra.db.marshal.MapType(org.apache.cassandra.db.marshal.UserType(cql_rb_client_spec,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a6970:org.apache.cassandra.db.marshal.Int32Type),org.apache.cassandra.db.marshal.Int32Type))')
+          type.should == [:udt, {'name' => :text, 'addresses' => [:map, [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}], :int]}]
+        end
+      end
+    end
+  end
+end

data/spec/cql/protocol/requests/execute_request_spec.rb

@@ -3,6 +3,17 @@
 require 'spec_helper'
 
 
+module ExecuteRequestSpec
+  module ItEncodes
+    def it_encodes(description, type, value, expected_bytes)
+      it("encodes #{description}") do
+        bytes = encode_value(type, value)
+        bytes.should eql_bytes(expected_bytes)
+      end
+    end
+  end
+end
+
 module Cql
   module Protocol
     describe ExecuteRequest do
@@ -64,6 +75,13 @@ module Cql
       end
 
       describe '#write' do
+        def encode_value(type, value)
+          request = described_class.new(id, [['ks', 'tbl', 'col', type]], [value], true, :one, nil, nil, nil, false)
+          buffer = request.write(1, CqlByteBuffer.new)
+          buffer.discard(2 + 16 + 2)
+          buffer.read(buffer.read_int)
+        end
+
         context 'when the protocol version is 1' do
           let :frame_bytes do
             ExecuteRequest.new(id, column_metadata, ['hello', 42, 'foo'], true, :each_quorum, nil, nil, nil, false).write(1, CqlByteBuffer.new)
@@ -141,44 +159,150 @@ module Cql
           end
         end
 
-        context 'with different data types' do
-          specs = [
-            [:ascii, 'test', "test"],
-            [:bigint, 1012312312414123, "\x00\x03\x98\xB1S\xC8\x7F\xAB"],
-            [:blob, "\xab\xcd", "\xab\xcd"],
-            [:boolean, false, "\x00"],
-            [:boolean, true, "\x01"],
-            [:decimal, BigDecimal.new('1042342234234.123423435647768234'), "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"],
-            [:double, 10000.123123123, "@\xC3\x88\x0F\xC2\x7F\x9DU"],
-            [:float, 12.13, "AB\x14{"],
-            [:inet, IPAddr.new('8.8.8.8'), "\x08\x08\x08\x08"],
-            [:inet, IPAddr.new('::1'), "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"],
-            [:int, 12348098, "\x00\xBCj\xC2"],
-            [:text, 'FOOBAR', 'FOOBAR'],
-            [:timestamp, Time.at(1358013521.123), "\x00\x00\x01</\xE9\xDC\xE3"],
-            [:timeuuid, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711'), "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"],
-            [:uuid, Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), "\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6"],
-            [:varchar, 'hello', 'hello'],
-            [:varint, 1231312312331283012830129382342342412123, "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["],
-            [:varint, -234234234234, "\xC9v\x8D:\x86"],
-            [[:list, :timestamp], [Time.at(1358013521.123)], "\x00\x01" + "\x00\x08\x00\x00\x01</\xE9\xDC\xE3"],
-            [[:list, :boolean], [true, false, true, true], "\x00\x04" + "\x00\x01\x01" + "\x00\x01\x00"  + "\x00\x01\x01" + "\x00\x01\x01"],
-            [[:map, :uuid, :int], {Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6') => 45345, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711') => 98765}, "\x00\x02" + "\x00\x10\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6" + "\x00\x04\x00\x00\xb1\x21" + "\x00\x10\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11" + "\x00\x04\x00\x01\x81\xcd"],
-            [[:map, :ascii, :blob], {'hello' => 'world', 'one' => "\x01", 'two' => "\x02"}, "\x00\x03" + "\x00\x05hello" + "\x00\x05world" + "\x00\x03one" + "\x00\x01\x01" + "\x00\x03two" + "\x00\x01\x02"],
-            [[:set, :int], Set.new([13, 3453, 456456, 123, 768678]), "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"],
-            [[:set, :varchar], Set.new(['foo', 'bar', 'baz']), "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"],
-            [[:set, :int], [13, 3453, 456456, 123, 768678], "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"],
-            [[:set, :varchar], ['foo', 'bar', 'baz'], "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"]
-          ]
-          specs.each do |type, value, expected_bytes|
-            it "encodes #{type} values" do
-              metadata = [['ks', 'tbl', 'id_column', type]]
-              buffer = ExecuteRequest.new(id, metadata, [value], true, :one, nil, nil, nil, false).write(1, CqlByteBuffer.new)
-              buffer.discard(2 + 16 + 2)
-              length = buffer.read_int
-              result_bytes = buffer.read(length)
-              result_bytes.should eql_bytes(expected_bytes)
+        context 'with scalar types' do
+          extend ExecuteRequestSpec::ItEncodes
+
+          it_encodes 'ASCII strings', :ascii, 'test', "test"
+          it_encodes 'BIGINTs', :bigint, 1012312312414123, "\x00\x03\x98\xB1S\xC8\x7F\xAB"
+          it_encodes 'BLOBs', :blob, "\xab\xcd", "\xab\xcd"
+          it_encodes 'false BOOLEANs', :boolean, false, "\x00"
+          it_encodes 'true BOOLEANs', :boolean, true, "\x01"
+          it_encodes 'DECIMALs', :decimal, BigDecimal.new('1042342234234.123423435647768234'), "\x00\x00\x00\x12\r'\xFDI\xAD\x80f\x11g\xDCfV\xAA"
+          it_encodes 'DOUBLEs', :double, 10000.123123123, "@\xC3\x88\x0F\xC2\x7F\x9DU"
+          it_encodes 'FLOATs', :float, 12.13, "AB\x14{"
+          it_encodes 'IPv4 INETs', :inet, IPAddr.new('8.8.8.8'), "\x08\x08\x08\x08"
+          it_encodes 'IPv6 INETs', :inet, IPAddr.new('::1'), "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01"
+          it_encodes 'INTs', :int, 12348098, "\x00\xBCj\xC2"
+          it_encodes 'TEXTs from UTF-8 strings', :text, 'ümlaut'.force_encoding(::Encoding::UTF_8), "\xc3\xbcmlaut"
+          it_encodes 'TIMESTAMPs from Times', :timestamp, Time.at(1358013521.123), "\x00\x00\x01</\xE9\xDC\xE3"
+          it_encodes 'TIMESTAMPs from floats', :timestamp, 1358013521.123, "\x00\x00\x01</\xE9\xDC\xE3"
+          it_encodes 'TIMESTAMPs from integers', :timestamp, 1358013521, "\x00\x00\x01</\xE9\xDCh"
+          it_encodes 'TIMEUUIDs', :timeuuid, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711'), "\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11"
+          it_encodes 'UUIDs', :uuid, Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6'), "\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6"
+          it_encodes 'VARCHAR from UTF-8 strings', :varchar, 'hello'.force_encoding(::Encoding::UTF_8), 'hello'
+          it_encodes 'positive VARINTs', :varint, 1231312312331283012830129382342342412123, "\x03\x9EV \x15\f\x03\x9DK\x18\xCDI\\$?\a["
+          it_encodes 'negative VARINTs', :varint, -234234234234, "\xC9v\x8D:\x86"
+        end
+
+        context 'with collection types' do
+          extend ExecuteRequestSpec::ItEncodes
+
+          it_encodes 'LIST<TIMESTAMP>', [:list, :timestamp], [Time.at(1358013521.123)], "\x00\x01" + "\x00\x08\x00\x00\x01</\xE9\xDC\xE3"
+          it_encodes 'LIST<BOOLEAN>', [:list, :boolean], [true, false, true, true], "\x00\x04" + "\x00\x01\x01" + "\x00\x01\x00"  + "\x00\x01\x01" + "\x00\x01\x01"
+          it_encodes 'MAP<UUID,INT>', [:map, :uuid, :int], {Uuid.new('cfd66ccc-d857-4e90-b1e5-df98a3d40cd6') => 45345, Uuid.new('a4a70900-24e1-11df-8924-001ff3591711') => 98765}, "\x00\x02" + "\x00\x10\xCF\xD6l\xCC\xD8WN\x90\xB1\xE5\xDF\x98\xA3\xD4\f\xD6" + "\x00\x04\x00\x00\xb1\x21" + "\x00\x10\xA4\xA7\t\x00$\xE1\x11\xDF\x89$\x00\x1F\xF3Y\x17\x11" + "\x00\x04\x00\x01\x81\xcd"
+          it_encodes 'MAP<ASCII,BLOB>', [:map, :ascii, :blob], {'hello' => 'world', 'one' => "\x01", 'two' => "\x02"}, "\x00\x03" + "\x00\x05hello" + "\x00\x05world" + "\x00\x03one" + "\x00\x01\x01" + "\x00\x03two" + "\x00\x01\x02"
+          it_encodes 'SET<INT> from Sets', [:set, :int], Set.new([13, 3453, 456456, 123, 768678]), "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"
+          it_encodes 'SET<INT> from arrays', [:set, :int], [13, 3453, 456456, 123, 768678], "\x00\x05" + "\x00\x04\x00\x00\x00\x0d" + "\x00\x04\x00\x00\x0d\x7d" + "\x00\x04\x00\x06\xf7\x08" + "\x00\x04\x00\x00\x00\x7b" + "\x00\x04\x00\x0b\xba\xa6"
+          it_encodes 'SET<VARCHAR> from Sets', [:set, :varchar], Set.new(['foo', 'bar', 'baz']), "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"
+          it_encodes 'SET<VARCHAR> from arrays', [:set, :varchar], ['foo', 'bar', 'baz'], "\x00\x03" + "\x00\x03foo" + "\x00\x03bar" + "\x00\x03baz"
+        end
+
+        context 'with user defined types' do
+          context 'with a flat UDT' do
+            let :type do
+              [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]
+            end
+
+            let :value do
+              {'street' => '123 Some St.', 'city' => 'Frans Sanisco', 'zip' => 76543}
+            end
+
+            it 'encodes a hash into bytes' do
+              bytes = encode_value(type, value)
+              bytes.should eql_bytes(
+                "\x00\x00\x00\f123 Some St." +
+                "\x00\x00\x00\rFrans Sanisco" +
+                "\x00\x00\x00\x04\x00\x01*\xFF"
+              )
+            end
+          end
+
+          context 'with a UDT as a MAP value' do
+            let :type do
+              [:map, :varchar, [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]]
             end
+
+            let :value do
+              {'secret_lair' => {'street' => '4 Some Other St.', 'city' => 'Gos Latos', 'zip' => 87654}}
+            end
+
+            it 'encodes a hash into bytes' do
+              bytes = encode_value(type, value)
+              bytes.should eql_bytes(
+                "\x00\x01" +
+                "\x00\vsecret_lair" +
+                "\x00)" +
+                "\x00\x00\x00\x104 Some Other St." +
+                "\x00\x00\x00\tGos Latos" +
+                "\x00\x00\x00\x04\x00\x01Vf"
+              )
+            end
+          end
+
+          context 'with nested UDTs' do
+            let :type do
+              [:set, [:udt, {'name' => :text, 'addresses' => [:list, [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]]}]]
+            end
+
+            let :value do
+              Set.new([
+                {
+                  'name' => 'Acme Corp',
+                  'addresses' => [
+                    {'street' => '1 St.', 'city' => '1 City', 'zip' => 11111},
+                    {'street' => '2 St.', 'city' => '2 City', 'zip' => 22222}
+                  ]
+                },
+                {
+                  'name' => 'Foo Inc.',
+                  'addresses' => [
+                    {'street' => '3 St.', 'city' => '3 City', 'zip' => 33333}
+                  ]
+                }
+              ])
+            end
+
+            it 'encodes a hash into bytes' do
+              bytes = encode_value(type, value)
+              bytes.should eql_bytes(
+                "\x00\x02" +
+                "\x00S" +
+                "\x00\x00\x00\tAcme Corp" +
+                "\x00\x00\x00B" +
+                "\x00\x00\x00\x02" +
+                "\x00\x00\x00\e" +
+                "\x00\x00\x00\x051 St." +
+                "\x00\x00\x00\x061 City" +
+                "\x00\x00\x00\x04\x00\x00+g" +
+                "\x00\x00\x00\e" +
+                "\x00\x00\x00\x052 St." +
+                "\x00\x00\x00\x062 City" +
+                "\x00\x00\x00\x04\x00\x00V\xCE" +
+                "\x003" +
+                "\x00\x00\x00\bFoo Inc." +
+                "\x00\x00\x00#" +
+                "\x00\x00\x00\x01" +
+                "\x00\x00\x00\e" +
+                "\x00\x00\x00\x053 St." +
+                "\x00\x00\x00\x063 City" +
+                "\x00\x00\x00\x04\x00\x00\x825"
+              )
+            end
+          end
+        end
+
+        context 'with custom types' do
+          let :type do
+            [:custom, 'com.example.CustomType']
+          end
+
+          let :value do
+            "\x01\x02\x03\x04\x05"
+          end
+
+          it 'encodes a byte string into bytes' do
+            bytes = encode_value(type, value)
+            bytes.should eql_bytes("\x01\x02\x03\x04\x05")
           end
         end
       end

data/spec/cql/protocol/responses/prepared_result_response_spec.rb

@@ -73,6 +73,28 @@ module Cql
             response.result_metadata.should be_nil
           end
         end
+
+        context 'with user defined types' do
+          let :buffer do
+            b = CqlByteBuffer.new
+            b << "\x00\x10\xC8\x90\r\x98\x06t\x97\x96\x94\xDA6\x13\xBB\x9D\xA5\xE1" # statement ID
+            b << "\x00\x00\x00\x00" # flags
+            b << "\x00\x00\x00\x00" # column count
+            b << "\x00\x00\x00\x01" # flags (global_tables_spec)
+            b << "\x00\x00\x00\x03" # column count
+            b << "\x00\x12user_defined_types\x00\x05users" # global_tables_spec
+            b << "\x00\x02id\x00\f" # col_spec (name + type)
+            b << "\x00\taddresses\x00!\x00\r\x00\x00\x01Morg.apache.cassandra.db.marshal.UserType(user_defined_types,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a69705f636f6465:org.apache.cassandra.db.marshal.Int32Type,70686f6e6573:org.apache.cassandra.db.marshal.SetType(org.apache.cassandra.db.marshal.UTF8Type))" # col_spec (name + type + extra type info)
+            b << "\x00\x04name\x00\r"
+          end
+
+          it 'decodes the full type hierarchy' do
+            response = described_class.decode(2, buffer, buffer.length)
+            column_metadata = response.result_metadata[1]
+            type_description = column_metadata[3]
+            type_description.should == [:map, :varchar, [:udt, {'street' => :text, 'city' => :text, 'zip_code' => :int, 'phones' => [:set, :text]}]]
+          end
+        end
       end
 
       describe '#void?' do

data/spec/cql/protocol/responses/rows_result_response_spec.rb

@@ -292,6 +292,193 @@ module Cql
           end
         end
 
+        context 'with custom types' do
+          let :buffer do
+            b = CqlByteBuffer.new
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x02"
+            b << "\x00\x12cql_rb_client_spec"
+            b << "\x00\x05users"
+            b << "\x00\x02id"
+            b << "\x00\r"
+            b << "\x00\x0Fprimary_address"
+            b << "\x00\x00\x00\x16com.example.CustomType"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x03sue"
+            b << "\x00\x00\x00\x05"
+            b << "\x01\x02\x03\x04\x05"
+            b
+          end
+
+          let :response do
+            described_class.decode(2, buffer, buffer.length)
+          end
+
+          it 'decodes the type metadata' do
+            type_description = response.metadata[1]
+            type_description.should == [
+              'cql_rb_client_spec',
+              'users',
+              'primary_address',
+              [:custom, 'com.example.CustomType']
+            ]
+          end
+
+          it 'decodes the column value to a byte string' do
+            custom_value = response.rows[0]['primary_address']
+            custom_value.should == "\x01\x02\x03\x04\x05"
+          end
+        end
+
+        context 'with user defined types' do
+          let :buffer do
+            b = CqlByteBuffer.new
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x02"
+            b << "\x00\x12cql_rb_client_spec"
+            b << "\x00\x05users"
+            b << "\x00\x02id"
+            b << "\x00\r"
+            b << "\x00\x0Fprimary_address"
+            b << "\x00\x00\x00\xE4org.apache.cassandra.db.marshal.UserType(cql_rb_client_spec,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a6970:org.apache.cassandra.db.marshal.Int32Type)"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x03sue"
+            b << "\x00\x00\x00)"
+            b << "\x00\x00\x00\f123 Some St."
+            b << "\x00\x00\x00\rFrans Sanisco"
+            b << "\x00\x00\x00\x04\x00\x01*\xFF"
+            b
+          end
+
+          let :response do
+            described_class.decode(2, buffer, buffer.length)
+          end
+
+          it 'decodes the type metadata' do
+            type_description = response.metadata[1]
+            type_description.should == [
+              'cql_rb_client_spec',
+              'users',
+              'primary_address',
+              [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]
+            ]
+          end
+
+          it 'decodes the column value to a hash' do
+            custom_value = response.rows[0]['primary_address']
+            custom_value.should eql(
+              'street' => '123 Some St.',
+              'city' => 'Frans Sanisco',
+              'zip' => 76543,
+            )
+          end
+        end
+
+        context 'with user defined types inside of collection types' do
+          let :buffer do
+            b = CqlByteBuffer.new
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x12cql_rb_client_spec"
+            b << "\x00\x05users"
+            b << "\x00\x13secondary_addresses"
+            b << "\x00!"
+            b << "\x00\r"
+            b << "\x00\x00\x00\xE4org.apache.cassandra.db.marshal.UserType(cql_rb_client_spec,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a6970:org.apache.cassandra.db.marshal.Int32Type)"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00:"
+            b << "\x00\x01\x00\vsecret_lair"
+            b << "\x00)"
+            b << "\x00\x00\x00\x104 Some Other St."
+            b << "\x00\x00\x00\tGos Latos"
+            b << "\x00\x00\x00\x04\x00\x01Vf"
+            b
+          end
+
+          let :response do
+            described_class.decode(2, buffer, buffer.length)
+          end
+
+          it 'decodes the type metadata' do
+            type_description = response.metadata[0]
+            type_description.should == [
+              'cql_rb_client_spec',
+              'users',
+              'secondary_addresses',
+              [:map, :varchar, [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]]
+            ]
+          end
+
+          it 'decodes the column value to a hash' do
+            custom_value = response.rows[0]['secondary_addresses']
+            custom_value.should eql(
+              'secret_lair' => {
+                'street' => '4 Some Other St.',
+                'city' => 'Gos Latos',
+                'zip' => 87654,
+              }
+            )
+          end
+        end
+
+        context 'with user defined types inside of other user defined types and collection types' do
+          let :buffer1 do
+            b = CqlByteBuffer.new
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x12cql_rb_client_spec"
+            b << "\x00\x05users"
+            b << "\x00\temployers"
+            b << "\x00\""
+            b << "\x00\x00\x01\x9Forg.apache.cassandra.db.marshal.UserType(cql_rb_client_spec,636f6d70616e79,6e616d65:org.apache.cassandra.db.marshal.UTF8Type,616464726573736573:org.apache.cassandra.db.marshal.ListType(org.apache.cassandra.db.marshal.UserType(cql_rb_client_spec,61646472657373,737472656574:org.apache.cassandra.db.marshal.UTF8Type,63697479:org.apache.cassandra.db.marshal.UTF8Type,7a6970:org.apache.cassandra.db.marshal.Int32Type)))"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\x8C"
+            b << "\x00\x02"
+            b << "\x00S"
+            b << "\x00\x00\x00\tAcme Corp"
+            b << "\x00\x00\x00B"
+            b << "\x00\x00\x00\x02"
+            b << "\x00\x00\x00\e"
+            b << "\x00\x00\x00\x051 St."
+            b << "\x00\x00\x00\x061 City"
+            b << "\x00\x00\x00\x04\x00\x00+g"
+            b << "\x00\x00\x00\e"
+            b << "\x00\x00\x00\x052 St."
+            b << "\x00\x00\x00\x062 City"
+            b << "\x00\x00\x00\x04\x00\x00V\xCE"
+            b << "\x003"
+            b << "\x00\x00\x00\bFoo Inc."
+            b << "\x00\x00\x00#"
+            b << "\x00\x00\x00\x01"
+            b << "\x00\x00\x00\e"
+            b << "\x00\x00\x00\x053 St."
+            b << "\x00\x00\x00\x063 City"
+            b << "\x00\x00\x00\x04\x00\x00\x825"
+          end
+
+          let :response do
+            described_class.decode(2, buffer1, buffer1.length)
+          end
+
+          it 'decodes the type metadata' do
+            type_description = response.metadata[0]
+            type_description.should == [
+              'cql_rb_client_spec',
+              'users',
+              'employers',
+              [:set, [:udt, {'name' => :text, 'addresses' => [:list, [:udt, {'street' => :text, 'city' => :text, 'zip' => :int}]]}]]
+            ]
+          end
+
+          it 'decodes the column value to a hash' do
+            custom_value = response.rows[0]['employers']
+            custom_value.should eql(Set.new([
+              {'name' => 'Acme Corp', 'addresses' => [{'street' => '1 St.', 'city' => '1 City', 'zip' => 11111}, {'street' => '2 St.', 'city' => '2 City', 'zip' => 22222}]},
+              {'name' => 'Foo Inc.', 'addresses' => [{'street' => '3 St.', 'city' => '3 City', 'zip' => 33333}]}
+            ]))
+          end
+        end
+
         context 'with an unknown column type' do
           it 'raises an error when encountering an unknown column type' do
             buffer = CqlByteBuffer.new("\x00\x00\x00\x01\x00\x00\x00\x03\x00\ncql_rb_328\x00\x05users\x00\tuser_name\x00\xff\x00\x05email\x00\r\x00\bpassword\x00\r\x00\x00\x00\x00")