* Refactored Statement classes and session.execute_async to make it possible to create new Statement classes (say in DSE) that the core driver can execute.

Author: stamhankar999

lib/cassandra/session.rb

@@ -89,20 +89,13 @@ def execute_async(statement, options = nil)
 
       case statement
       when ::String
-        @client.query(Statements::Simple.new(statement,
-                                             options.arguments,
-                                             options.type_hints,
-                                             options.idempotent?),
-                      options)
-      when Statements::Simple
-        @client.query(statement, options)
-      when Statements::Prepared
-        @client.execute(statement.bind(options.arguments), options)
-      when Statements::Bound
-        @client.execute(statement, options)
-      when Statements::Batch
-        Util.assert_not_empty(statement.statements) { 'batch cannot be empty' }
-        @client.batch(statement, options)
+        Statements::Simple.new(statement,
+                               options.arguments,
+                               options.type_hints,
+                               options.idempotent?).accept(@client,
+                                                           options)
+      when Statement
+        statement.accept(@client, options)
       else
         @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
       end

lib/cassandra/statement.rb

@@ -23,5 +23,10 @@ module Statement
     def idempotent?
       !!@idempotent
     end
+
+    # @private
+    def accept(client, options)
+      raise NotImplementedError, "#{self.class} must implement :accept method"
+    end
   end
 end

lib/cassandra/statements/batch.rb

@@ -113,6 +113,12 @@ def add(statement, options = nil)
         self
       end
 
+      # @private
+      def accept(client, options)
+        Util.assert_not_empty(statements) { 'batch cannot be empty' }
+        client.batch(self, options)
+      end
+
       # Determines whether or not the statement is safe to retry on timeout
       # Batches are idempotent only when all statements in a batch are.
       # @return [Boolean] whether the statement is safe to retry on timeout

lib/cassandra/statements/bound.rb

@@ -46,6 +46,11 @@ def initialize(cql,
         @idempotent      = idempotent
       end
 
+      # @private
+      def accept(client, options)
+        client.execute(self, options)
+      end
+
       # @return [String] a CLI-friendly bound statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \

lib/cassandra/statements/prepared.rb

@@ -155,6 +155,11 @@ def execution_info
                                           nil)
       end
 
+      # @private
+      def accept(client, options)
+        client.execute(bind(options.arguments), options)
+      end
+
       # @return [String] a CLI-friendly prepared statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect}>"

lib/cassandra/statements/simple.rb

@@ -93,6 +93,11 @@ def initialize(cql, params = nil, type_hints = nil, idempotent = false)
         @idempotent   = idempotent
       end
 
+      # @private
+      def accept(client, options)
+        client.query(self, options)
+      end
+
       # @return [String] a CLI-friendly simple statement representation
       def inspect
         "#<#{self.class.name}:0x#{object_id.to_s(16)} @cql=#{@cql.inspect} " \

lib/cassandra/statements/void.rb

@@ -23,6 +23,11 @@ module Statements
     class Void
       include Statement
 
+      # @private
+      def accept(client, options)
+        nil
+      end
+
       # Returns nothing
       # @return [nil] there is no cql for the void statement
       def cql

spec/cassandra/session_spec.rb

@@ -35,7 +35,7 @@ module Cassandra
             statement = double('simple statement')
 
             expect(Statements::Simple).to receive(:new).once.with(cql, EMPTY_LIST, EMPTY_LIST, false).and_return(statement)
-            expect(client).to receive(:query).once.with(statement, session_options).and_return(promise)
+            expect(statement).to receive(:accept).once.with(client, session_options).and_return(promise)
             expect(session.execute_async(cql)).to eq(promise)
           end
         end
@@ -48,7 +48,7 @@ module Cassandra
             statement = double('simple statement')
 
             expect(Statements::Simple).to receive(:new).once.with(cql, [1], [], false).and_return(statement)
-            expect(client).to receive(:query).once.with(statement, session_options.override(arguments: [1])).and_return(promise)
+            expect(statement).to receive(:accept).once.with(client, session_options.override(arguments: [1])).and_return(promise)
             expect(session.execute_async(cql, arguments: [1])).to eq(promise)
           end
         end
@@ -61,7 +61,7 @@ module Cassandra
             statement = double('simple statement')
 
             expect(Statements::Simple).to receive(:new).once.with(cql, [1], [:int], false).and_return(statement)
-            expect(client).to receive(:query).once.with(statement, session_options.override(arguments: [1], type_hints: [:int])).and_return(promise)
+            expect(statement).to receive(:accept).once.with(client, 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
@@ -75,7 +75,7 @@ module Cassandra
             statement = double('simple statement')
 
             expect(Statements::Simple).to receive(:new).once.with(cql, EMPTY_LIST, EMPTY_LIST, false).and_return(statement)
-            expect(client).to receive(:query).once.with(statement, session_options.override(options)).and_return(promise)
+            expect(statement).to receive(:accept).once.with(client, session_options.override(options)).and_return(promise)
             expect(session.execute_async(cql, options)).to eq(promise)
           end
         end