sunstone 5.1.0.4 → 6.1.0.rc1

data/ext/active_record/persistence.rb

@@ -2,6 +2,22 @@ module ActiveRecord
   # = Active Record \Persistence
   module Persistence
     
+    module ClassMethods
+      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)
+              end
+            end
+          end
+          true
+        end
+      end
+    end
+    
     def update!(attributes)
       @no_save_transaction = true
       with_transaction_returning_status do
@@ -14,12 +30,14 @@ module ActiveRecord
     
     private
 
-    def create_or_update(*args)
+    def create_or_update(**, &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(&block)
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
         row_hash = result.rows.first
@@ -61,9 +79,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(attribute_names)
+
+      new_id = self.class._insert_record(attributes_values)
 
       @new_record = false
       
@@ -76,20 +95,23 @@ module ActiveRecord
     end
     
     def _update_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_update(attribute_names)
-      if attributes_values.empty?
-        rows_affected = 0
+      attribute_values = attributes_with_values(attribute_names)
+
+      if attribute_values.empty?
+        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( attribute_values, self.class.primary_key => id_in_database )
+        @_trigger_update_callback = affected_rows == 1
       end
 
+      @previously_new_record = false
+
       yield(self) if block_given?
 
-      rows_affected
+      affected_rows
     end
-    
+
     #!!!! TODO: I am duplicated from finder_methods.....
     def construct(parent, relations, seen, model_cache)
       relations.each do |key, attributes|

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

@@ -2,24 +2,32 @@ 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
 
       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
+        klass.disallow_raw_sql!(column_names)
+        columns = arel_columns(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.cast_values(klass.attribute_types)
+        relation.select_values = columns
+        
+        result = skip_query_cache_if_necessary do
+          if where_clause.contradiction?
+            ActiveRecord::Result.new([], [])
+          else
+            klass.connection.select_all(relation.arel, nil)
+          end
+        end
+        type_cast_pluck_values(result, columns)
       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,24 +5,26 @@ 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
+          values.each_with_index.find_all { |thing, i|
+            Substitute === thing
           }.map(&:last)
         end
       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
           val = @values.dup
-          @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
+          @indexes.each do |i|
+            value = binds.shift
+            if ActiveModel::Attribute === value
+              value = value.value_for_database
+            end
+            val[i] = connection.quote(value)
+          end
           val.join
         end
       end

data/ext/active_record/transactions.rb

@@ -20,7 +20,7 @@ module ActiveRecord
     #   end
     # end
     #
-    def save!(*) #:nodoc:
+    def save!(**) #:nodoc:
       if instance_variable_defined?(:@no_save_transaction) && @no_save_transaction
         super
       else
@@ -34,33 +34,23 @@ 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
+      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
+
           status = yield
-        rescue ActiveRecord::Rollback
-          clear_transaction_record_state
-          status = nil
+          raise ActiveRecord::Rollback unless status
         end
-        
-        raise ActiveRecord::Rollback unless status
       end
+      
       status
-    ensure
-      if @transaction_state && @transaction_state.committed?
-        clear_transaction_record_state
-      end
     end
 
 

data/ext/arel/attributes/empty_relation.rb

@@ -1,31 +1,31 @@
-module Arel
-  module Attributes
-    class EmptyRelation < Attribute
-
-      attr_accessor :collection, :for_write
-
-      def initialize(relation, name, collection = false, for_write=false)
-        self[:relation] = relation
-        self[:name] = name
-        @collection = collection
-        @for_write = for_write
-      end
-
-      def able_to_type_cast?
-        false
-      end
-
-      def table_name
-        nil
-      end
-
-      def eql? other
-        self.class == other.class &&
-          self.relation == other.relation &&
-          self.name == other.name &&
-          self.collection == other.collection
-      end
-
-    end
-  end
-end
+# module Arel
+#   module Attributes
+#     class EmptyRelation < Attribute
+#
+#       attr_accessor :collection, :for_write
+#
+#       def initialize(relation, name, collection = false, for_write=false)
+#         self[:relation] = relation
+#         self[:name] = name
+#         @collection = collection
+#         @for_write = for_write
+#       end
+#
+#       def able_to_type_cast?
+#         false
+#       end
+#
+#       def table_name
+#         nil
+#       end
+#
+#       def eql? other
+#         self.class == other.class &&
+#           self.relation == other.relation &&
+#           self.name == other.name &&
+#           self.collection == other.collection
+#       end
+#
+#     end
+#   end
+# end

data/ext/arel/nodes/select_statement.rb

@@ -1,27 +1,41 @@
 module Arel
   module Nodes
-    class SelectStatement < Arel::Nodes::Node
+    class SelectStatement < Arel::Nodes::NodeExpression
 
       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/column.rb

@@ -2,8 +2,7 @@ module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
     class SunstoneColumn < Column #:nodoc:
-      delegate :array, to: :sql_type_metadata
-      alias :array? :array
+      attr_reader :array
       
       def initialize(name, sql_type_metadata, options={})
         @name = name.freeze
@@ -14,6 +13,7 @@ module ActiveRecord
         @collation = nil
         @table_name = nil
         @primary_key = (options['primary_key'] == true)
+        @array = options['array']
       end
       
       def primary_key?

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.compile(arel.ast, collector)
+            query = klass.query(sql)
+          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)
           else
-            if self.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
-              StatementCache::PartialQuery.new(collected, true)
-            else
-              StatementCache::PartialQuery.new(collected.value, false)
-            end
+            collector = klass.partial_query_collector
+            parts, binds = visitor.compile(arel.ast, collector)
+            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)
@@ -95,7 +142,7 @@ 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
@@ -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 = [])