sunstone 6.1.3 → 7.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67c26e8a4275aa67d9e09b43cfce417732142a043b6ca49d2c1e85bbfb74950d
-  data.tar.gz: a46c586fe763e9d90029a007074919fca9e997efa8ddddf57588136d6cb2b883
+  metadata.gz: 3956ea045dce2994b10bcac8535462bdf08597b85d7e15fc325110149a576aa6
+  data.tar.gz: 02be730df372f32557112e9fb618befb5aafd7a8ef15ce1e12a866f8c18c2ed7
 SHA512:
-  metadata.gz: 1fd7cb872485fa5507d1bcb21e28e81d92b807279fbdbf12440a74de32cd39c4584c42e6f0ea1fd371261a3c614358967d94c1abc30bb304b2364bb8ae7e9dab
-  data.tar.gz: 3d3105125dfaad25f7884648406444ca3a4dab3e2782b482659179ca8a484ce52bded0222af6b48210ad7f0f00c901ca92a3e780380b22d4b62cb3e3c57019f8
+  metadata.gz: c978ff5919d301007ccd326a632ed915cce129584e0ff9c25c199bddb9a65e517361f95a7d3a8af4ea70546acd1bb16fbc1118ff050a0c209f4168f9ec71feb9
+  data.tar.gz: 3a24f347b5ca8ccf2816e8d50a28ca3effedea79a897ab3692801b5cd8095d9fc324f37f792ffba621a9669eb7ea92f58be762b62d2a1e9096a9306fc1d46be9

data/ext/active_record/associations/collection_association.rb

@@ -1,3 +1,5 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
 module ActiveRecord
   module Associations
     class CollectionAssociation
@@ -8,7 +10,7 @@ module ActiveRecord
 
         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)
@@ -70,27 +72,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
@@ -44,4 +48,4 @@ module ActiveRecord
       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 ||= {}
@@ -97,10 +98,16 @@ module ActiveRecord
             []
           else
             association.target.select { |r| !r.destroyed? }.map do |record|
-              record.send(:attributes_with_values, record.send(:attribute_names_for_partial_writes) + (record.new_record? ? [] : [record.class.primary_key]))
+              record.send(
+                :attributes_with_values,
+                record.new_record? ?
+                  record.send(:attribute_names_for_partial_inserts)
+                  :
+                  record.send(:attribute_names_for_partial_updates) + [record.class.primary_key]
+                )
             end
           end
-        
+
           association.instance_variable_set(:@sunstone_changed, false)
         end
 
@@ -108,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,13 +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)
-          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)
+        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.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)
@@ -23,11 +34,8 @@ module ActiveRecord
           # PriceEstimate.where(estimate_of: treasure)
           associated_table = table.associated_table(key)
           if associated_table.polymorphic_association?
-            case value.is_a?(Array) ? value.first : value
-            when Base, Relation
-              value = [value] unless value.is_a?(Array)
-              klass = PolymorphicArrayValue
-            end
+            value = [value] unless value.is_a?(Array)
+            klass = PolymorphicArrayValue
           elsif associated_table.through_association?
             next associated_table.predicate_builder.expand_from_hash(
               associated_table.primary_key => value
@@ -36,7 +44,9 @@ module ActiveRecord
 
           klass ||= AssociationQueryValue
           queries = klass.new(associated_table, value).queries.map! do |query|
-            expand_from_hash(query)
+            # If the query produced is identical to attributes don't go any deeper.
+            # Prevents stack level too deep errors when association and foreign_key are identical.
+            query == attributes ? self[key, value] : expand_from_hash(query)
           end
 
           grouping_queries(queries)
@@ -202,7 +212,7 @@ module ActiveRecord
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
       end
 
-      if eager_loading && !(
+      if eager_loading && has_limit_or_offset? && !(
           using_limitable_reflections?(join_dependency.reflections) &&
           using_limitable_reflections?(
             construct_join_dependency(
@@ -211,12 +221,12 @@ module ActiveRecord
               ), nil
             ).reflections
           )
-      )
-        if has_limit_or_offset? && !connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-          limited_ids = limited_ids_for(relation)
-          limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)
+        )
+        if !connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+          relation = skip_query_cache_if_necessary do
+            klass.connection.distinct_relation_for_primary_key(relation)
+          end
         end
-        relation.limit_value = relation.offset_value = nil
       end
 
       if block_given?

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,36 +95,50 @@ 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 &= self.class.column_names
-      attributes_values = attributes_with_values(attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+      attribute_values = attributes_with_values(attribute_names)
+
+      returning_columns = self.class._returning_columns_for_insert
 
-      new_id = self.class._insert_record(attributes_values)
+      returning_values = self.class._insert_record(
+        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
 
       @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
-        self.id ||= new_id if self.class.primary_key
         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,8 +1,11 @@
+# The last ref that this code was synced with Rails
+# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+
 module ActiveRecord
   module Calculations
-    
+
     def pluck(*column_names)
-      if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
+      if loaded? && all_attributes?(column_names)
         return records.pluck(*column_names)
       end
       
@@ -14,10 +17,17 @@ module ActiveRecord
         return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{klass.table_name}\./, "")})
       else
         klass.disallow_raw_sql!(column_names)
+        columns = arel_columns(column_names)
         relation = spawn
-        relation.select_values = column_names
-        result = skip_query_cache_if_necessary { klass.connection.select_all(relation.arel, nil) }
-        result.cast_values(klass.attribute_types)
+        relation.select_values = columns
+        result = skip_query_cache_if_necessary do
+          if where_clause.contradiction?
+            ActiveRecord::Result.empty
+          else
+            klass.connection.select_all(relation.arel, "#{klass.name} Pluck")
+          end
+        end
+        type_cast_pluck_values(result, columns)
       end
     end
 

data/ext/active_record/relation/query_methods.rb

@@ -3,7 +3,7 @@ module ActiveRecord
     private
       def assert_mutability!
         raise ImmutableRelation if @loaded
-        raise ImmutableRelation if defined?(@arel) && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && @arel
+        raise ImmutableRelation if defined?(@arel) && @arel && !klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
       end
   end
 end

data/ext/active_record/statement_cache.rb

@@ -14,7 +14,6 @@ module ActiveRecord
 
       def sql_for(binds, connection)
         if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-          binds.map!(&:value_for_database)
           @values
         else
           val = @values.dup

data/ext/active_record/transactions.rb

@@ -36,8 +36,8 @@ module ActiveRecord
     def with_transaction_returning_status
       status = nil
       connection = self.class.connection
-      
-      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
+
+      if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@sunstone_updating) && @sunstone_updating
         status = yield
       else
         ensure_finalize = !connection.transaction_open?

data/ext/arel/nodes/select_statement.rb

@@ -4,9 +4,9 @@ module Arel
 
       attr_accessor :eager_load
 
-      def initialize(cores = [SelectCore.new])
+      def initialize(relation = nil)
         super()
-        @cores          = cores
+        @cores          = [SelectCore.new(relation)]
         @orders         = []
         @limit          = nil
         @lock           = nil
@@ -36,7 +36,7 @@ module Arel
           self.with == other.with &&
           self.eager_load == other.eager_load
       end
-
+      alias :== :eql?
     end
   end
 end

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

@@ -2,24 +2,34 @@ 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={})
         @name = name.freeze
         @sql_type_metadata = sql_type_metadata
         @null = options['null']
-        @default = (sql_type_metadata.type == :json ? JSON.generate(options['default']) : options['default'])
+        @default = options['default'] ? JSON.generate(options['default']) : options['default']
         @default_function = nil
         @collation = nil
         @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,24 +25,35 @@ module ActiveRecord
           else
             sar = arel_or_sar_string
           end
+
           sar.compile(binds)
         end
         
-        def to_sar_and_binds(arel_or_sar_string, binds = []) # :nodoc:
+        def to_sar_and_binds(arel_or_sar_string, binds = [], preparable = nil) # :nodoc:
+          # Arel::TreeManager -> Arel::Node
           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)
-            # puts ['a', sar.freeze, sar.binds].map(&:inspect)
-            [sar.freeze, sar.binds]
+            
+            sar = visitor.accept(arel_or_sar_string, collector)
+            [sar.freeze, sar.binds, false]
           else
-            # puts ['b',arel_or_sar_string.dup.freeze, binds].map(&:inspect)
-            [arel_or_sar_string.dup.freeze, binds]
+            [arel_or_sar_string.dup.freeze, binds, false]
           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:
@@ -79,13 +90,29 @@ module ActiveRecord
         end
 
         # Returns an ActiveRecord::Result instance.
-        def select_all(arel, name = nil, binds = [], preparable: nil)
+        def select_all(arel, name = nil, binds = [], preparable: nil, async: false)
           arel = arel_from_relation(arel)
-          sar, binds = to_sar_and_binds(arel, binds)
-          select(sar, name, binds)
+          sar, binds, preparable = to_sar_and_binds(arel, binds, preparable)
+
+          select(sar, name, binds, prepare: prepared_statements && preparable, async: async && FutureResult::SelectAll)
+        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, materialize_transactions: true)
           sars = []
           multiple_requests = arel.is_a?(Arel::Collectors::Sunstone)
           type_casted_binds = binds#type_casted_binds(binds)
@@ -96,7 +123,7 @@ module ActiveRecord
             requested_limit = if limit_bind_index
               type_casted_binds[limit_bind_index]
             else
-              arel.limit&.value&.value_for_database
+              arel.limit
             end
 
             if allowed_limit.nil?
@@ -113,11 +140,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
           }
@@ -142,21 +171,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 = [])
           sar, binds = to_sar_and_binds(arel, binds)
           value = exec_insert(sar, name, binds, pk, sequence_name)
+
+          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 = [])
@@ -172,6 +201,10 @@ module ActiveRecord
           row && row['id']
         end
 
+        def returning_column_values(result)
+          result.rows.first
+        end
+
       end
     end
   end