cassandra-driver 1.2.0 → 2.0.0

data/lib/cassandra/protocol/requests/startup_request.rb

@@ -32,7 +32,7 @@ module Cassandra
         false
       end
 
-      def write(protocol_version, buffer)
+      def write(buffer, protocol_version, encoder)
         buffer.append_string_map(@options)
       end
 

data/lib/cassandra/protocol/response.rb

@@ -19,15 +19,6 @@
 module Cassandra
   module Protocol
     class Response
-      def self.decode(opcode, protocol_version, buffer, length, trace_id)
-        response_class = RESPONSE_TYPES[opcode]
-        if response_class
-          response_class.decode(protocol_version, buffer, length, trace_id)
-        else
-          raise Errors::DecodingError, "Unsupported opcode #{opcode.inspect}"
-        end
-      end
-
       private
 
       RESPONSE_TYPES = [

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

@@ -0,0 +1,40 @@
+# 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 AlreadyExistsErrorResponse < ErrorResponse
+      attr_reader :keyspace, :table
+
+      def initialize(code, message, keyspace, table)
+        super(code, message)
+
+        @keyspace = keyspace
+        @table    = table
+      end
+
+      def to_error(statement = nil)
+        Errors::AlreadyExistsError.new(@message, statement, @keyspace, @table)
+      end
+
+      def to_s
+        "#{super} #{@keyspace} #{@table}"
+      end
+    end
+  end
+end

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

@@ -21,10 +21,6 @@ module Cassandra
     class AuthChallengeResponse < Response
       attr_reader :token
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(buffer.read_bytes)
-      end
-
       def initialize(token)
         @token = token
       end

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

@@ -21,16 +21,12 @@ module Cassandra
     class AuthSuccessResponse < Response
       attr_reader :token
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(buffer.read_bytes)
-      end
-
       def initialize(token)
         @token = token
       end
 
       def to_s
-        %(AUTH_SUCCESS #{@token.bytesize})
+        %(AUTH_SUCCESS #{@token && @token.bytesize})
       end
 
       private

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

@@ -21,10 +21,6 @@ module Cassandra
     class AuthenticateResponse < Response
       attr_reader :authentication_class
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(buffer.read_string)
-      end
-
       def initialize(authentication_class)
         @authentication_class = authentication_class
       end

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

@@ -25,18 +25,6 @@ module Cassandra
         @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")

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

@@ -19,14 +19,6 @@
 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 Errors::DecodingError, %(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

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

@@ -26,16 +26,6 @@ module Cassandra
         @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

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

@@ -27,7 +27,7 @@ module Cassandra
 
       def materialize(metadata)
         @metadata = metadata
-        @rows = RowsResultResponse.read_rows(@protocol_version, @raw_rows, @metadata)
+        @rows = Coder.read_values_v1(@raw_rows, @metadata)
       end
 
       def rows

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

@@ -0,0 +1,42 @@
+# 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 ReadTimeoutErrorResponse < ErrorResponse
+      attr_reader :consistency, :received, :blockfor, :data_present
+
+      def initialize(code, message, consistency, received, blockfor, data_present)
+        super(code, message)
+
+        @consistency  = consistency
+        @received     = received
+        @blockfor     = blockfor
+        @data_present = data_present
+      end
+
+      def to_error(statement = nil)
+        Errors::ReadTimeoutError.new(@message, statement, @data_present, @consistency, @blockfor, @received)
+      end
+
+      def to_s
+        "#{super} #{@consistency} #{@received} #{@blockfor} #{@data_present}"
+      end
+    end
+  end
+end

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

@@ -19,10 +19,6 @@
 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

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

@@ -25,13 +25,6 @@ module Cassandra
         @trace_id = trace_id
       end
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        kind = buffer.read_int
-        impl = RESULT_TYPES[kind]
-        raise Errors::DecodingError, %(Unsupported result kind: #{kind}) unless impl
-        impl.decode(protocol_version, buffer, length - 4, trace_id)
-      end
-
       def void?
         false
       end

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

@@ -26,18 +26,6 @@ module Cassandra
         @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
@@ -45,95 +33,6 @@ module Cassandra
       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 Errors::DecodingError, %(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

@@ -28,9 +28,6 @@ module Cassandra
         @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

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

@@ -26,10 +26,6 @@ module Cassandra
         @keyspace = keyspace
       end
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(buffer.read_string, trace_id)
-      end
-
       def to_s
         %(RESULT SET_KEYSPACE "#@keyspace")
       end

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

@@ -28,10 +28,6 @@ module Cassandra
         @type = TYPE
       end
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(buffer.read_string, *buffer.read_inet)
-      end
-
       def to_s
         %(EVENT #@type #@change #@address:#@port)
       end

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

@@ -25,10 +25,6 @@ module Cassandra
         @options = options
       end
 
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(buffer.read_string_multimap)
-      end
-
       def to_s
         %(SUPPORTED #{options})
       end

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

@@ -0,0 +1,41 @@
+# 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 UnavailableErrorResponse < ErrorResponse
+      attr_reader :consistency, :required, :alive
+
+      def initialize(code, message, consistency, required, alive)
+        super(code, message)
+
+        @consistency = consistency
+        @required    = required
+        @alive       = alive
+      end
+
+      def to_error(statement = nil)
+        Errors::UnavailableError.new(@message, statement, @consistency, @required, @alive)
+      end
+
+      def to_s
+        "#{super} #{@consistency} #{@required} #{@alive}"
+      end
+    end
+  end
+end

data/lib/cassandra/protocol/responses/unprepared_error_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 UnpreparedErrorResponse < ErrorResponse
+      attr_reader :id
+
+      def initialize(code, message, id)
+        super(code, message)
+
+        @id = id
+      end
+
+      def to_error(statement = nil)
+        Errors::UnpreparedError.new(@message, statement, @id)
+      end
+
+      def to_s
+        "#{super} #{@id}"
+      end
+    end
+  end
+end