sunstone 7.0.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02df1d75e40c2ef207e6e1f329068c95098f5b99758d1bcea603e157ed2c1f40
-  data.tar.gz: 4807c8a530f9c7f09448a08bea1dbe015724f2afb53d81b86cf5cef6d6b49dcf
+  metadata.gz: d280487f58777eebd36b07eb69f9492b77370ea3def7b05321bb2d4fd8e55626
+  data.tar.gz: a34f616483aca20b1207f12538e08fafb19b16ac01db6c19977b902cd1cd1537
 SHA512:
-  metadata.gz: e884525eda7c249da0f4decbadff3d27ff97859eac4874e1c20b4b0e10c80d6d96ee49419d27bd2f6d429c55c93485bfe1961451ff8396d101e37752ec39ac6d
-  data.tar.gz: 4323252706192a940b6f730a6c46324d4c40729df5864a5d1aafc4283764ef159284ddefe9b1335a7d9174b6716d11a2d0da4aa59dbdfbc3ac7cdccc537b06f8
+  metadata.gz: 0211de6c05fded268d04e00af2e0f16e9f4ee0650307288ea890c343e1b20f0a2fcf924631e2c0c3e72b602af7e964c8663a6df51f22cce9bd85798b26d12604
+  data.tar.gz: 62e9b986925a43ca27c172499bca956ea20e6b8ca237d94dbcb1b07f52772ad1ffc9d5a0fe68d9ef6560e9a3df5ccc7bc27a8a78b56aad4fcccc44604f2a9060

data/ext/active_record/associations/collection_association.rb

@@ -1,14 +1,16 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
 module ActiveRecord
   module Associations
     class CollectionAssociation
 
       def replace(other_array)
         other_array.each { |val| raise_on_type_mismatch!(val) }
-        original_target = load_target.dup
+        original_target = skip_strict_loading { load_target }.dup
 
         if owner.new_record?
           replace_records(other_array, original_target)
-        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating)
+        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
           replace_common_records_in_memory(other_array, original_target)
 
           # Remove from target
@@ -41,7 +43,7 @@ module ActiveRecord
       end
 
       def insert_record(record, validate = true, raise = false, &block)
-        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating)
+        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@sunstone_updating) && owner.instance_variable_get(:@sunstone_updating)
           true
         elsif raise
           record.save!(validate: validate, &block)
@@ -50,7 +52,6 @@ module ActiveRecord
         end
       end
 
-
     end
 
     class HasManyThroughAssociation
@@ -70,27 +71,3 @@ module ActiveRecord
 
   end
 end
-
-module ActiveRecord
-  module Persistence
-    
-    # Updates the attributes of the model from the passed-in hash and saves the
-    # record, all wrapped in a transaction. If the object is invalid, the saving
-    # will fail and false will be returned.
-    def update(attributes)
-      @updating = :updating
-      Thread.current[:sunstone_updating_model] = self
-      
-      # The following transaction covers any possible database side-effects of the
-      # attributes assignment. For example, setting the IDs of a child collection.
-      with_transaction_returning_status do
-        assign_attributes(attributes)
-        save
-      end
-    ensure
-      @updating = false
-      Thread.current[:sunstone_updating_model] = nil
-    end
-    
-  end
-end

data/ext/active_record/associations.rb

@@ -1,5 +1,9 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 require 'active_record'
 require 'active_record/associations'
+
 module ActiveRecord
   module Associations
     module ClassMethods
@@ -21,13 +25,13 @@ module ActiveRecord
 
         include Module.new {
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def destroy_associations
-            if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-              association(:#{middle_reflection.name}).delete_all(:delete_all)
-              association(:#{name}).reset
+            def destroy_associations
+              if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+                association(:#{middle_reflection.name}).delete_all(:delete_all)
+                association(:#{name}).reset
+              end
+              super
             end
-            super
-          end
           RUBY
         }
 
@@ -40,8 +44,8 @@ module ActiveRecord
         end
 
         has_many name, scope, **hm_options, &extension
-        _reflections[name.to_s].parent_reflection = habtm_reflection
+        _reflections[name].parent_reflection = habtm_reflection
       end
     end
   end
-end
+end

data/ext/active_record/attribute_methods.rb

@@ -1,14 +1,15 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module AttributeMethods
-    
+
     protected
-    
+
     # Returns a Hash of the Arel::Attributes and attribute values that have been
     # typecasted for use in an Arel insert/update method.
     def attributes_with_values(attribute_names)
-      attrs = attribute_names.index_with do |name|
-        _read_attribute(name)
-      end
+      attrs = attribute_names.index_with { |name| @attributes[name] }
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         self.class.reflect_on_all_associations.each do |reflection|
@@ -25,17 +26,17 @@ module ActiveRecord
           end
         end
       end
-      
+
       attrs
     end
-    
+
     def add_attributes_for_belongs_to_association(reflection, attrs)
       key = :"add_attributes_for_belongs_to_association_#{reflection.name}"
       @_already_called ||= {}
       return if @_already_called[key]
       @_already_called[key]=true
       @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
-      
+
       association = association_instance_get(reflection.name)
       record      = association && association.load_target
       if record && !record.destroyed?
@@ -51,14 +52,14 @@ module ActiveRecord
         end
       end
     end
-    
+
     def add_attributes_for_has_one_association(reflection, attrs)
       key = :"add_attributes_for_has_one_association#{reflection.name}"
       @_already_called ||= {}
       return if @_already_called[key]
       @_already_called[key]=true
       @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
-      
+
       association = association_instance_get(reflection.name)
       record      = association && association.load_target
 
@@ -80,7 +81,7 @@ module ActiveRecord
         end
       end
     end
-    
+
     def add_attributes_for_collection_association(reflection, attrs, arel_table=nil)
       key = :"add_attributes_for_collection_association#{reflection.name}"
       @_already_called ||= {}
@@ -106,7 +107,7 @@ module ActiveRecord
                 )
             end
           end
-        
+
           association.instance_variable_set(:@sunstone_changed, false)
         end
 
@@ -114,6 +115,6 @@ module ActiveRecord
         association.reset_scope if association.respond_to?(:reset_scope)
       end
     end
-    
+
   end
 end

data/ext/active_record/callbacks.rb

@@ -1,3 +1,6 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module Callbacks
     private
@@ -14,4 +17,4 @@ module ActiveRecord
       end
 
   end
-end
+end

data/ext/active_record/finder_methods.rb

@@ -1,14 +1,24 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   class PredicateBuilder # :nodoc:
 
     def expand_from_hash(attributes, &block)
       return ["1=0"] if attributes.empty?
-  
+
       attributes.flat_map do |key, value|
-        if value.is_a?(Hash) && !table.has_column?(key)
+        if key.is_a?(Array)
+          queries = Array(value).map do |ids_set|
+            raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
+            expand_from_hash(key.zip(ids_set).to_h)
+          end
+          grouping_queries(queries)
+        elsif value.is_a?(Hash) && !table.has_column?(key)
           ka = table.associated_table(key, &block)
-                 .predicate_builder.expand_from_hash(value.stringify_keys)
-          if self.send(:table).instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+            .predicate_builder.expand_from_hash(value.stringify_keys)
+
+          if self.table.instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             ka.each { |k|
               if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
                 k.left = Arel::Attributes::Relation.new(k.left, key)

data/ext/active_record/persistence.rb

@@ -6,10 +6,12 @@ module ActiveRecord
       def rpc(name)
         define_method("#{name}!") do
           req = Net::HTTP::Post.new("/#{self.class.table_name}/#{CGI.escape(id.to_s)}/#{CGI.escape(name.to_s)}")
-          self.class.connection.instance_variable_get(:@connection).send_request(req) do |response|
-            JSON.parse(response.body).each do |k,v|
-              if self.class.column_names.include?(k)
-                @attributes.write_from_database(k, v)
+          self.class.connection.send(:with_raw_connection) do |conn|
+            conn.send_request(req) do |response|
+              JSON.parse(response.body).each do |k,v|
+                if self.class.column_names.include?(k)
+                  @attributes.write_from_database(k, v)
+                end
               end
             end
           end
@@ -17,7 +19,25 @@ module ActiveRecord
         end
       end
     end
-    
+
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # record, all wrapped in a transaction. If the object is invalid, the saving
+    # will fail and false will be returned.
+    def update(attributes)
+      @sunstone_updating = :updating
+      Thread.current[:sunstone_updating_model] = self
+
+      # The following transaction covers any possible database side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save
+      end
+    ensure
+      @sunstone_updating = false
+      Thread.current[:sunstone_updating_model] = nil
+    end
+
     def update!(attributes)
       @no_save_transaction = true
       with_transaction_returning_status do
@@ -33,14 +53,14 @@ module ActiveRecord
     def create_or_update(**, &block)
       _raise_readonly_record_error if readonly?
       return false if destroyed?
-      
-      @updating = new_record? ? :creating : :updating
+
+      @sunstone_updating = new_record? ? :creating : :updating
       Thread.current[:sunstone_updating_model] = self
 
       result = new_record? ? _create_record(&block) : _update_record(&block)
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
-        row_hash = result.rows.first
+        row_hash = result[0]
 
         seen = Hash.new { |h, parent_klass|
           h[parent_klass] = Hash.new { |i, parent_id|
@@ -51,10 +71,13 @@ module ActiveRecord
         model_cache = Hash.new { |h,klass| h[klass] = {} }
         parents = model_cache[self.class.base_class]
         
-        self.assign_attributes(row_hash.select{|k,v| self.class.column_names.include?(k.to_s) })
-        row_hash.select{|k,v| !self.class.column_names.include?(k.to_s) }.each do |relation_name, value|
-          assc = association(relation_name.to_sym)
-          assc.reset if assc.reflection.collection?
+        row_hash.each do |key, value|
+          if self.class.column_names.include?(key.to_s)
+            _write_attribute(key, value)
+          else
+            assc = association(key.to_sym)
+            assc.reset if assc.reflection.collection? # TODO: can load here if included
+          end
         end
 
         construct(self, row_hash.select{|k,v| !self.class.column_names.include?(k.to_s) }, seen, model_cache)
@@ -72,39 +95,54 @@ module ActiveRecord
       end
       raise ActiveRecord::RecordInvalid
     ensure
-      @updating = false
+      @sunstone_updating = false
       Thread.current[:sunstone_updating_model] = nil
     end
-    
+
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def _create_record(attribute_names = self.attribute_names)
       attribute_names = attributes_for_create(attribute_names)
-      attributes_values = attributes_with_values(attribute_names)
+      attribute_values = attributes_with_values(attribute_names)
+      returning_values = nil
       
-      new_id = self.class._insert_record(attributes_values)
+      self.class.with_connection do |connection|
+        returning_columns = self.class._returning_columns_for_insert(connection)
+
+        returning_values = self.class._insert_record(
+          connection,
+          attribute_values,
+          returning_columns
+        )
+
+        if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+          returning_columns.zip(returning_values).each do |column, value|
+            _write_attribute(column, value) if !_read_attribute(column)
+          end if returning_values
+        end
+      end
 
-      self.id ||= new_id if @primary_key
       @new_record = false
       @previously_new_record = true
       
       yield(self) if block_given?
       
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-        new_id
+        returning_values
       else
         id
       end
     end
-    
+
     def _update_record(attribute_names = self.attribute_names)
+      attribute_names = attributes_for_update(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
 
       if attribute_values.empty?
         affected_rows = 0
         @_trigger_update_callback = true
       else
-        affected_rows = self.class._update_record( attribute_values, self.class.primary_key => id_in_database )
+        affected_rows = self.class._update_record(attribute_values, _query_constraints_hash)
         @_trigger_update_callback = affected_rows == 1
       end
 

data/ext/active_record/relation/calculations.rb

@@ -1,11 +1,27 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module Calculations
-    
+
     def pluck(*column_names)
+      if @none
+        if @async
+          return Promise::Complete.new([])
+        else
+          return []
+        end
+      end
+
       if loaded? && all_attributes?(column_names)
-        return records.pluck(*column_names)
+        result = records.pluck(*column_names)
+        if @async
+          return Promise::Complete.new(result)
+        else
+          return result
+        end
       end
-      
+
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
@@ -13,18 +29,22 @@ module ActiveRecord
         load
         return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{klass.table_name}\./, "")})
       else
-        klass.disallow_raw_sql!(column_names)
+        klass.disallow_raw_sql!(flattened_args(column_names))
         columns = arel_columns(column_names)
         relation = spawn
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?
-            ActiveRecord::Result.empty
+            ActiveRecord::Result.empty(async: @async)
           else
-            klass.connection.select_all(relation.arel, "#{klass.name} Pluck")
+            klass.with_connection do |c|
+              c.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            end
           end
         end
-        type_cast_pluck_values(result, columns)
+        result.then do |result|
+          type_cast_pluck_values(result, columns)
+        end
       end
     end
 

data/ext/active_record/relation/query_methods.rb

@@ -1,9 +1,11 @@
 module ActiveRecord
   module QueryMethods
     private
-      def assert_mutability!
-        raise ImmutableRelation if @loaded
-        raise ImmutableRelation if defined?(@arel) && @arel && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-      end
+
+    def assert_modifiable!
+      raise UnmodifiableRelation if @loaded
+      raise UnmodifiableRelation if @arel && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+    end
+
   end
 end

data/ext/active_record/transactions.rb

@@ -34,23 +34,25 @@ module ActiveRecord
     # end
 
     def with_transaction_returning_status
-      status = nil
-      connection = self.class.connection
-      
-      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
-        status = yield
-      else
-        ensure_finalize = !connection.transaction_open?
-        connection.transaction do
-          add_to_transaction(ensure_finalize || has_transactional_callbacks?)
-          remember_transaction_record_state
+      self.class.with_connection do |connection|
+        status = nil
+        # connection = self.class.connection
 
+        if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
           status = yield
-          raise ActiveRecord::Rollback unless status
+        else
+          ensure_finalize = !connection.transaction_open?
+          connection.transaction do
+            add_to_transaction(ensure_finalize || has_transactional_callbacks?)
+            remember_transaction_record_state
+
+            status = yield
+            raise ActiveRecord::Rollback unless status
+          end
         end
-      end
       
-      status
+        status
+      end
     end
 
 

data/lib/active_record/connection_adapters/sunstone/column.rb

@@ -2,6 +2,8 @@ module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
     class SunstoneColumn < Column #:nodoc:
+      NONE = Object.new
+
       attr_reader :array
       
       def initialize(name, sql_type_metadata, options={})
@@ -14,12 +16,20 @@ module ActiveRecord
         @table_name = nil
         @primary_key = (options['primary_key'] == true)
         @array = options['array']
+        @auto_populated = options.has_key?('auto_populated') ? options['auto_populated'] : NONE
       end
       
       def primary_key?
         @primary_key
       end
       
+      def auto_populated?
+        # TODO: when retuning is working we can do the following to only
+        # return autopulated fields from StandardAPI
+        # @auto_populated == NONE ? @primary_key : @auto_populated
+        true
+      end
+      
     end
   end
 end

data/lib/active_record/connection_adapters/sunstone/database_statements.rb

@@ -25,22 +25,34 @@ module ActiveRecord
           else
             sar = arel_or_sar_string
           end
+
           sar.compile(binds)
         end
         
-        def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil) # :nodoc:
+        def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil, allow_retry = false)
           if arel_or_sar_string.respond_to?(:ast)
+            arel_or_sar_string = arel_or_sar_string.ast
+          end
+
+          if Arel.arel_node?(arel_or_sar_string) && !(String === arel_or_sar_string)
             unless binds.empty?
               raise "Passing bind parameters with an arel AST is forbidden. " \
                 "The values must be stored on the AST directly"
             end
-            sar = visitor.accept(arel_or_sar_string.ast, collector)
-            [sar.freeze, sar.binds, false]
+            
+            sar = visitor.accept(arel_or_sar_string, collector)
+            [sar.freeze, sar.binds, false, allow_retry]
           else
-            [arel_or_sar_string.dup.freeze, binds, false]
+            [arel_or_sar_string.dup.freeze, binds, false, allow_retry]
           end
         end
         
+        def sar_for_insert(sql, pk, binds, returning)
+          # TODO: when StandardAPI supports returning we can do this; it might
+          # already need to investigate
+          to_sar_and_binds(sql, binds)
+        end
+        
         # This is used in the StatementCache object. It returns an object that
         # can be used to query the database repeatedly.
         def cacheable_query(klass, arel) # :nodoc:
@@ -77,14 +89,33 @@ module ActiveRecord
         end
 
         # Returns an ActiveRecord::Result instance.
-        def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
+        def select_all(arel, name = nil, binds = [], preparable: nil, async: false, allow_retry: false)
           arel = arel_from_relation(arel)
-          sar, binds, preparable = to_sar_and_binds(arel, binds, preparable)
-          
-          select(sar, name, binds, prepare: prepared_statements && preparable, async: async && FutureResult::SelectAll)
+          sar, binds, preparable, allow_retry = to_sar_and_binds(arel, binds, preparable, allow_retry)
+
+          select(sar, name, binds,
+            prepare: prepared_statements && preparable,
+            async: async && FutureResult::SelectAll,
+            allow_retry: allow_retry
+          )
+        rescue ::RangeError
+          ActiveRecord::Result.empty(async: async)
+        end
+        
+        # Executes insert +sql+ statement in the context of this connection using
+        # +binds+ as the bind substitutes. +name+ is logged along with
+        # the executed +sql+ statement.
+        # Some adapters support the `returning` keyword argument which allows to control the result of the query:
+        # `nil` is the default value and maintains default behavior. If an array of column names is passed -
+        # the result will contain values of the specified columns from the inserted row.
+        #
+        # TODO: Add support for returning
+        def exec_insert(arel, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
+          sar, binds = sar_for_insert(arel, pk, binds, returning)
+          internal_exec_query(sar, name, binds)
         end
 
-        def exec_query(arel, name = 'SAR', binds = [], prepare: false)
+        def internal_exec_query(arel, name = 'SAR', binds = [], prepare: false, async: false, allow_retry: false)
           sars = []
           multiple_requests = arel.is_a?(Arel::Collectors::Sunstone)
           type_casted_binds = binds#type_casted_binds(binds)
@@ -112,11 +143,13 @@ module ActiveRecord
             sars.push(sar)
             log_mess = sar.path.split('?', 2)
             log("#{sar.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }", name) do
-              response = @connection.send_request(sar)
-              if response.is_a?(Net::HTTPNoContent)
-                nil
-              else
-                JSON.parse(response.body)
+              with_raw_connection do |conn|
+                response = conn.send_request(sar)
+                if response.is_a?(Net::HTTPNoContent)
+                  nil
+                else
+                  JSON.parse(response.body)
+                end
               end
             end
           }
@@ -141,21 +174,21 @@ module ActiveRecord
           
           if sars[0].instance_variable_defined?(:@sunstone_calculation) && sars[0].instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
-            ActiveRecord::Result.new(['all'], [result], {:all => type_map.lookup('integer', {})})
+            ActiveRecord::Result.new(['all'], [result], {:all => @type_map.lookup('integer', {})})
           elsif result.is_a?(Array)
             ActiveRecord::Result.new(result[0] ? result[0].keys : [], result.map{|r| r.values})
           else
-            ActiveRecord::Result.new(result.keys, [result])
+            ActiveRecord::Result.new(result.keys, [result.values])
           end
         end
         
-        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+        def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [], returning: nil)
           sar, binds = to_sar_and_binds(arel, binds)
-          value = exec_insert(sar, name, binds, pk, sequence_name)
+          value = exec_insert(sar, name, binds, pk, sequence_name, returning: returning)
+
+          return returning_column_values(value) unless returning.nil?
+
           id_value || last_inserted_id(value)
-          
-          # value = exec_insert(arel, name, binds, pk, sequence_name)
-          # id_value || last_inserted_id(value)
         end
         
         def update(arel, name = nil, binds = [])
@@ -171,6 +204,10 @@ module ActiveRecord
           row && row['id']
         end
 
+        def returning_column_values(result)
+          result.rows.first
+        end
+
       end
     end
   end