cql-rb 1.0.0.pre6 → 1.0.0.pre7

data/lib/cql/protocol/responses/authenticate_response.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class AuthenticateResponse < ResponseBody
+      attr_reader :authentication_class
+
+      def self.decode!(buffer)
+        new(read_string!(buffer))
+      end
+
+      def initialize(authentication_class)
+        @authentication_class = authentication_class
+      end
+
+      def to_s
+        %(AUTHENTICATE #{authentication_class})
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/detailed_error_response.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class DetailedErrorResponse < ErrorResponse
+      attr_reader :details
+
+      def initialize(code, message, details)
+        super(code, message)
+        @details = details
+      end
+
+      def self.decode!(code, message, buffer)
+        details = {}
+        case code
+        when 0x1000 # unavailable
+          details[:cl] = read_consistency!(buffer)
+          details[:required] = read_int!(buffer)
+          details[:alive] = read_int!(buffer)
+        when 0x1100 # write_timeout
+          details[:cl] = read_consistency!(buffer)
+          details[:received] = read_int!(buffer)
+          details[:blockfor] = read_int!(buffer)
+          details[:write_type] = read_string!(buffer)
+        when 0x1200 # read_timeout
+          details[:cl] = read_consistency!(buffer)
+          details[:received] = read_int!(buffer)
+          details[:blockfor] = read_int!(buffer)
+          details[:data_present] = read_byte!(buffer) != 0
+        when 0x2400 # already_exists
+          details[:ks] = read_string!(buffer)
+          details[:table] = read_string!(buffer)
+        when 0x2500
+          details[:id] = read_short_bytes!(buffer)
+        end
+        new(code, message, details)
+      end
+
+      def to_s
+        %(ERROR #@code "#@message" #@details)
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/error_response.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class ErrorResponse < ResponseBody
+      attr_reader :code, :message
+
+      def initialize(*args)
+        @code, @message = args
+      end
+
+      def self.decode!(buffer)
+        code = read_int!(buffer)
+        message = read_string!(buffer)
+        case code
+        when 0x1000, 0x1100, 0x1200, 0x2400, 0x2500
+          DetailedErrorResponse.decode!(code, message, buffer)
+        else
+          new(code, message)
+        end
+      end
+
+      def to_s
+        %(ERROR #@code "#@message")
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/event_response.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class EventResponse < ResultResponse
+      def self.decode!(buffer)
+        type = read_string!(buffer)
+        case type
+        when SchemaChangeEventResponse::TYPE
+          SchemaChangeEventResponse.decode!(buffer)
+        when StatusChangeEventResponse::TYPE
+          StatusChangeEventResponse.decode!(buffer)
+        when TopologyChangeEventResponse::TYPE
+          TopologyChangeEventResponse.decode!(buffer)
+        else
+          raise UnsupportedEventTypeError, %(Unsupported event type: "#{type}")
+        end
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/prepared_result_response.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class PreparedResultResponse < ResultResponse
+      attr_reader :id, :metadata
+
+      def initialize(*args)
+        @id, @metadata = args
+      end
+
+      def self.decode!(buffer)
+        id = read_short_bytes!(buffer)
+        metadata = RowsResultResponse.read_metadata!(buffer)
+        new(id, metadata)
+      end
+
+      def to_s
+        %(RESULT PREPARED #{id.each_byte.map { |x| x.to_s(16) }.join('')} #@metadata)
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/ready_response.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class ReadyResponse < ResponseBody
+      def self.decode!(buffer)
+        new
+      end
+
+      def eql?(rs)
+        self.class === rs
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @h ||= to_s.hash ^ 0xbadc0de
+      end
+
+      def to_s
+        'READY'
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/result_response.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class ResultResponse < ResponseBody
+      def self.decode!(buffer)
+        kind = read_int!(buffer)
+        case kind
+        when 0x01
+          VoidResultResponse.decode!(buffer)
+        when 0x02
+          RowsResultResponse.decode!(buffer)
+        when 0x03
+          SetKeyspaceResultResponse.decode!(buffer)
+        when 0x04
+          PreparedResultResponse.decode!(buffer)
+        when 0x05
+          SchemaChangeResultResponse.decode!(buffer)
+        else
+          raise UnsupportedResultKindError, %(Unsupported result kind: #{kind})
+        end
+      end
+
+      def void?
+        false
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/rows_result_response.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class RowsResultResponse < ResultResponse
+      attr_reader :rows, :metadata
+
+      def initialize(*args)
+        @rows, @metadata = args
+      end
+
+      def self.decode!(buffer)
+        column_specs = read_metadata!(buffer)
+        new(read_rows!(buffer, column_specs), column_specs)
+      end
+
+      def to_s
+        %(RESULT ROWS #@metadata #@rows)
+      end
+
+      private
+
+      COLUMN_TYPES = [
+        nil,
+        :ascii,
+        :bigint,
+        :blob,
+        :boolean,
+        :counter,
+        :decimal,
+        :double,
+        :float,
+        :int,
+        :text,
+        :timestamp,
+        :uuid,
+        :varchar,
+        :varint,
+        :timeuuid,
+        :inet,
+      ].freeze
+
+      def self.read_column_type!(buffer)
+        id, type = read_option!(buffer) do |id, b|
+          if id > 0 && id <= 0x10
+            COLUMN_TYPES[id]
+          elsif id == 0x20
+            sub_type = read_column_type!(buffer)
+            [:list, sub_type]
+          elsif id == 0x21
+            key_type = read_column_type!(buffer)
+            value_type = read_column_type!(buffer)
+            [:map, key_type, value_type]
+          elsif id == 0x22
+            sub_type = read_column_type!(buffer)
+            [:set, sub_type]
+          else
+            raise UnsupportedColumnTypeError, %(Unsupported column type: #{id})
+          end
+        end
+        type
+      end
+
+      def self.read_metadata!(buffer)
+        flags = read_int!(buffer)
+        columns_count = read_int!(buffer)
+        if flags & 0x01 == 0x01
+          global_keyspace_name = read_string!(buffer)
+          global_table_name = read_string!(buffer)
+        end
+        column_specs = columns_count.times.map do
+          if global_keyspace_name
+            keyspace_name = global_keyspace_name
+            table_name = global_table_name
+          else
+            keyspace_name = read_string!(buffer)
+            table_name = read_string!(buffer)
+          end
+          column_name = read_string!(buffer)
+          type = read_column_type!(buffer)
+          [keyspace_name, table_name, column_name, type]
+        end
+      end
+
+      def self.read_rows!(buffer, column_specs)
+        type_converter = TypeConverter.new
+        rows_count = read_int!(buffer)
+        rows = []
+        rows_count.times do |row_index|
+          row = {}
+          column_specs.each do |column_spec|
+            row[column_spec[2]] = type_converter.convert_type(buffer, column_spec[3])
+          end
+          rows << row
+        end
+        rows
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/schema_change_event_result_response.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class SchemaChangeEventResponse < EventResponse
+      TYPE = 'SCHEMA_CHANGE'.freeze
+
+      attr_reader :type, :change, :keyspace, :table
+
+      def initialize(*args)
+        @change, @keyspace, @table = args
+        @type = TYPE
+      end
+
+      def self.decode!(buffer)
+        new(read_string!(buffer), read_string!(buffer), read_string!(buffer))
+      end
+
+      def eql?(rs)
+        rs.type == self.type && rs.change == self.change && rs.keyspace == self.keyspace && rs.table == self.table
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @h ||= begin
+          h = 0
+          h = ((h & 33554431) * 31) ^ @type.hash
+          h = ((h & 33554431) * 31) ^ @change.hash
+          h = ((h & 33554431) * 31) ^ @keyspace.hash
+          h = ((h & 33554431) * 31) ^ @table.hash
+          h
+        end
+      end
+
+      def to_s
+        %(EVENT #@type #@change "#@keyspace" "#@table")
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/schema_change_result_response.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class SchemaChangeResultResponse < ResultResponse
+      attr_reader :change, :keyspace, :table
+
+      def initialize(*args)
+        @change, @keyspace, @table = args
+      end
+
+      def self.decode!(buffer)
+        new(read_string!(buffer), read_string!(buffer), read_string!(buffer))
+      end
+
+      def to_s
+        %(RESULT SCHEMA_CHANGE #@change "#@keyspace" "#@table")
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/set_keyspace_result_response.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class SetKeyspaceResultResponse < ResultResponse
+      attr_reader :keyspace
+
+      def initialize(keyspace)
+        @keyspace = keyspace
+      end
+
+      def self.decode!(buffer)
+        new(read_string!(buffer))
+      end
+
+      def to_s
+        %(RESULT SET_KEYSPACE "#@keyspace")
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/status_change_event_result_response.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class StatusChangeEventResponse < EventResponse
+      TYPE = 'STATUS_CHANGE'.freeze
+
+      attr_reader :type, :change, :address, :port
+
+      def initialize(*args)
+        @change, @address, @port = args
+        @type = TYPE
+      end
+
+      def self.decode!(buffer)
+        new(read_string!(buffer), *read_inet!(buffer))
+      end
+
+      def to_s
+        %(EVENT #@type #@change #@address:#@port)
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/supported_response.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class SupportedResponse < ResponseBody
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def self.decode!(buffer)
+        new(read_string_multimap!(buffer))
+      end
+
+      def to_s
+        %(SUPPORTED #{options})
+      end
+    end
+  end
+end

data/lib/cql/protocol/responses/topology_change_event_result_response.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class TopologyChangeEventResponse < StatusChangeEventResponse
+      TYPE = 'TOPOLOGY_CHANGE'.freeze
+
+      def initialize(*args)
+        super
+        @type = TYPE
+      end
+    end
+  end
+end