adding type_hints for simple statements, to override Util.guess_type

Author: Vijay Ramesh

lib/cassandra/execution/options.rb

@@ -32,6 +32,8 @@ class Options
       attr_reader :timeout
       # @return [Array] positional arguments for the statement
       attr_reader :arguments
+      # @return [Array] type hints for positional arguments for the statement
+      attr_reader :type_hints
 
       # @return [String] paging state
       #
@@ -56,6 +58,7 @@ def initialize(options)
         serial_consistency = options[:serial_consistency]
         paging_state       = options[:paging_state]
         arguments          = options[:arguments]
+        type_hints         = options[:type_hints]
 
         Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
 
@@ -85,13 +88,20 @@ def initialize(options)
           Util.assert_instance_of_one_of([::Array, ::Hash], arguments) { ":arguments must be an Array or a Hash, #{arguments.inspect} given" }
         end
 
+        if type_hints.nil?
+          type_hints = EMPTY_LIST
+        else
+          Util.assert_instance_of_one_of([::Array, ::Hash], type_hints) { ":type_hints must be an Array or a Hash, #{type_hints.inspect} given" }
+        end
+
         @consistency        = consistency
         @page_size          = page_size
         @trace              = !!trace
         @timeout            = timeout
         @serial_consistency = serial_consistency
         @paging_state       = paging_state
         @arguments          = arguments
+        @type_hints         = type_hints
       end
 
       # @return [Boolean] whether request tracing was enabled
@@ -107,7 +117,8 @@ def eql?(other)
           other.timeout == @timeout &&
           other.serial_consistency == @serial_consistency &&
           other.paging_state == @paging_state &&
-          other.arguments == @arguments
+          other.arguments == @arguments &&
+          other.type_hints == @type_hints
       end
       alias :== :eql?
 
@@ -130,7 +141,8 @@ def to_h
           :trace              => @trace,
           :timeout            => @timeout,
           :serial_consistency => @serial_consistency,
-          :arguments          => @arguments || EMPTY_LIST
+          :arguments          => @arguments || EMPTY_LIST,
+          :type_hints         => @type_hints || EMPTY_LIST
         }
       end
     end

lib/cassandra/protocol/coder.rb

@@ -433,7 +433,7 @@ def read_type_v1(buffer)
         when 0x0020 then Types.list(read_type_v1(buffer))
         when 0x0021 then Types.map(read_type_v1(buffer), read_type_v1(buffer))
         when 0x0022 then Types.set(read_type_v1(buffer))
-        else 
+        else
           raise Errors::DecodingError, %(Unsupported column type: #{kind})
         end
       end

lib/cassandra/session.rb

@@ -57,6 +57,9 @@ def initialize(client, default_options, futures_factory)
     #   initial request.
     # @option options [Array, Hash] :arguments (nil) positional or named
     #   arguments for the statement.
+    # @option options [Array, Hash] :type_hints (nil) override Util.guess_type to
+    #   determine the CQL type for an argument; nil elements will fall-back
+    #   to Util.guess_type.
     #
     # @see Cassandra.cluster Options that can be specified on the cluster-level
     #   and their default values.
@@ -80,7 +83,7 @@ def execute_async(statement, options = nil)
 
       case statement
       when ::String
-        @client.query(Statements::Simple.new(statement, options.arguments), options)
+        @client.query(Statements::Simple.new(statement, options.arguments, options.type_hints), options)
       when Statements::Simple
         @client.query(statement, options)
       when Statements::Prepared

lib/cassandra/statements/batch.rb

@@ -63,6 +63,8 @@ def initialize
       # @param args [Array, Hash] (nil) positional or named arguments to bind,
       #   must contain the same number of parameters as the number of positional
       #   (`?`) or named (`:name`) markers in the CQL passed.
+      # @param type_hints [Array, Hash] (nil) specified CQL types for positional
+      #   or named arguments to override type guessing.
       #
       # @note Positional arguments for simple statements are only supported
       #   starting with Apache Cassandra 2.0 and above.
@@ -71,12 +73,13 @@ def initialize
       #   starting with Apache Cassandra 2.1 and above.
       #
       # @return [self]
-      def add(statement, args = nil)
+      def add(statement, args = nil, type_hints = nil)
         args ||= EMPTY_LIST
+        type_hints ||= EMPTY_LIST
 
         case statement
         when String
-          @statements << Simple.new(statement, args)
+          @statements << Simple.new(statement, args, type_hints)
         when Prepared
           @statements << statement.bind(args)
         when Bound, Simple

lib/cassandra/statements/simple.rb

@@ -33,7 +33,10 @@ class Simple
       attr_reader :params_names
 
       # @param cql [String] a cql statement
-      # @param params [Array] (nil) positional arguments for the query
+      # @param params [Array, Hash] (nil) positional or named arguments
+      #   for the query
+      # @param type_hints [Array, Hash] (nil) positional or named types
+      #   to override type guessing for the query
       #
       # @note Positional arguments for simple statements are only supported
       #   starting with Apache Cassandra 2.0 and above.
@@ -42,25 +45,37 @@ class Simple
       #   starting with Apache Cassandra 2.1 and above.
       #
       # @raise [ArgumentError] if cql statement given is not a String
-      def initialize(cql, params = nil)
+      def initialize(cql, params = nil, type_hints = nil)
         Util.assert_instance_of(::String, cql) { "cql must be a string, #{cql.inspect} given" }
 
         params ||= EMPTY_LIST
 
+
         if params.is_a?(::Hash)
           params_names = []
           params = params.each_with_object([]) do |(name, value), params|
             params_names << name
             params       << value
           end
+          if type_hints && !type_hints.empty?
+            Util.assert_instance_of(::Hash, type_hints) { "type_hints must be a Hash when using named params" }
+          end
         else
           Util.assert_instance_of(::Array, params) { "params must be an Array or a Hash, #{params.inspect} given" }
           params_names = EMPTY_LIST
         end
 
+        type_hints ||= EMPTY_LIST
+
+        if type_hints.is_a?(::Hash)
+          type_hints = params_names.map {|name| type_hints[name] }
+        else
+          Util.assert_instance_of(::Array, type_hints) { "type_hints must be an Array or a Hash, #{type_hints.inspect} given" }
+        end
+
         @cql          = cql
         @params       = params
-        @params_types = params.map {|value| Util.guess_type(value)}
+        @params_types = params.each_with_index.map {|value, index| (!type_hints.empty? && type_hints[index]) ? Types::Simple.new(type_hints[index]) : Util.guess_type(value)}
         @params_names = params_names
       end
 

spec/cassandra/session_spec.rb

@@ -34,7 +34,7 @@ module Cassandra
             promise   = double('promise')
             statement = double('simple statement')
 
-            expect(Statements::Simple).to receive(:new).once.with(cql, EMPTY_LIST).and_return(statement)
+            expect(Statements::Simple).to receive(:new).once.with(cql, EMPTY_LIST, EMPTY_LIST).and_return(statement)
             expect(client).to receive(:query).once.with(statement, session_options).and_return(promise)
             expect(session.execute_async(cql)).to eq(promise)
           end
@@ -47,12 +47,25 @@ module Cassandra
             promise   = double('promise')
             statement = double('simple statement')
 
-            expect(Statements::Simple).to receive(:new).once.with(cql, [1]).and_return(statement)
+            expect(Statements::Simple).to receive(:new).once.with(cql, [1], []).and_return(statement)
             expect(client).to receive(:query).once.with(statement, session_options.override(arguments: [1])).and_return(promise)
             expect(session.execute_async(cql, arguments: [1])).to eq(promise)
           end
         end
 
+        context 'with arguments and type_hints' do
+          let(:cql) { 'SELECT * FROM songs WHERE id = ?' }
+
+          it 'sends query with a simple statement with parameters and type hints' do
+            promise   = double('promise')
+            statement = double('simple statement')
+
+            expect(Statements::Simple).to receive(:new).once.with(cql, [1], [:int]).and_return(statement)
+            expect(client).to receive(:query).once.with(statement, session_options.override(arguments: [1], type_hints: [:int])).and_return(promise)
+            expect(session.execute_async(cql, arguments: [1], type_hints: [:int])).to eq(promise)
+          end
+        end
+
         context 'with options' do
           let(:cql) { 'SELECT * FROM songs' }
           let(:options) { {:trace => true} }
@@ -61,7 +74,7 @@ module Cassandra
             promise   = double('promise')
             statement = double('simple statement')
 
-            expect(Statements::Simple).to receive(:new).once.with(cql, EMPTY_LIST).and_return(statement)
+            expect(Statements::Simple).to receive(:new).once.with(cql, EMPTY_LIST, EMPTY_LIST).and_return(statement)
             expect(client).to receive(:query).once.with(statement, session_options.override(options)).and_return(promise)
             expect(session.execute_async(cql, options)).to eq(promise)
           end