sunstone 6.1.0.2 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52f0e0a557ddc1ec6d7dcc9728d3cfbf602d8c467d1647571cb887b56755e3cc
-  data.tar.gz: 8db1bd8849700b80328ac2cf1248ff5260659d0afc49648e694fae33790c79cc
+  metadata.gz: 02df1d75e40c2ef207e6e1f329068c95098f5b99758d1bcea603e157ed2c1f40
+  data.tar.gz: 4807c8a530f9c7f09448a08bea1dbe015724f2afb53d81b86cf5cef6d6b49dcf
 SHA512:
-  metadata.gz: a656ce5545ac0ad4a3f660f61857e8068a9c1f59060d4e9f9f06b1d80d2f6daca73e3317e02b35669a100ea1f8c578695f8ca0cc3a9eb2f00fc908708c1d18ff
-  data.tar.gz: 3395da82c6d52adc2029570a459f98cb7311c428a3f92c9f598d61ae8f0b7c5c7a354bb4d88933a6096e2cd5271997f929535f9ad2a35cda2c066d59472dae72
+  metadata.gz: e884525eda7c249da0f4decbadff3d27ff97859eac4874e1c20b4b0e10c80d6d96ee49419d27bd2f6d429c55c93485bfe1961451ff8396d101e37752ec39ac6d
+  data.tar.gz: 4323252706192a940b6f730a6c46324d4c40729df5864a5d1aafc4283764ef159284ddefe9b1335a7d9174b6716d11a2d0da4aa59dbdfbc3ac7cdccc537b06f8

data/ext/active_record/associations/collection_association.rb

@@ -41,7 +41,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?(:@updating) && owner.instance_variable_get(:@updating)
           true
         elsif raise
           record.save!(validate: validate, &block)

data/ext/active_record/attribute_methods.rb

@@ -97,7 +97,13 @@ 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
         

data/ext/active_record/finder_methods.rb

@@ -6,7 +6,8 @@ module ActiveRecord
   
       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)
+          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)
             ka.each { |k|
               if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
@@ -23,11 +24,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 +34,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 +202,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 +211,12 @@ module ActiveRecord
               ), nil
             ).reflections
           )
-      )
-        if has_limit_or_offset?
-          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?
@@ -225,6 +225,7 @@ module ActiveRecord
         relation
       end
     end
+    
   end
 
 end

data/ext/active_record/persistence.rb

@@ -79,17 +79,20 @@ 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)
-      attribute_names &= self.class.column_names
+      attribute_names = attributes_for_create(attribute_names)
       attributes_values = attributes_with_values(attribute_names)
-
+      
       new_id = self.class._insert_record(attributes_values)
 
+      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
       else
-        self.id ||= new_id if self.class.primary_key
         id
       end
     end

data/ext/active_record/relation/calculations.rb

@@ -2,7 +2,7 @@ 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 +14,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/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

@@ -8,7 +8,7 @@ module ActiveRecord
         @name = name.freeze
         @sql_type_metadata = sql_type_metadata
         @null = options['null']
-        @default = options['default']
+        @default = options['default'] ? JSON.generate(options['default']) : options['default']
         @default_function = nil
         @collation = nil
         @table_name = nil

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

@@ -28,18 +28,16 @@ module ActiveRecord
           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:
           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]
+            [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
         
@@ -79,10 +77,11 @@ 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)
         end
 
         def exec_query(arel, name = 'SAR', binds = [], prepare: false)
@@ -96,7 +95,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?

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

@@ -29,17 +29,7 @@ module ActiveRecord
 
           response = @connection.get("/#{table_name}/schema")
 
-          version = Gem::Version.create(response['StandardAPI-Version'] || '5.0.0.4')
-
-          @definitions[table_name] = if (version >= Gem::Version.create('6.0.0.29'))
-            schema = JSON.parse(response.body)
-            schema['columns'] = schema.delete('attributes')
-            schema
-          elsif (version >= Gem::Version.create('5.0.0.5'))
-            JSON.parse(response.body)
-          else
-            { 'columns' => JSON.parse(response.body), 'limit' => nil }
-          end
+          @definitions[table_name] = JSON.parse(response.body)
         rescue ::Sunstone::Exception::NotFound
           raise ActiveRecord::StatementInvalid, "Table \"#{table_name}\" does not exist"
         end
@@ -50,9 +40,7 @@ module ActiveRecord
         #  - format_type includes the column size constraint, e.g. varchar(50)
         #  - ::regclass is a function that gives the id for a table name
         def column_definitions(table_name) # :nodoc:
-          # First check for attributes and then for the deprecated columns field
-          # TODO: Remove after 0.3
-          definition(table_name)['attributes'] || definition(table_name)['columns']
+          definition(table_name)['columns']
         end
 
         # Returns the limit definition of the table (the maximum limit that can
@@ -93,6 +81,35 @@ module ActiveRecord
         def column_name_for_operation(operation, node) # :nodoc:
           visitor.accept(node, collector).first[operation.to_sym]
         end
+        
+        # Given a set of columns and an ORDER BY clause, returns the columns for a SELECT DISTINCT.
+        # PostgreSQL, MySQL, and Oracle override this for custom DISTINCT syntax - they
+        # require the order columns appear in the SELECT.
+        #
+        #   columns_for_distinct("posts.id", ["posts.created_at desc"])
+        #
+        def columns_for_distinct(columns, orders) # :nodoc:
+          columns
+        end
+
+        def distinct_relation_for_primary_key(relation) # :nodoc:
+          values = columns_for_distinct(
+            relation.table[relation.primary_key],
+            relation.order_values
+          )
+
+          limited = relation.reselect(values).distinct!
+          limited_ids = select_rows(limited.arel, "SQL").map(&:last)
+
+          if limited_ids.empty?
+            relation.none!
+          else
+            relation.where!(relation.primary_key => limited_ids)
+          end
+
+          relation.limit_value = relation.offset_value = nil
+          relation
+        end
 
         # TODO: def encoding
 

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -85,8 +85,8 @@ module ActiveRecord
         @prepared_statement_status = Concurrent::ThreadLocalVar.new(false)
         @connection_parameters = connection_parameters
 
-        # @type_map = Type::HashLookupTypeMap.new
-        # initialize_type_map(type_map)
+        @type_map = Type::HashLookupTypeMap.new
+        initialize_type_map(@type_map)
       end
 
       def active?
@@ -180,14 +180,24 @@ module ActiveRecord
       end
       alias create insert
 
-      # Should be the defuat insert, but rails escapes if for SQL so we'll just
-      # catch the string "DEFATUL VALUES" in the visitor
-      # def empty_insert_statement_value
-      #   {}
-      # end
+      def reload_type_map
+        type_map.clear
+        initialize_type_map
+      end
 
       private
 
+      def type_map
+        @type_map ||= Type::HashLookupTypeMap.new.tap do |mapping|
+          initialize_type_map(mapping)
+        end
+      end
+      
+      def initialize_type_map(m = type_map)
+        self.class.initialize_type_map(m)
+        load_additional_types
+      end
+
       def initialize_type_map(m) # :nodoc:
         m.register_type 'boolean',    Type::Boolean.new
         m.register_type 'string' do |_, options|

data/lib/arel/collectors/sunstone.rb

@@ -24,7 +24,14 @@ module Arel
       def substitute_binds hash, bvs
         if hash.is_a?(Array)
           hash.map do |v|
-            if v.is_a?(Arel::Nodes::BindParam)
+            if v.is_a?(ActiveRecord::Relation::QueryAttribute)
+              new_v = bvs.shift
+              if new_v.is_a?(ActiveRecord::Relation::QueryAttribute)
+                new_v.value_for_database
+              else
+                v.type.serialize(new_v)
+              end
+            elsif v.is_a?(Arel::Nodes::BindParam)
               bvs.shift#.value_for_database
             elsif v.is_a?(Hash) || v.is_a?(Array)
               substitute_binds(v, bvs)
@@ -35,7 +42,14 @@ module Arel
         elsif hash.is_a?(Hash)
           newhash = {}
           hash.each do |k, v|
-            if v.is_a?(Arel::Nodes::BindParam)
+            if v.is_a?(ActiveRecord::Relation::QueryAttribute)
+              new_v = bvs.shift
+              newhash[k] = if new_v.is_a?(ActiveRecord::Relation::QueryAttribute)
+                new_v.value_for_database
+              else
+                v.type.serialize(new_v)
+              end
+            elsif v.is_a?(Arel::Nodes::BindParam)
               newhash[k] = bvs.shift || v.value.value_for_database
             elsif v.is_a?(Hash)
               newhash[k] = substitute_binds(v, bvs)
@@ -47,9 +61,16 @@ module Arel
           end
           newhash
         elsif hash.is_a?(Arel::Nodes::BindParam)
-          bvs.shift || hash.value.value_for_database
+          bvs.shift
+        elsif hash.is_a?(ActiveRecord::Relation::QueryAttribute)
+          new_v = bvs.shift
+          if new_v.is_a?(ActiveRecord::Relation::QueryAttribute)
+            new_v.value_for_database
+          else
+            v.type.serialize(new_v)
+          end
         else
-          bvs.shift || hash.value.value_for_database
+          bvs.shift
         end
       end
 

data/lib/arel/visitors/sunstone.rb

@@ -8,10 +8,6 @@ module Arel
         accept(node, collector).value
       end
       
-      def preparable
-        false
-      end
-      
       private
       
       def visit_Arel_Nodes_SelectStatement o, collector
@@ -72,26 +68,12 @@ module Arel
           else
             collector.updates = {}
             
-            o.values.expr[0].each_with_index do |value, i|
-              k = value.value.name
-              if k.is_a?(Hash)
-                add_to_bottom_of_hash_or_array(k, value)
-                collector.updates.deep_merge!(k) { |key, v1, v2|
-                  if (v1.is_a?(Array) && v2.is_a?(Array))
-                    v2.each_with_index do |v, j|
-                      if v1[j].nil?
-                        v1[j] = v2[j]
-                      else
-                        v1[j].deep_merge!(v2[j]) unless v2[j].nil?
-                      end
-                    end
-                    v1
-                  else
-                    v2
-                  end
-                }
+            o.columns.map(&:name).zip(o.values.expr.first).to_h.each do |k, v|
+              collector.updates[k] = case v
+              when Nodes::SqlLiteral, Nodes::BindParam, ActiveModel::Attribute
+                visit(v, collector)
               else
-                collector.updates[k] = visit(value, collector)
+                v
               end
             end
           end
@@ -765,8 +747,13 @@ module Arel
       def visit_Arel_Nodes_Assignment o, collector
         case o.left
         when Arel::Nodes::UnqualifiedColumn
-          { visit(o.left.expr, collector) => visit(o.right, collector) }
-        when Arel::Attributes::Attribute, Arel::Nodes::BindParam
+          case o.right
+          when Arel::Attributes::Attribute, Arel::Nodes::BindParam, ActiveModel::Attribute
+            { visit(o.left.expr, collector) => visit(o.right, collector) }
+          else
+            { visit(o.left.expr, collector) => o.right }
+          end
+        when Arel::Attributes::Attribute, Arel::Nodes::BindParam, ActiveModel::Attribute
           { visit(o.left, collector) => visit(o.right, collector) }
         else
           collector = visit o.left, collector
@@ -968,6 +955,15 @@ module Arel
       alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute
 
+      def visit_ActiveModel_Attribute(o, collector)
+        if o.value.is_a?(ActiveRecord::StatementCache::Substitute)
+          a = collector.add_bind(o)
+          o
+        else
+          o.value_for_database
+        end
+      end
+      
       def visit_Arel_Nodes_BindParam o, collector
         a = collector.add_bind(o.value)
         o.is_a?(Arel::Nodes::BindParam) ? o : a
@@ -1067,7 +1063,6 @@ module Arel
       
       def maybe_visit thing, collector
         return collector unless thing
-        collector << " "
         visit thing, collector
       end
     end

data/lib/sunstone/connection.rb

@@ -132,25 +132,52 @@ module Sunstone
         if Thread.current[:sunstone_transaction_count] == 1 && !Thread.current[:sunstone_request_sent]
           Thread.current[:sunstone_request_sent] = request
         elsif Thread.current[:sunstone_request_sent]
-          log_mess = request.path.split('?', 2)
-          log_mess += Thread.current[:sunstone_request_sent].path.split('?', 2)
-          raise ActiveRecord::StatementInvalid, <<~MSG
+          message = <<~MSG
             Cannot send multiple request in a transaction.
-            
+        
             Trying to send:
-              #{request.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }
-            
-            Already sent:
-              #{Thread.current[:sunstone_request_sent].method} #{log_mess[2]} #{(log_mess[3] && !log_mess[3].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[3])) : '' }
           MSG
+          
+          path_and_query = request.path.split('?', 2)
+          message << "  #{request.method} #{path_and_query[0]}"
+          if path_and_query[1]
+            if request['Query-Encoding'] == 'application/msgpack'
+              message << " " << MessagePack.unpack(CGI.unescape(path_and_query[1]))
+            else
+              message << " " << CGI.unescape(path_and_query[1])
+            end
+          end
+            
+          message << "\n\nAlready sent:\n"
+          path_and_query = Thread.current[:sunstone_request_sent].path.split('?', 2)
+          message << "  #{Thread.current[:sunstone_request_sent].method} #{path_and_query[0]}"
+          if path_and_query[1]
+            if request['Query-Encoding'] == 'application/msgpack'
+              message << " " << MessagePack.unpack(CGI.unescape(path_and_query[1]))
+            else
+              message << " " << CGI.unescape(path_and_query[1])
+            end
+          end
+
+          raise ActiveRecord::StatementInvalid, message
         else
           log_mess = request.path.split('?', 2)
-          raise ActiveRecord::StatementInvalid, <<~MSG
-            Cannot send multiple request in a transaction.
+          message = if request['Query-Encoding'] == 'application/msgpack'
+            <<~MSG
+              Cannot send multiple request in a transaction.
             
-            Trying to send:
-              #{request.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }
-          MSG
+              Trying to send:
+                #{request.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? MessagePack.unpack(CGI.unescape(log_mess[1])) : '' }
+            MSG
+          else
+              <<~MSG
+              Cannot send multiple request in a transaction.
+            
+              Trying to send:
+                #{request.method} #{log_mess[0]} #{(log_mess[1] && !log_mess[1].empty?) ? CGI.unescape(log_mess[1]) : '' }
+            MSG
+          end
+          raise ActiveRecord::StatementInvalid, message
         end
       end
       

data/lib/sunstone/version.rb

@@ -1,3 +1,3 @@
 module Sunstone
-  VERSION = '6.1.0.2'
+  VERSION = '7.0.0'
 end