cassandra-driver 1.2.0 → 2.0.0

data/lib/cassandra/statements/batch.rb

@@ -55,18 +55,45 @@ module Cassandra
         @statements = []
       end
 
-      # Adds a statement to this batch
+      # @!method add(statement, args)
+      # Adds a statement to this batch.
+      #
       # @param statement [String, Cassandra::Statements::Simple,
-      #   Cassandra::Statements::Prepared, Cassandra::Statements::Bound] statement to add
-      # @param args [*Object] arguments to paramterized query or prepared
-      #   statement
+      #   Cassandra::Statements::Prepared, Cassandra::Statements::Bound]
+      #   statement to add.
+      # @param args [Array] positional arguments to bind, must contain
+      #   the same number of parameters as the number of positional (`?`)
+      #   markers in the original CQL passed to {Cassandra::Session#prepare}
+      #
+      # @overload add(statement, *args)
+      #   Adds a statement to this batch using the deprecated splat-style way of
+      #   passing positional arguments
+      #
+      #   @deprecated Please pass a single {Array} of positional arguments, the
+      #     `*args` style is deprecated.
+      #
+      #   @param statement [String, Cassandra::Statements::Simple,
+      #     Cassandra::Statements::Prepared, Cassandra::Statements::Bound]
+      #     statement to add.
+      #   @param args [*Object] **this style of positional arguments is
+      #     deprecated, please pass a single {Array} instead** - arguments to
+      #     paramterized query or prepared statement
+      #
       # @return [self]
       def add(statement, *args)
+        if args.one? && args.first.is_a?(::Array)
+          args = args.first
+        elsif !args.empty?
+          ::Kernel.warn "[WARNING] Splat style (*args) positional arguments " \
+                        "are deprecated, pass an Array instead - called " \
+                        "from #{caller.first}"
+        end
+
         case statement
         when String
-          @statements << Simple.new(statement, *args)
+          @statements << Simple.new(statement, args)
         when Prepared
-          @statements << statement.bind(*args)
+          @statements << statement.bind(args)
         when Bound, Simple
           @statements << statement
         else

data/lib/cassandra/statements/bound.rb

@@ -27,12 +27,12 @@ module Cassandra
       # @return [Array<Object>] a list of positional parameters for the cql
       attr_reader :params
       # @private
-      attr_reader :params_metadata, :result_metadata, :keyspace, :partition_key
+      attr_reader :params_types, :result_metadata, :keyspace, :partition_key
 
       # @private
-      def initialize(cql, params_metadata, result_metadata, params, keyspace = nil, partition_key = nil)
+      def initialize(cql, params_types, result_metadata, params, keyspace = nil, partition_key = nil)
         @cql             = cql
-        @params_metadata = params_metadata
+        @params_types    = params_types
         @result_metadata = result_metadata
         @params          = params
         @keyspace        = keyspace

data/lib/cassandra/statements/prepared.rb

@@ -24,8 +24,6 @@ module Cassandra
       # @return [String] original cql used to prepare this statement
       attr_reader :cql
       # @private
-      attr_reader :params_metadata
-      # @private
       attr_reader :result_metadata
 
       # @private
@@ -44,22 +42,52 @@ module Cassandra
         @schema          = schema
       end
 
+      # @!method bind(args)
       # Creates a statement bound with specific arguments
-      # @param args [*Object] arguments to bind, must contain the same number
-      #   of parameters as the number of positional arguments (`?`) in the
-      #   original cql passed to {Cassandra::Session#prepare}
+      #
+      # @param args [Array] positional arguments to bind, must contain the same
+      #   number of parameters as the number of positional (`?`) markers in the
+      #   original CQL passed to {Cassandra::Session#prepare}
+      #
+      # @note Positional arguments are only supported on Apache Cassandra 2.1
+      #   and above.
+      #
+      # @overload bind(*args)
+      #   Creates a statement bound with specific arguments using the
+      #   deprecated splat-style way of passing positional arguments.
+      #
+      #   @deprecated Please pass a single {Array} of positional arguments, the
+      #     `*args` style is deprecated.
+      #
+      #   @param args [*Object] **this style of positional arguments is
+      #     deprecated, please pass a single {Array} instead** - positional
+      #     arguments to bind, must contain the same number of parameters as
+      #     the number of positional argument markers (`?`) in the CQL passed
+      #     to {Cassandra::Session#prepare}.
+      #
       # @return [Cassandra::Statements::Bound] bound statement
       def bind(*args)
+        if args.one? && args.first.is_a?(::Array)
+          args = args.first
+        else
+          unless args.empty?
+            ::Kernel.warn "[WARNING] Splat style (*args) positional " \
+                          "arguments are deprecated, pass an Array instead " \
+                          "- called from #{caller.first}"
+          end
+        end
+
         Util.assert_equal(@params_metadata.size, args.size) { "expecting exactly #{@params_metadata.size} bind parameters, #{args.size} given" }
 
-        @params_metadata.each_with_index do |metadata, i|
-          Util.assert_type(metadata[3], args[i]) { "argument for #{metadata[2].inspect} must be #{metadata[3].inspect}, #{args[i]} given" }
+        params_types = @params_metadata.each_with_index.map do |(_, _, name, type), i|
+          Util.assert_type(type, args[i]) { "argument for #{name.inspect} must be #{type.inspect}, #{args[i]} given" }
+          type
         end
 
-        return Bound.new(@cql, @params_metadata, @result_metadata, args) if @params_metadata.empty?
+        return Bound.new(@cql, params_types, @result_metadata, args) if @params_metadata.empty?
 
         keyspace, table, _, _ = @params_metadata.first
-        return Bound.new(@cql, @params_metadata, @result_metadata, args, keyspace) unless keyspace && table
+        return Bound.new(@cql, params_types, @result_metadata, args, keyspace) unless keyspace && table
 
         values = ::Hash.new
         @params_metadata.zip(args) do |(keyspace, table, column, type), value|
@@ -68,7 +96,7 @@ module Cassandra
 
         partition_key = @schema.create_partition_key(keyspace, table, values)
 
-        Bound.new(@cql, @params_metadata, @result_metadata, args, keyspace, partition_key)
+        Bound.new(@cql, params_types, @result_metadata, args, keyspace, partition_key)
       end
 
       # @return [Cassandra::Execution::Info] execution info for PREPARE request

data/lib/cassandra/statements/simple.rb

@@ -26,8 +26,26 @@ module Cassandra
       # @return [Array<Object>] a list of positional parameters for the cql
       attr_reader :params
 
+      # @private
+      attr_reader :params_types
+
+      # @!method initialize(cql, params)
       # @param cql [String] a cql statement
-      # @param params [*Object] positional arguments for the query
+      # @param params [Array] positional arguments for the query
+      #
+      # @note Positional arguments for simple statements are only supported on
+      #   starting with Apache Cassandra 2.0 and above.
+      #
+      # @overload initialize(cql, *params)
+      #   Uses the deprecated splat-style way of passing positional arguments.
+      #
+      #   @deprecated Please pass a single {Array} of positional arguments, the
+      #     `*params` style is deprecated.
+      #
+      #   @param cql [String] a cql statement
+      #   @param params [*Object] **this style of positional arguments is
+      #     deprecated, please pass a single {Array} instead** - positional
+      #     arguments for the query
       #
       # @raise [ArgumentError] if cql statement given is not a String
       def initialize(cql, *params)
@@ -35,8 +53,21 @@ module Cassandra
           raise ::ArgumentError, "cql must be a string, #{cql.inspect} given"
         end
 
-        @cql    = cql
-        @params = params
+        if params.one? && params.first.is_a?(::Array)
+          params = params.first
+        else
+          unless params.empty?
+            ::Kernel.warn "[WARNING] Splat style (*params) positional " \
+                          "arguments are deprecated, pass an Array instead " \
+                          "- called from #{caller.first}"
+          end
+        end
+
+        params_types = params.map {|value| guess_type(value)}
+
+        @cql          = cql
+        @params       = params
+        @params_types = params_types
       end
 
       # @return [String] a CLI-friendly simple statement representation
@@ -53,6 +84,44 @@ module Cassandra
       end
 
       alias :== :eql?
+
+      private
+
+      # @private
+      @@type_guesses = {
+        ::String     => :varchar,
+        ::Fixnum     => :bigint,
+        ::Float      => :double,
+        ::Bignum     => :varint,
+        ::BigDecimal => :decimal,
+        ::TrueClass  => :boolean,
+        ::FalseClass => :boolean,
+        ::NilClass   => :bigint,
+        Uuid         => :uuid,
+        TimeUuid     => :uuid,
+        ::IPAddr     => :inet,
+        ::Time       => :timestamp,
+        ::Hash       => :map,
+        ::Array      => :list,
+        ::Set        => :set,
+      }.freeze
+
+      def guess_type(value)
+        type = @@type_guesses[value.class]
+
+        raise ::ArgumentError, "Unable to guess the type of the argument: #{value.inspect}" unless type
+
+        if type == :map
+          pair = value.first
+          [type, guess_type(pair[0]), guess_type(pair[1])]
+        elsif type == :list
+          [type, guess_type(value.first)]
+        elsif type == :set
+          [type, guess_type(value.first)]
+        else
+          type
+        end
+      end
     end
   end
 end

data/lib/cassandra/table.rb

@@ -261,7 +261,7 @@ module Cassandra
 
         buffer = Protocol::CqlByteBuffer.new
 
-        TYPE_CONVERTER.to_bytes(buffer, column.type, values[column_name])
+        Protocol::Coder.write_value_v1(buffer, values[column_name], column.type)
         buffer.discard(4)
       else
         buf    = nil
@@ -274,7 +274,7 @@ module Cassandra
           buf    ||= Protocol::CqlByteBuffer.new
           buffer ||= Protocol::CqlByteBuffer.new
 
-          TYPE_CONVERTER.to_bytes(buf, column.type, values[column_name])
+          Protocol::Coder.write_value_v1(buf, values[column_name], column.type)
           buf.discard(4) # discard size
 
           size = buf.length
@@ -289,7 +289,6 @@ module Cassandra
     private
 
     NULL_BYTE = "\x00".freeze
-    TYPE_CONVERTER = Protocol::TypeConverter.new
 
     attr_reader :partition_key, :clustering_columns, :clustering_order
     protected :partition_key, :clustering_columns, :clustering_order

data/lib/cassandra/util.rb

@@ -132,6 +132,22 @@ module Cassandra
       io.string
     end
 
+    def type_to_cql(type)
+      case type
+      when Array
+        case type[0]
+        when :list, :set
+          "#{type[0].to_s}<#{type_to_cql(type[1])}>"
+        when :map
+          "#{type[0].to_s}<#{type_to_cql(type[1])}, #{type_to_cql(type[2])}>"
+        else
+          type.to_s
+        end
+      else
+        type.to_s
+      end
+    end
+
     def escape_name(name)
       return name if name[LOWERCASE_REGEXP] == name
       DBL_QUOT + name + DBL_QUOT
@@ -159,6 +175,8 @@ module Cassandra
             assert_type(type[1], k)
             assert_type(type[2], v)
           end
+        when :custom
+          assert_responds_to_all([:bytesize, :to_s], value, message, &block)
         else
           raise ::RuntimeError, "unsupported complex type #{type.inspect}"
         end

data/lib/cassandra/version.rb

@@ -17,5 +17,5 @@
 #++
 
 module Cassandra
-  VERSION = '1.2.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassandra-driver
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Theo Hultberg
@@ -116,10 +116,9 @@ files:
 - lib/cassandra/load_balancing/policies/white_list.rb
 - lib/cassandra/null_logger.rb
 - lib/cassandra/protocol.rb
+- lib/cassandra/protocol/coder.rb
 - lib/cassandra/protocol/cql_byte_buffer.rb
 - lib/cassandra/protocol/cql_protocol_handler.rb
-- lib/cassandra/protocol/frame_decoder.rb
-- lib/cassandra/protocol/frame_encoder.rb
 - lib/cassandra/protocol/request.rb
 - lib/cassandra/protocol/requests/auth_response_request.rb
 - lib/cassandra/protocol/requests/batch_request.rb
@@ -132,14 +131,15 @@ files:
 - lib/cassandra/protocol/requests/startup_request.rb
 - lib/cassandra/protocol/requests/void_query_request.rb
 - lib/cassandra/protocol/response.rb
+- lib/cassandra/protocol/responses/already_exists_error_response.rb
 - lib/cassandra/protocol/responses/auth_challenge_response.rb
 - lib/cassandra/protocol/responses/auth_success_response.rb
 - lib/cassandra/protocol/responses/authenticate_response.rb
-- lib/cassandra/protocol/responses/detailed_error_response.rb
 - lib/cassandra/protocol/responses/error_response.rb
 - lib/cassandra/protocol/responses/event_response.rb
 - lib/cassandra/protocol/responses/prepared_result_response.rb
 - lib/cassandra/protocol/responses/raw_rows_result_response.rb
+- lib/cassandra/protocol/responses/read_timeout_error_response.rb
 - lib/cassandra/protocol/responses/ready_response.rb
 - lib/cassandra/protocol/responses/result_response.rb
 - lib/cassandra/protocol/responses/rows_result_response.rb
@@ -149,8 +149,11 @@ files:
 - lib/cassandra/protocol/responses/status_change_event_response.rb
 - lib/cassandra/protocol/responses/supported_response.rb
 - lib/cassandra/protocol/responses/topology_change_event_response.rb
+- lib/cassandra/protocol/responses/unavailable_error_response.rb
+- lib/cassandra/protocol/responses/unprepared_error_response.rb
 - lib/cassandra/protocol/responses/void_result_response.rb
-- lib/cassandra/protocol/type_converter.rb
+- lib/cassandra/protocol/responses/write_timeout_error_response.rb
+- lib/cassandra/protocol/v1.rb
 - lib/cassandra/reconnection.rb
 - lib/cassandra/reconnection/policies.rb
 - lib/cassandra/reconnection/policies/constant.rb

data/lib/cassandra/protocol/frame_decoder.rb

@@ -1,128 +0,0 @@
-# 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
-    # @private
-    class FrameDecoder
-      def initialize(compressor=nil)
-        @compressor = compressor
-      end
-
-      def decode_frame(buffer, partial_frame=nil)
-        partial_frame ||= NULL_FRAME
-        if partial_frame == NULL_FRAME
-          buffer_length = buffer.length
-          return NULL_FRAME if buffer_length < 8
-          fields = buffer.read_int
-          size = buffer.read_int
-          if buffer_length - 8 >= size
-            actual_decode(buffer, fields, size)
-          else
-            PartialFrame.new(fields, size)
-          end
-        elsif buffer.length >= partial_frame.size
-          actual_decode(buffer, partial_frame.fields, partial_frame.size)
-        else
-          partial_frame
-        end
-      end
-
-      private
-
-      def actual_decode(buffer, fields, size)
-        if (fields >> 24) & 0x80 == 0
-          raise Errors::DecodingError, 'Request frames are not supported'
-        end
-        protocol_version = (fields >> 24) & 0x7f
-        compression = (fields >> 16) & 0x01
-        tracing = (fields >> 16) & 0x02
-        stream_id = (fields >> 8) & 0xff
-        stream_id = (stream_id & 0x7f) - (stream_id & 0x80)
-        opcode = fields & 0xff
-        if compression == 1
-          buffer = decompress(buffer, size)
-          size = buffer.size
-        end
-        if tracing == 2
-          trace_id = buffer.read_uuid
-          size -= 16
-        else
-          trace_id = nil
-        end
-        extra_length = buffer.length - size
-        response = Response.decode(opcode, protocol_version, buffer, size, trace_id)
-        if buffer.length > extra_length
-          buffer.discard(buffer.length - extra_length)
-        end
-        CompleteFrame.new(stream_id, response)
-      end
-
-      def decompress(buffer, size)
-        if @compressor
-          compressed_body = buffer.read(size)
-          CqlByteBuffer.new(@compressor.decompress(compressed_body))
-        else
-          raise Errors::DecodingError, 'Compressed frame received, but no compressor configured'
-        end
-      end
-
-      class NullFrame
-        def size
-          nil
-        end
-
-        def complete?
-          false
-        end
-      end
-
-      class PartialFrame
-        attr_reader :fields, :size
-
-        def initialize(fields, size)
-          @fields = fields
-          @size = size
-        end
-
-        def stream_id
-          nil
-        end
-
-        def complete?
-          false
-        end
-      end
-
-      class CompleteFrame
-        attr_reader :stream_id, :body
-
-        def initialize(stream_id, body)
-          @stream_id = stream_id
-          @body = body
-        end
-
-        def complete?
-          true
-        end
-      end
-
-      NULL_FRAME = NullFrame.new
-    end
-  end
-end