cassandra-driver 0.1.0.alpha1 → 1.0.0.beta.1

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

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class ErrorResponse < Response
+      attr_reader :code, :message
+
+      def initialize(*args)
+        @code, @message = args
+      end
+
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        code = buffer.read_int
+        message = buffer.read_string
+        case code
+        when 0x1000, 0x1100, 0x1200, 0x2400, 0x2500
+          new_length = length - 4 - 4 - message.bytesize
+          DetailedErrorResponse.decode(code, message, protocol_version, buffer, new_length)
+        else
+          new(code, message)
+        end
+      end
+
+      def to_s
+        hex_code = @code.to_s(16).rjust(4, '0').upcase
+        %(ERROR 0x#{hex_code} "#@message")
+      end
+
+      private
+
+      RESPONSE_TYPES[0x00] = self
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class EventResponse < ResultResponse
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        type = buffer.read_string
+        impl = EVENT_TYPES[type]
+        raise UnsupportedEventTypeError, %(Unsupported event type: "#{type}") unless impl
+        new_length = length - 4 - type.bytesize
+        impl.decode(protocol_version, buffer, new_length, trace_id)
+      end
+
+      private
+
+      RESPONSE_TYPES[0x0c] = self
+
+      EVENT_TYPES = {
+        # populated by subclasses
+      }
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class PreparedResultResponse < ResultResponse
+      attr_reader :id, :metadata, :result_metadata
+
+      def initialize(id, metadata, result_metadata, trace_id)
+        super(trace_id)
+        @id, @metadata, @result_metadata = id, metadata, result_metadata
+      end
+
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        id = buffer.read_short_bytes
+        metadata, _ = RowsResultResponse.read_metadata(protocol_version, buffer)
+        result_metadata = nil
+        if protocol_version > 1
+          result_metadata, _, _ = RowsResultResponse.read_metadata(protocol_version, buffer)
+        end
+        new(id, metadata, result_metadata, trace_id)
+      end
+
+      def eql?(other)
+        self.id == other.id && self.metadata == other.metadata && self.trace_id == other.trace_id
+      end
+      alias_method :==, :eql?
+
+      def hash
+        @h ||= begin
+          h = 0
+          h = ((h & 0x01ffffff) * 31) ^ @id.hash
+          h = ((h & 0x01ffffff) * 31) ^ @metadata.hash
+          h = ((h & 0x01ffffff) * 31) ^ @trace_id.hash
+          h
+        end
+      end
+
+      def to_s
+        hex_id = @id.each_byte.map { |x| x.to_s(16).rjust(2, '0') }.join('')
+        %(RESULT PREPARED #{hex_id} #@metadata)
+      end
+
+      private
+
+      RESULT_TYPES[0x04] = self
+    end
+  end
+end

data/lib/cassandra/protocol/responses/raw_rows_result_response.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class RawRowsResultResponse < RowsResultResponse
+      def initialize(protocol_version, raw_rows, paging_state, trace_id)
+        super(nil, nil, paging_state, trace_id)
+        @protocol_version = protocol_version
+        @raw_rows = raw_rows
+      end
+
+      def materialize(metadata)
+        @metadata = metadata
+        @rows = RowsResultResponse.read_rows(@protocol_version, @raw_rows, @metadata)
+      end
+
+      def rows
+        raise UnmaterializedRowsError, 'Not materialized!' unless @rows
+        @rows
+      end
+
+      def to_s
+        %(RESULT ROWS (raw))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class ReadyResponse < Response
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        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
+
+      private
+
+      RESPONSE_TYPES[0x02] = self
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class ResultResponse < Response
+      attr_reader :trace_id
+
+      def initialize(trace_id)
+        @trace_id = trace_id
+      end
+
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        kind = buffer.read_int
+        impl = RESULT_TYPES[kind]
+        raise UnsupportedResultKindError, %(Unsupported result kind: #{kind}) unless impl
+        impl.decode(protocol_version, buffer, length - 4, trace_id)
+      end
+
+      def void?
+        false
+      end
+
+      private
+
+      RESPONSE_TYPES[0x08] = self
+
+      RESULT_TYPES = [
+        # populated by subclasses
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class RowsResultResponse < ResultResponse
+      attr_reader :rows, :metadata, :paging_state
+
+      def initialize(rows, metadata, paging_state, trace_id)
+        super(trace_id)
+        @rows, @metadata, @paging_state = rows, metadata, paging_state
+      end
+
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        original_buffer_length = buffer.length
+        column_specs, columns_count, paging_state = read_metadata(protocol_version, buffer)
+        if column_specs.nil?
+          consumed_bytes = original_buffer_length - buffer.length
+          remaining_bytes = CqlByteBuffer.new(buffer.read(length - consumed_bytes))
+          RawRowsResultResponse.new(protocol_version, remaining_bytes, paging_state, trace_id)
+        else
+          new(read_rows(protocol_version, buffer, column_specs), column_specs, paging_state, trace_id)
+        end
+      end
+
+      def to_s
+        %(RESULT ROWS #@metadata #@rows)
+      end
+
+      private
+
+      RESULT_TYPES[0x02] = self
+
+      COLUMN_TYPES = [
+        nil,
+        :ascii,
+        :bigint,
+        :blob,
+        :boolean,
+        :counter,
+        :decimal,
+        :double,
+        :float,
+        :int,
+        :text,
+        :timestamp,
+        :uuid,
+        :varchar,
+        :varint,
+        :timeuuid,
+        :inet,
+      ].freeze
+
+      TYPE_CONVERTER = TypeConverter.new
+
+      GLOBAL_TABLES_SPEC_FLAG = 0x01
+      HAS_MORE_PAGES_FLAG = 0x02
+      NO_METADATA_FLAG = 0x04
+
+      def self.read_column_type(buffer)
+        id, type = buffer.read_option 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(protocol_version, buffer)
+        flags = buffer.read_int
+        columns_count = buffer.read_int
+        paging_state = nil
+        column_specs = nil
+        if flags & HAS_MORE_PAGES_FLAG != 0
+          paging_state = buffer.read_bytes
+        end
+        if flags & NO_METADATA_FLAG == 0
+          if flags & GLOBAL_TABLES_SPEC_FLAG != 0
+            global_keyspace_name = buffer.read_string
+            global_table_name = buffer.read_string
+          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 = buffer.read_string
+              table_name = buffer.read_string
+            end
+            column_name = buffer.read_string
+            type = read_column_type(buffer)
+            [keyspace_name, table_name, column_name, type]
+          end
+        end
+        [column_specs, columns_count, paging_state]
+      end
+
+      def self.read_rows(protocol_version, buffer, column_specs)
+        rows_count = buffer.read_int
+        rows = []
+        rows_count.times do |row_index|
+          row = {}
+          column_specs.each do |column_spec|
+            row[column_spec[2]] = TYPE_CONVERTER.from_bytes(buffer, column_spec[3])
+          end
+          rows << row
+        end
+        rows
+      end
+    end
+  end
+end

data/lib/cassandra/protocol/responses/schema_change_event_response.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  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(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string, buffer.read_string, buffer.read_string)
+      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
+
+      private
+
+      EVENT_TYPES[TYPE] = self
+    end
+  end
+end