sunstone 8.0.0 → 8.1.0

data/ext/active_record/persistence.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
 module ActiveRecord
   # = Active Record \Persistence
   module Persistence
@@ -59,7 +64,7 @@ module ActiveRecord
 
       result = new_record? ? _create_record(&block) : _update_record(&block)
 
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
+      if self.sunstone? && result != 0 && !result[0].nil?
         row_hash = result[0]
 
         seen = Hash.new { |h, parent_klass|
@@ -70,7 +75,7 @@ module ActiveRecord
 
         model_cache = Hash.new { |h,klass| h[klass] = {} }
         parents = model_cache[self.class.base_class]
-        
+
         row_hash.each do |key, value|
           if self.class.column_names.include?(key.to_s)
             _write_attribute(key, value)
@@ -105,7 +110,7 @@ module ActiveRecord
       attribute_names = attributes_for_create(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
       returning_values = nil
-      
+
       self.class.with_connection do |connection|
         returning_columns = self.class._returning_columns_for_insert(connection)
 
@@ -115,25 +120,41 @@ module ActiveRecord
           returning_columns
         )
 
-        if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        if !self.sunstone?
           returning_columns.zip(returning_values).each do |column, value|
-            _write_attribute(column, value) if !_read_attribute(column)
+            _write_attribute(column, type_for_attribute(column).deserialize(value)) if !_read_attribute(column)
           end if returning_values
         end
       end
 
       @new_record = false
       @previously_new_record = true
-      
+
       yield(self) if block_given?
-      
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+
+      if self.sunstone?
         returning_values
       else
         id
       end
     end
 
+    def _touch_row(attribute_names, time)
+      time ||= current_time_from_proper_timezone
+
+      attribute_names.each do |attr_name|
+        _write_attribute(attr_name, time)
+      end
+
+      _update_row(attributes_with_values(attribute_names), "touch")
+    end
+
+    # Sunstone passes the values, not just the names. This is because if a
+    # sub resource has changed it'll send the whole shabang
+    def _update_row(attribute_values, attempted_action = "update")
+      self.class._update_record(attribute_values, _query_constraints_hash)
+    end
+
     def _update_record(attribute_names = self.attribute_names)
       attribute_names = attributes_for_update(attribute_names)
       attribute_values = attributes_with_values(attribute_names)
@@ -142,8 +163,10 @@ module ActiveRecord
         affected_rows = 0
         @_trigger_update_callback = true
       else
-        affected_rows = self.class._update_record(attribute_values, _query_constraints_hash)
-        @_trigger_update_callback = affected_rows == 1
+        affected_rows = _update_row(attribute_values)
+
+        # Suntone returns the row(s) not a int of afftecd_rows
+        @_trigger_update_callback = (sunstone? ? affected_rows.rows.size : affected_rows) == 1
       end
 
       @previously_new_record = false
@@ -179,7 +202,7 @@ module ActiveRecord
 
       end
     end
-    
+
     #!!!! TODO: I am duplicated from finder_methods.....
     def construct_association(parent, reflection, attributes, seen, model_cache)
       return if attributes.nil?
@@ -231,6 +254,6 @@ module ActiveRecord
       other.set_inverse_instance(model)
       model
     end
-    
+
   end
 end

data/ext/active_record/relation/calculations.rb

@@ -1,30 +1,11 @@
+# frozen_string_literal: true
+
 # The last ref that this code was synced with Rails
-# ref: 9269f634d471ad6ca46752421eabd3e1c26220b5
+# ref: 90a1eaa1b3
 
 module ActiveRecord
   module Calculations
 
-    # Prior to Rails 8 we didn't need this method becuase it would
-    # return the first value if there was just one - so we'll just
-    # do the same as prevously because it doesn't have to be joined
-    def select_for_count
-      if select_values.empty?
-        :all
-      else
-        with_connection do |conn|
-          # Rails compiles this to a string, but we don't have string we
-          # have a hash
-          if model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-            sv = arel_columns(select_values)
-            sv.one? ? sv.first : sv
-          else
-            sv = arel_columns(select_values).map { |column| conn.visitor.compile(column) } 
-            sv.one? ? sv.first : sv.join(", ")
-          end
-        end
-      end
-    end
-
     def pluck(*column_names)
       if @none
         if @async
@@ -46,7 +27,7 @@ module ActiveRecord
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
-      elsif model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      elsif model.sunstone?
         load
         return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{model.table_name}\./, "")})
       else
@@ -55,7 +36,11 @@ module ActiveRecord
         columns = relation.arel_columns(column_names)
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
-          if where_clause.contradiction?
+          # TODO: drop this Rails 8.0 compatibility guard when Rails 8.0 support is
+          # dropped, and call possible_aggregation?(column_names) directly.
+          # possible_aggregation? was added in Rails 8.1; on 8.0 a contradiction
+          # short-circuits to an empty result unconditionally.
+          if where_clause.contradiction? && !(respond_to?(:possible_aggregation?, true) && possible_aggregation?(column_names))
             ActiveRecord::Result.empty(async: @async)
           else
             model.with_connection do |c|
@@ -69,5 +54,22 @@ module ActiveRecord
       end
     end
 
+    private
+
+      # Prior to Rails 8 we didn't need this method becuase it would
+      # return the first value if there was just one - so we'll just
+      # do the same as prevously because it doesn't have to be joined
+      def select_for_count
+        if select_values.empty?
+          :all
+        elsif model.sunstone?
+          select_values.one? ? select_values.first : select_values
+        else
+          with_connection do |conn|
+            arel_columns(select_values).map { |column| conn.visitor.compile(column) }.join(", ")
+          end
+        end
+      end
+    
   end
 end

data/ext/active_record/relation/finder_methods.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
+module ActiveRecord::FinderMethods
+  class SunstoneJoinDependency
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def reflections
+      []
+    end
+    
+    def apply_column_aliases(relation)
+      relation
+    end
+    
+    def instantiate(result_set, strict_loading_value, &block)
+      seen = Hash.new { |i, object_id|
+        i[object_id] = Hash.new { |j, child_class|
+          j[child_class] = {}
+        }
+      }
+
+      model_cache = Hash.new { |h, klass| h[klass] = {} }
+      parents = model_cache[@klass]
+
+      message_bus = ActiveSupport::Notifications.instrumenter
+
+      payload = {
+        record_count: result_set.length,
+        class_name: @klass.name
+      }
+
+      message_bus.instrument("instantiation.active_record", payload) do
+        result_set.each { |row_hash|
+          parent_key = @klass.primary_key ? row_hash[@klass.primary_key] : row_hash
+          parent = parents[parent_key] ||= @klass.instantiate(row_hash.select{|k,v| @klass.column_names.include?(k.to_s) }, &block)
+          construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+        }
+      end
+
+      parents.values
+    end
+
+    def construct(parent, relations, seen, model_cache, strict_loading_value)
+      relations.each do |key, attributes|
+        reflection = parent.class.reflect_on_association(key)
+        next unless reflection
+
+        if reflection.collection?
+          other = parent.association(reflection.name)
+          other.loaded!
+        else
+          if parent.association_cached?(reflection.name)
+            model = parent.association(reflection.name).target
+            construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+          end
+        end
+
+        if !reflection.collection?
+          construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
+        else
+          attributes.each do |row|
+            construct_association(parent, reflection, row, seen, model_cache, strict_loading_value)
+          end
+        end
+
+      end
+    end
+
+    def construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
+      return if attributes.nil?
+
+      klass = if reflection.polymorphic?
+        parent.send(reflection.foreign_type).constantize.base_class
+      else
+        reflection.klass
+      end
+      id = attributes[klass.primary_key]
+      model = seen[parent.object_id][klass][id]
+
+      if model
+        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+
+        other = parent.association(reflection.name)
+
+        if reflection.collection?
+          other.target.push(model)
+        else
+          other.target = model
+        end
+
+        other.set_inverse_instance(model)
+      else
+        model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+        seen[parent.object_id][model.class.base_class][id] = model
+        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
+      end
+    end
+
+
+    def construct_model(record, reflection, id, attributes, seen, model_cache, strict_loading_value)
+      klass = if reflection.polymorphic?
+        record.send(reflection.foreign_type).constantize
+      else
+        reflection.klass
+      end
+
+      model = model_cache[klass][id] ||= klass.instantiate(attributes)
+      other = record.association(reflection.name)
+
+      if reflection.collection?
+        other.target.push(model)
+      else
+        other.target = model
+      end
+
+      other.set_inverse_instance(model)
+      model
+    end
+
+  end
+
+  private
+
+    def apply_join_dependency(eager_loading: group_values.empty?)
+      if model.sunstone?
+        join_dependency = SunstoneJoinDependency.new(base_class)
+        relation = except(:includes, :eager_load, :preload)
+        relation.arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
+      else
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
+        relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
+
+        if eager_loading && has_limit_or_offset? && !(
+            using_limitable_reflections?(join_dependency.reflections) &&
+            using_limitable_reflections?(
+              construct_join_dependency(
+                select_association_list(joins_values).concat(
+                  select_association_list(left_outer_joins_values)
+                ), nil
+              ).reflections
+            )
+          )
+          relation = skip_query_cache_if_necessary do
+            model.with_connection do |c|
+              c.distinct_relation_for_primary_key(relation)
+            end
+          end
+        end
+      end
+
+      if block_given?
+        yield relation, join_dependency
+      else
+        relation
+      end
+    end
+  
+end

data/ext/active_record/relation/predicate_builder.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
+class ActiveRecord::PredicateBuilder # :nodoc:
+
+  def expand_from_hash(attributes, &block)
+    return [Arel.sql("1=0", retryable: true)] if attributes.empty?
+
+    attributes.flat_map do |key, value|
+      if key.is_a?(Array) && key.size == 1
+        key = key.first
+        value = value.flatten
+      end
+      
+      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).sunstone?
+          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)
+            end
+          }
+        end
+        ka
+      # TODO: drop this Rails 8.0 compatibility branch when Rails 8.0 support is
+      # dropped, and always use table.associated_with(key). (8.0 named it associated_with?)
+      elsif (associated_reflection = (table.respond_to?(:associated_with) ? table.associated_with(key) : table.associated_with?(key)))
+        # Find the foreign key when using queries such as:
+        # Post.where(author: author)
+        #
+        # For polymorphic relationships, find the foreign key and type:
+        # PriceEstimate.where(estimate_of: treasure)
+
+        if associated_reflection.polymorphic?
+          value = [value] unless value.is_a?(Array)
+          klass = PolymorphicArrayValue
+        elsif associated_reflection.through_reflection?
+          associated_table = table.associated_table(key)
+          
+          next associated_table.predicate_builder.expand_from_hash(
+            associated_table.primary_key => value
+          )
+        end
+
+        klass ||= AssociationQueryValue
+        # TODO: drop this Rails 8.0 compatibility branch when Rails 8.0 support is
+        # dropped, and always pass associated_reflection.
+        # Rails 8.1 threads the reflection through the value objects; 8.0 threads the table metadata.
+        query_source = table.respond_to?(:associated_with) ? associated_reflection : table.associated_table(key)
+        queries = klass.new(query_source, value).queries.map! do |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)
+      elsif table.aggregated_with?(key)
+        mapping = table.reflect_on_aggregation(key).mapping
+        values = value.nil? ? [nil] : Array.wrap(value)
+        if mapping.length == 1 || values.empty?
+          column_name, aggr_attr = mapping.first
+          values = values.map do |object|
+            object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+          end
+          self[column_name, values]
+        else
+          queries = values.map do |object|
+            mapping.map do |field_attr, aggregate_attr|
+              self[field_attr, object.try!(aggregate_attr)]
+            end
+          end
+
+          grouping_queries(queries)
+        end
+      else
+        self[key, value]
+      end
+    end
+  end
+
+end

data/ext/active_record/relation/query_methods.rb

@@ -1,10 +1,15 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
 module ActiveRecord
   module QueryMethods
     private
 
     def assert_modifiable!
       raise UnmodifiableRelation if @loaded
-      raise UnmodifiableRelation if @arel && !model.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+      raise UnmodifiableRelation if @arel && !model.sunstone?
     end
 
   end

data/ext/active_record/relation.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
 module ActiveRecord
   class Relation
 

data/ext/active_record/statement_cache.rb

@@ -1,8 +1,16 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
 module ActiveRecord
   class StatementCache
     class PartialQuery
 
-      def initialize(values, sunstone=false)
+      # TODO: drop this Rails 8.0 compatibility default when Rails 8.0 support is
+      # dropped, and make retryable: a required keyword again.
+      # retryable: is required on Rails 8.1 but absent from 8.0's caller.
+      def initialize(values, retryable: false, sunstone: false)
         @values = values
         @indexes = if sunstone
         else
@@ -10,8 +18,9 @@ module ActiveRecord
             Substitute === thing
           }.map(&:last)
         end
+        @retryable = retryable
       end
-
+      
       def sql_for(binds, connection)
         if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
           @values
@@ -29,6 +38,5 @@ module ActiveRecord
       end
 
     end
-
   end
 end

data/ext/active_record/transactions.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+# The last ref that this code was synced with Rails
+# ref: 90a1eaa1b3
+
 require 'active_record'
 require 'active_record/transactions'
 
@@ -35,26 +40,35 @@ module ActiveRecord
 
     def with_transaction_returning_status
       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
-        else
-          ensure_finalize = !connection.transaction_open?
-          connection.transaction do
-            add_to_transaction(ensure_finalize || has_transactional_callbacks?)
-            remember_transaction_record_state
+        transaction_body = proc do
+          status = nil
 
+          if sunstone? && 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
+            @_last_transaction_return_status = status
+            status
           end
         end
-      
-        status
+
+        # TODO: drop this Rails 8.0 compatibility branch when Rails 8.0
+        # support is dropped, and always use with_pool_transaction_isolation_level.
+        # Rails 8.1 wraps the transaction in a pool-level isolation context;
+        # this API doesn't exist on 8.0, so run the body directly there.
+        if ActiveRecord.respond_to?(:default_transaction_isolation_level)
+          connection.pool.with_pool_transaction_isolation_level(ActiveRecord.default_transaction_isolation_level, connection.transaction_open?, &transaction_body)
+        else
+          transaction_body.call
+        end
       end
     end
-
-
   end
 end

data/ext/active_support/core_ext/object/to_query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class NilClass
   
   def to_query(namespace)

data/ext/arel/attributes/empty_relation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # module Arel
 #   module Attributes
 #     class EmptyRelation < Attribute

data/ext/arel/nodes/eager_load.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Arel
   module Nodes
     class EagerLoad < Arel::Nodes::Unary

data/ext/arel/nodes/select_statement.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Arel
   module Nodes
     class SelectStatement < Arel::Nodes::NodeExpression

data/ext/arel/select_manager.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Arel
   class SelectManager < Arel::TreeManager
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
@@ -6,8 +8,9 @@ module ActiveRecord
 
       attr_reader :array
       
-      def initialize(name, sql_type_metadata, options={})
+      def initialize(name, cast_type, sql_type_metadata, options={})
         @name = name.freeze
+        @cast_type = cast_type
         @sql_type_metadata = sql_type_metadata
         @null = options['null']
         @default = options['default'] ? JSON.generate(options['default']) : options['default']

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "arel/collectors/sql_string"
 
 module ActiveRecord
@@ -66,7 +68,7 @@ module ActiveRecord
           elsif self.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
             collector = SunstonePartialQueryCollector.new(self.collector)
             parts, binds = visitor.compile(arel.ast, collector)
-            query = StatementCache::PartialQuery.new(parts, true)
+            query = StatementCache::PartialQuery.new(parts, retryable: collector.retryable, sunstone: true)
           else
             collector = klass.partial_query_collector
             parts, binds = visitor.compile(arel.ast, collector)
@@ -118,6 +120,11 @@ module ActiveRecord
           sar, binds = sar_for_insert(arel, pk, binds, returning)
           internal_exec_query(sar, name, binds)
         end
+        
+        def exec_delete(arel, name = nil, binds = [])
+          x = internal_execute(arel, name, binds)
+          x.nil? ? 1 : x
+        end
 
         # Lowest level way to execute a query. Doesn't check for illegal writes, doesn't annotate queries, yields a native result object.
         def raw_execute(arel, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
@@ -240,6 +247,10 @@ module ActiveRecord
           result.rows.first
         end
 
+        def write_query?(arel)
+          arel.request_type != Net::HTTP::Get
+        end
+
       end
     end
   end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module Sunstone

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module Sunstone