sunstone 5.1.0.4 → 5.2.1

data/ext/active_record/persistence.rb

@@ -14,12 +14,14 @@ module ActiveRecord
     
     private
 
-    def create_or_update(*args)
+    def create_or_update(*args, &block)
+      _raise_readonly_record_error if readonly?
+      return false if destroyed?
+      
       @updating = new_record? ? :creating : :updating
       Thread.current[:sunstone_updating_model] = self
 
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
-      result = new_record? ? _create_record : _update_record(*args)
+      result = new_record? ? _create_record(&block) : _update_record(*args, &block)
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
         row_hash = result.rows.first
@@ -61,9 +63,10 @@ module ActiveRecord
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def _create_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_create(attribute_names)
-      
-      new_id = self.class.unscoped.insert attributes_values
+      attribute_names &= self.class.column_names
+      attributes_values = attributes_with_values_for_create(attribute_names)
+
+      new_id = self.class._insert_record(attributes_values)
 
       @new_record = false
       
@@ -76,18 +79,20 @@ module ActiveRecord
     end
     
     def _update_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_update(attribute_names)
+      attribute_names &= self.class.column_names
+      attributes_values = attributes_with_values_for_update(attribute_names)
+
       if attributes_values.empty?
-        rows_affected = 0
+        affected_rows = 0
         @_trigger_update_callback = true
       else
-        rows_affected = self.class.unscoped._update_record(attributes_values, id, id_in_database)
-        @_trigger_update_callback = (rows_affected.is_a?(ActiveRecord::Result) ? rows_affected.rows.size : rows_affected) > 0
+        affected_rows = self.class._update_record( attributes_values, self.class.primary_key => id_in_database )
+        @_trigger_update_callback = affected_rows == 1
       end
 
       yield(self) if block_given?
 
-      rows_affected
+      affected_rows
     end
     
     #!!!! TODO: I am duplicated from finder_methods.....

data/ext/active_record/relation.rb

@@ -1,59 +1,19 @@
 module ActiveRecord
   class Relation
 
-    def to_sql
-      @to_sql ||= begin
-        relation   = self
-        
-        if eager_loading?
-          find_with_associations { |rel| relation = rel }
-        end
-
-        conn = klass.connection
-        conn.unprepared_statement {
-          conn.to_sql(relation.arel, relation.bound_attributes)
-        }
-      end
-    end
-
     def to_sar
       @to_sar ||= begin
-        relation   = self
-        
         if eager_loading?
-          find_with_associations { |rel| relation = rel }
+          apply_join_dependency do |relation, join_dependency|
+            relation = join_dependency.apply_column_aliases(relation)
+            relation.to_sar
+          end
+        else
+          conn = klass.connection
+          conn.unprepared_statement { conn.to_sar(arel) }
         end
-
-        conn = klass.connection
-        conn.unprepared_statement {
-          conn.to_sar(relation.arel, relation.bound_attributes)
-        }
       end
     end
 
-    def _update_record(values, id, id_was) # :nodoc:
-      substitutes, binds = substitute_values values
-      
-      scope = @klass.unscoped
-
-      if @klass.finder_needs_type_condition?
-        scope.unscope!(where: @klass.inheritance_column)
-      end
-
-      relation = scope.where(@klass.primary_key => (id_was || id))
-      bvs = binds + relation.bound_attributes
-      um = relation
-        .arel
-        .compile_update(substitutes, @klass.primary_key)
-      um.table @klass.arel_table
-
-      @klass.connection.update(
-        um,
-        'SQL',
-        bvs,
-      )
-    end
-
-
   end
 end

data/ext/active_record/relation/calculations.rb

@@ -7,19 +7,21 @@ module ActiveRecord
       end
 
       if has_include?(column_names.first)
-        construct_relation_for_association_calculations.pluck(*column_names)
+        relation = apply_join_dependency
+        relation.pluck(*column_names)
       elsif klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         load
         return records.pluck(*column_names.map{|n| n.sub(/^#{klass.table_name}\./, "")})
       else
+        enforce_raw_sql_whitelist(column_names)
         relation = spawn
         relation.select_values = column_names.map { |cn|
           @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
         }
-        result = klass.connection.select_all(relation.arel, nil, bound_attributes)
+        result = skip_query_cache_if_necessary { klass.connection.select_all(relation.arel, nil) }
         result.cast_values(klass.attribute_types)
       end
     end
-    
+
   end
 end

data/ext/active_record/relation/query_methods.rb

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

data/ext/active_record/statement_cache.rb

@@ -5,9 +5,7 @@ module ActiveRecord
       def initialize(values, sunstone=false)
         @values = values
         @indexes = if sunstone
-          values.value.find_all { |thing|
-            Arel::Nodes::BindParam === thing
-          }
+          
         else
           values.each_with_index.find_all { |thing,i|
             Arel::Nodes::BindParam === thing
@@ -16,11 +14,11 @@ module ActiveRecord
       end
 
       def sql_for(binds, connection)
-        casted_binds = binds.map(&:value_for_database)
-        
         if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-          @values.compile(binds)
+          binds.map!(&:value_for_database)
+          @values
         else
+          casted_binds = binds.map(&:value_for_database)
           val = @values.dup
           @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
           val.join

data/ext/active_record/transactions.rb

@@ -34,29 +34,19 @@ module ActiveRecord
     # end
 
     def with_transaction_returning_status
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
-        begin
-          status = yield
-        rescue ActiveRecord::Rollback
-          clear_transaction_record_state
-          status = nil
-        end
-        return status
-      end
-      
       status = nil
-      self.class.transaction do
-        add_to_transaction
-        begin
+      
+      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
+        status = yield
+        status
+      else
+        self.class.transaction do
+          add_to_transaction
           status = yield
-        rescue ActiveRecord::Rollback
-          clear_transaction_record_state
-          status = nil
+          raise ActiveRecord::Rollback unless status
         end
-        
-        raise ActiveRecord::Rollback unless status
+        status
       end
-      status
     ensure
       if @transaction_state && @transaction_state.committed?
         clear_transaction_record_state

data/ext/arel/nodes/select_statement.rb

@@ -4,24 +4,38 @@ module Arel
 
       attr_accessor :eager_load
 
-      def initialize_with_eager_load cores = [SelectCore.new]
-        initialize_without_eager_load
-        @eager_load = nil
+      def initialize cores = [SelectCore.new]
+        super()
+        @cores          = cores
+        @orders         = []
+        @limit          = nil
+        @lock           = nil
+        @offset         = nil
+        @with           = nil
+        @eager_load     = nil
       end
-
-      alias_method :initialize_without_eager_load, :initialize
-      alias_method :initialize, :initialize_with_eager_load
-
+      
+      def initialize_copy other
+        super
+        @cores  = @cores.map { |x| x.clone }
+        @orders = @orders.map { |x| x.clone }
+        @eager_load = @eager_load&.map { |x| x.clone }
+      end
+      
       def hash
         [@cores, @orders, @limit, @lock, @offset, @with, @eager_load].hash
       end
 
-      def eql_with_eager_load? other
-        eql_without_eager_load?(other) && self.eager_load == other.eager_load
+      def eql? other
+        self.class == other.class &&
+          self.cores == other.cores &&
+          self.orders == other.orders &&
+          self.limit == other.limit &&
+          self.lock == other.lock &&
+          self.offset == other.offset &&
+          self.with == other.with &&
+          self.eager_load == other.eager_load
       end
-      alias_method :eql_without_eager_load?, :eql?
-      alias_method :eql?, :eql_with_eager_load?
-      alias_method :==, :eql?
 
     end
   end

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

@@ -7,49 +7,97 @@ module ActiveRecord
 
         def to_sql(arel, binds = [])
           if arel.respond_to?(:ast)
-            collected = Arel::Visitors::ToSql.new(self).accept(arel.ast, prepared_statements ? AbstractAdapter::SQLString.new : AbstractAdapter::BindCollector.new)
-            collected.compile(binds, self).freeze
+            unless binds.empty?
+              raise "Passing bind parameters with an arel AST is forbidden. " \
+                "The values must be stored on the AST directly"
+            end
+            Arel::Visitors::ToSql.new(self).accept(arel.ast, Arel::Collectors::SubstituteBinds.new(self, Arel::Collectors::SQLString.new)).value
           else
             arel.dup.freeze
           end
         end
         
         # Converts an arel AST to a Sunstone API Request
-        def to_sar(arel, bvs = [])
-          if arel.respond_to?(:ast)
-            collected = visitor.accept(arel.ast, collector)
-            collected.compile(bvs, self)
+        def to_sar(arel_or_sar_string, binds = nil)
+          if arel_or_sar_string.respond_to?(:ast)
+            sar = visitor.accept(arel_or_sar_string.ast, collector)
+            binds = sar.binds if binds.nil?
           else
-            arel
+            sar = arel_or_sar_string
           end
+          sar.compile(binds)
         end
         
+        def to_sar_and_binds(arel_or_sar_string, binds = []) # :nodoc:
+          if arel_or_sar_string.respond_to?(:ast)
+            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]
+          else
+            # puts ['b',arel_or_sar_string.dup.freeze, binds].map(&:inspect)
+            [arel_or_sar_string.dup.freeze, binds]
+          end
+        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:
-          collected = visitor.accept(arel.ast, collector)
           if prepared_statements
-            klass.query(collected.value)
+            sql, binds = visitor.accept(arel.ast, collector).value
+            query = klass.query(sql)
+          elsif self.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+            collector = SunstonePartialQueryCollector.new(self.collector)
+            parts, binds = visitor.accept(arel.ast, collector).value
+            query = StatementCache::PartialQuery.new(parts, true)
           else
-            if self.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-              StatementCache::PartialQuery.new(collected, true)
-            else
-              StatementCache::PartialQuery.new(collected.value, false)
-            end
+            collector = PartialQueryCollector.new
+            parts, binds = visitor.accept(arel.ast, collector).value
+            query = klass.partial_query(parts)
+          end
+          [query, binds]
+        end
+
+        class SunstonePartialQueryCollector
+          delegate_missing_to :@collector
+          
+          def initialize(collector)
+            @collector = collector
+            @binds = []
+          end
+
+          def add_bind(obj)
+            @binds << obj
+          end
+
+          def value
+            [@collector, @binds]
           end
         end
 
         # Returns an ActiveRecord::Result instance.
         def select_all(arel, name = nil, binds = [], preparable: nil)
-          arel, binds = binds_from_relation arel, binds
-          select(arel, name, binds)
+          arel = arel_from_relation(arel)
+          sar, binds = to_sar_and_binds(arel, binds)
+          select(sar, name, binds)
         end
 
         def exec_query(arel, name = 'SAR', binds = [], prepare: false)
           sars = []
-          multiple_requests = arel.is_a?(Arel::SelectManager)
-
+          multiple_requests = arel.is_a?(Arel::Collectors::Sunstone)
+          type_casted_binds = binds#type_casted_binds(binds)
+          
           if multiple_requests
-            allowed_limit = limit_definition(arel.source.left.name)
-            requested_limit = binds.find { |x| x.name == 'LIMIT' }&.value
+            allowed_limit = limit_definition(arel.table)
+            limit_bind_index = nil#binds.find_index { |x| x.name == 'LIMIT' }
+            requested_limit = if limit_bind_index
+              type_casted_binds[limit_bind_index]
+            else
+              arel.limit&.value&.value_for_database
+            end
 
             if allowed_limit.nil?
               multiple_requests = false
@@ -61,7 +109,7 @@ module ActiveRecord
           end
 
           send_request = lambda { |req_arel|
-            sar = to_sar(req_arel, binds)
+            sar = to_sar(req_arel, type_casted_binds)
             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
@@ -75,12 +123,11 @@ module ActiveRecord
           }
 
           result = if multiple_requests
-            bind = binds.find { |x| x.name == 'LIMIT' }
-            binds.delete(bind)
+            binds.delete_at(limit_bind_index) if limit_bind_index
 
             limit, offset, results = allowed_limit, 0, []
             while requested_limit ? offset < requested_limit : true
-              split_arel = arel.clone
+              split_arel = arel.dup
               split_arel.limit = limit
               split_arel.offset = offset
               request_results = send_request.call(split_arel)
@@ -104,8 +151,12 @@ module ActiveRecord
         end
         
         def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-          value = exec_insert(arel, name, binds, pk, sequence_name)
+          sar, binds = to_sar_and_binds(arel, binds)
+          value = exec_insert(sar, name, binds, pk, sequence_name)
           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 = [])

data/lib/active_record/connection_adapters/sunstone/type/json.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     module Sunstone
       module Type
-        class Json < ActiveRecord::Type::Internal::AbstractJson
+        class Json < ActiveRecord::Type::Json
 
 
           def deserialize(value)

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -130,7 +130,7 @@ module ActiveRecord
       def collector
         Arel::Collectors::Sunstone.new
       end
-
+      
       def server_config
         JSON.parse(@connection.get("/configuration").body)
       end
@@ -173,8 +173,7 @@ module ActiveRecord
       # If the next id was calculated in advance (as in Oracle), it should be
       # passed in as +id_value+.
       def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
-        sql, binds, pk, sequence_name = sql_for_insert(arel, pk, id_value, sequence_name, binds)
-        exec_insert(sql, name, binds, pk, sequence_name)
+        exec_insert(arel, name, binds, pk, sequence_name)
       end
       alias create insert