sequel 5.8.0 → 5.38.0

data/lib/sequel/plugins/pg_array_associations.rb

@@ -160,7 +160,7 @@ module Sequel
 
         def filter_by_associations_add_conditions_dataset_filter(ds)
           key = qualify(associated_class.table_name, self[:key])
-          ds.select{unnest(key)}.exclude(key=>nil)
+          ds.cross_join(Sequel.function(:unnest, key).as(:_smtopgaa_, [:_smtopgaa_key_])).exclude(key=>nil).select(:_smtopgaa_key_)
         end
         
         def filter_by_associations_conditions_key
@@ -337,12 +337,13 @@ module Sequel
           end
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
+            eo = Hash[eo]
+            eo[:loader] = false
 
-            eager_load_results(opts, Hash[eo].merge!(:loader=>false)) do |assoc_record|
-              if pks ||= assoc_record.get_column_value(key)
+            eager_load_results(opts, eo) do |assoc_record|
+              if pks = assoc_record.get_column_value(key)
                 pks.each do |pkv|
-                  next unless objects = id_map[pkv]
-                  objects.each do |object| 
+                  id_map[pkv].each do |object| 
                     object.associations[name].push(assoc_record)
                   end
                 end
@@ -374,7 +375,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -433,7 +434,9 @@ module Sequel
               end
             end
 
-            eager_load_results(opts, Hash[eo].merge!(:id_map=>id_map)) do |assoc_record|
+            eo = Hash[eo]
+            eo[:id_map] = id_map
+            eager_load_results(opts, eo) do |assoc_record|
               if objects = id_map[assoc_record.get_column_value(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
@@ -466,7 +469,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -527,7 +530,7 @@ module Sequel
               Sequel[pk=>assoc_pks]
             end
           when Sequel::Dataset
-            Sequel[pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest}]
+            obj.select(ref.qualify(obj.model.table_name, ref[:key_column]).as(:key)).from_self.where{{pk=>any(:key)}}.select(1).exists
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
           expr = add_association_filter_conditions(ref, obj, expr)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -22,8 +22,9 @@ module Sequel
     # This plugin is not intended as a replacement for other validations,
     # it is intended as a last resort.  The purpose of validations is to provide nice
     # error messages for the user, and the error messages generated by this plugin are
-    # fairly generic.  The error messages can be customized using the :messages plugin
-    # option, but there is only a single message used per constraint type.
+    # fairly generic by default.  The error messages can be customized per constraint type
+    # using the :messages plugin option, and individually per constraint using
+    # +pg_auto_constraint_validation_override+ (see below).
     #
     # This plugin only works on the postgres adapter when using the pg 0.16+ driver,
     # PostgreSQL 9.3+ server, and PostgreSQL 9.3+ client library (libpq). In other cases
@@ -37,6 +38,38 @@ module Sequel
     #   rescue Sequel::ValidationFailed
     #     album.errors.on(:artist_id) # ['is invalid']
     #   end
+    #
+    # While the database usually provides enough information to correctly associated
+    # constraint violations with model columns, there are cases where it does not.
+    # In those cases, you can override the handling of specific constraint violations
+    # to be associated to particular column(s), and use a specific error message:
+    #
+    #   Album.pg_auto_constraint_validation_override(:constraint_name, [:column1], "validation error message")
+    #
+    # Using the pg_auto_constraint_validations plugin requires 5 queries per
+    # model at load time in order to gather the necessary metadata.  For applications
+    # with a large number of models, this can result in a noticeable delay during model
+    # initialization.  To mitigate this issue, you can cache the necessary metadata in
+    # a file with the :cache_file option:
+    #
+    #   Sequel::Model.plugin :pg_auto_constraint_validations, cache_file: 'db/pgacv.cache'
+    #
+    # The file does not have to exist when loading the plugin.  If it exists, the plugin
+    # will load the cache and use the cached results instead of issuing queries if there
+    # is an entry in the cache.  If there is no entry in the cache, it will update the
+    # in-memory cache with the metadata results.  To save the in in-memory cache back to
+    # the cache file, run:
+    #
+    #   Sequel::Model.dump_pg_auto_constraint_validations_cache
+    # 
+    # Note that when using the :cache_file option, it is up to the application to ensure
+    # that the dumped cached metadata reflects the current state of the database.  Sequel
+    # does no checking to ensure this, as checking would take time and the
+    # purpose of this code is to take a shortcut.
+    #
+    # The cached schema is dumped in Marshal format, since it is the fastest
+    # and it handles all ruby objects used in the metadata.  Because of this,
+    # you should not attempt to load the metadata from a untrusted file.
     # 
     # Usage:
     #
@@ -59,13 +92,28 @@ module Sequel
       }.freeze).each_value(&:freeze)
 
       # Setup the constraint violation metadata.  Options:
+      # :cache_file :: File storing cached metadata, to avoid queries for each model
       # :messages :: Override the default error messages for each constraint
       #              violation type (:not_null, :check, :unique, :foreign_key, :referenced_by)
       def self.configure(model, opts=OPTS)
         model.instance_exec do
+          if @pg_auto_constraint_validations_cache_file = opts[:cache_file]
+            @pg_auto_constraint_validations_cache = if ::File.file?(@pg_auto_constraint_validations_cache_file)
+              cache = Marshal.load(File.read(@pg_auto_constraint_validations_cache_file))
+              cache.each_value do |hash|
+                hash.freeze.each_value(&:freeze)
+              end
+            else
+              {}
+            end
+          else
+            @pg_auto_constraint_validations_cache = nil
+          end
+
           setup_pg_auto_constraint_validations
-          @pg_auto_constraint_validations_messages = (@pg_auto_constraint_validations_messages || DEFAULT_ERROR_MESSAGES).merge(opts[:messages] || {}).freeze
+          @pg_auto_constraint_validations_messages = (@pg_auto_constraint_validations_messages || DEFAULT_ERROR_MESSAGES).merge(opts[:messages] || OPTS).freeze
         end
+        nil
       end
 
       module ClassMethods
@@ -77,9 +125,26 @@ module Sequel
         # generated validation failures.
         attr_reader :pg_auto_constraint_validations_messages
 
-        Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil)
+        Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil, :@pg_auto_constraint_validations_cache=>nil, :@pg_auto_constraint_validations_cache_file=>nil)
         Plugins.after_set_dataset(self, :setup_pg_auto_constraint_validations)
 
+        # Dump the in-memory cached metadata to the cache file.
+        def dump_pg_auto_constraint_validations_cache
+          raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
+          File.open(file, 'wb'){|f| f.write(Marshal.dump(@pg_auto_constraint_validations_cache))}
+          nil
+        end
+
+        # Override the constraint validation columns and message for a given constraint
+        def pg_auto_constraint_validation_override(constraint, columns, message)
+          pgacv = Hash[@pg_auto_constraint_validations]
+          overrides = pgacv[:overrides] = Hash[pgacv[:overrides]]
+          overrides[constraint] = [Array(columns), message].freeze
+          overrides.freeze
+          @pg_auto_constraint_validations = pgacv.freeze
+          nil
+        end
+
         private
 
         # Get the list of constraints, unique indexes, foreign keys in the current
@@ -104,38 +169,51 @@ module Sequel
             return
           end
 
-          checks = {}
-          indexes = {}
-          foreign_keys = {}
-          referenced_by = {}
+          cache = @pg_auto_constraint_validations_cache
+          literal_table_name = dataset.literal(table_name)
+          unless cache && (metadata = cache[literal_table_name])
+            checks = {}
+            indexes = {}
+            foreign_keys = {}
+            referenced_by = {}
 
-          db.check_constraints(table_name).each do |k, v|
-            checks[k] = v[:columns].dup.freeze
-          end
-          db.indexes(table_name, :include_partial=>true).each do |k, v|
-            if v[:unique]
-              indexes[k] = v[:columns].dup.freeze
+            db.check_constraints(table_name).each do |k, v|
+              checks[k] = v[:columns].dup.freeze unless v[:columns].empty?
+            end
+            db.indexes(table_name, :include_partial=>true).each do |k, v|
+              if v[:unique]
+                indexes[k] = v[:columns].dup.freeze
+              end
+            end
+            db.foreign_key_list(table_name, :schema=>false).each do |fk|
+              foreign_keys[fk[:name]] = fk[:columns].dup.freeze
+            end
+            db.foreign_key_list(table_name, :reverse=>true, :schema=>false).each do |fk|
+              referenced_by[[fk[:schema], fk[:table], fk[:name]].freeze] = fk[:key].dup.freeze
+            end
+
+            schema, table = db[:pg_class].
+              join(:pg_namespace, :oid=>:relnamespace, db.send(:regclass_oid, table_name)=>:oid).
+              get([:nspname, :relname])
+
+            metadata = {
+              :schema=>schema,
+              :table=>table,
+              :check=>checks,
+              :unique=>indexes,
+              :foreign_key=>foreign_keys,
+              :referenced_by=>referenced_by,
+              :overrides=>OPTS
+            }.freeze
+            metadata.each_value(&:freeze)
+
+            if cache
+              cache[literal_table_name] = metadata
             end
-          end
-          db.foreign_key_list(table_name, :schema=>false).each do |fk|
-            foreign_keys[fk[:name]] = fk[:columns].dup.freeze
-          end
-          db.foreign_key_list(table_name, :reverse=>true, :schema=>false).each do |fk|
-            referenced_by[[fk[:schema], fk[:table], fk[:name]].freeze] = fk[:key].dup.freeze
           end
 
-          schema, table = db[:pg_class].
-            join(:pg_namespace, :oid=>:relnamespace, db.send(:regclass_oid, table_name)=>:oid).
-            get([:nspname, :relname])
-
-          (@pg_auto_constraint_validations = {
-            :schema=>schema,
-            :table=>table,
-            :check=>checks,
-            :unique=>indexes,
-            :foreign_key=>foreign_keys,
-            :referenced_by=>referenced_by
-          }.freeze).each_value(&:freeze)
+          @pg_auto_constraint_validations = metadata
+          nil
         end
       end
 
@@ -158,44 +236,54 @@ module Sequel
             m = ds.method(:output_identifier)
             schema = info[:schema]
             table = info[:table]
+
             if constraint = info[:constraint]
               constraint = m.call(constraint)
+
+              columns, message = cv_info[:overrides][constraint]
+              if columns
+                override = true
+                add_pg_constraint_validation_error(columns, message)
+              end
             end
+
             messages = model.pg_auto_constraint_validations_messages
 
-            case e
-            when Sequel::NotNullConstraintViolation
-              if column = info[:column]
-                add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
-              end
-            when Sequel::CheckConstraintViolation
-              if columns = cv_info[:check][constraint]
-                add_pg_constraint_validation_error(columns, messages[:check])
-              end
-            when Sequel::UniqueConstraintViolation
-              if columns = cv_info[:unique][constraint]
-                add_pg_constraint_validation_error(columns, messages[:unique])
-              end
-            when Sequel::ForeignKeyConstraintViolation
-              message_primary = info[:message_primary]
-              if message_primary.start_with?('update')
-                # This constraint violation is different from the others, because the constraint
-                # referenced is a constraint for a different table, not for this table.  This
-                # happens when another table references the current table, and the referenced
-                # column in the current update is modified such that referential integrity
-                # would be broken.  Use the reverse foreign key information to figure out
-                # which column is affected in that case.
-                skip_schema_table_check = true
-                if columns = cv_info[:referenced_by][[m.call(schema), m.call(table), constraint]]
-                  add_pg_constraint_validation_error(columns, messages[:referenced_by])
+            unless override
+              case e
+              when Sequel::NotNullConstraintViolation
+                if column = info[:column]
+                  add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
+                end
+              when Sequel::CheckConstraintViolation
+                if columns = cv_info[:check][constraint]
+                  add_pg_constraint_validation_error(columns, messages[:check])
+                end
+              when Sequel::UniqueConstraintViolation
+                if columns = cv_info[:unique][constraint]
+                  add_pg_constraint_validation_error(columns, messages[:unique])
                 end
-              elsif message_primary.start_with?('insert')
-                if columns = cv_info[:foreign_key][constraint]
-                  add_pg_constraint_validation_error(columns, messages[:foreign_key])
+              when Sequel::ForeignKeyConstraintViolation
+                message_primary = info[:message_primary]
+                if message_primary.start_with?('update')
+                  # This constraint violation is different from the others, because the constraint
+                  # referenced is a constraint for a different table, not for this table.  This
+                  # happens when another table references the current table, and the referenced
+                  # column in the current update is modified such that referential integrity
+                  # would be broken.  Use the reverse foreign key information to figure out
+                  # which column is affected in that case.
+                  skip_schema_table_check = true
+                  if columns = cv_info[:referenced_by][[m.call(schema), m.call(table), constraint]]
+                    add_pg_constraint_validation_error(columns, messages[:referenced_by])
+                  end
+                elsif message_primary.start_with?('insert')
+                  if columns = cv_info[:foreign_key][constraint]
+                    add_pg_constraint_validation_error(columns, messages[:foreign_key])
+                  end
                 end
               end
             end
-          rescue => e2
+          rescue
             # If there is an error trying to conver the constraint violation
             # into a validation failure, it's best to just raise the constraint
             # violation.  This can make debugging the above block of code more

data/lib/sequel/plugins/prepared_statements.rb

@@ -41,11 +41,9 @@ module Sequel
         # Create a prepared statement, but modify the SQL used so that the model's columns are explicitly
         # selected instead of using *, assuming that the dataset selects from a single table.
         def prepare_explicit_statement(ds, type, vals=OPTS)
-          f = ds.opts[:from]
-          meth = type == :insert_select ? :returning : :select
-          s = ds.opts[meth]
-          if f && f.length == 1 && !ds.opts[:join] && (!s || s.empty?)
-            ds = ds.public_send(meth, *columns.map{|c| Sequel.identifier(c)})
+          s = ds.opts[:returning]
+          if !s || s.empty?
+            ds = ds.returning(*columns.map{|c| Sequel.identifier(c)})
           end 
           
           prepare_statement(ds, type, vals)
@@ -70,9 +68,7 @@ module Sequel
         # Return a prepared statement that can be used to insert a row using the given columns
         # and return that column values for the row created.
         def prepared_insert_select(cols)
-          if dataset.supports_insert_select?
-            cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
-          end
+          cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
         end
 
         # Return an array of two element arrays with the column symbol as the first entry and the
@@ -138,9 +134,7 @@ module Sequel
         # and return the new column values.
         def _insert_select_raw(ds)
           if use_prepared_statements_for?(:insert_select)
-            if ps = model.send(:prepared_insert_select, @values.keys)
-              _set_prepared_statement_server(ps).call(@values)
-            end
+            _set_prepared_statement_server(model.send(:prepared_insert_select, @values.keys)).call(@values)
           else
             super
           end
@@ -149,7 +143,7 @@ module Sequel
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
           if use_prepared_statements_for?(:update)
-            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(Hash[columns].merge!(pk_hash))
+            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(columns.merge(pk_hash))
           else
             super
           end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -66,9 +66,7 @@ module Sequel
         # Merge the current values into the default values to reduce the number
         # of free columns.
         def before_create
-          if v = model.prepared_statements_column_defaults
-            @values = Hash[v].merge!(values)
-          end
+          @values = model.prepared_statements_column_defaults.merge(@values)
           super
         end
 

data/lib/sequel/plugins/rcte_tree.rb

@@ -105,7 +105,6 @@ module Sequel
           key_present = lambda{|m| key_conv[m].all?}
           prkey_conv = lambda{|m| prkey_array.map{|k| m[k]}}
           key_aliases = (0...key_array.length).map{|i| :"#{ka}_#{i}"}
-          ka_conv = lambda{|m| key_aliases.map{|k| m[k]}}
           ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
@@ -114,20 +113,22 @@ module Sequel
           key_present = key_conv = lambda{|m| m[key]}
           prkey_conv = lambda{|m| m[prkey]}
           key_aliases = [ka]
-          ka_conv = lambda{|m| m[ka]}
           ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
           descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
           recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
           extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
         end
         
-        parent = opts.merge(opts.fetch(:parent, {})).fetch(:name, :parent)
-        childrena = opts.merge(opts.fetch(:children, {})).fetch(:name, :children)
+        parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
+        childrena = opts.merge(opts.fetch(:children, OPTS)).fetch(:name, :children)
         
         opts[:reciprocal] = nil
-        a = opts.merge(opts.fetch(:ancestors, {}))
+        a = opts.merge(opts.fetch(:ancestors, OPTS))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
+        a[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{ancestors} association for #{self} does not support eager graphing"
+        end
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
           base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
@@ -191,23 +192,19 @@ module Sequel
              :args=>((key_aliases + col_aliases) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[parent] = nil
               parent_map[opk] = obj
               (children_map[key_conv[obj]] ||= []) << obj
             end
             
-            if roots = id_map[extract_key_alias[obj]]
-              roots.each do |root|
-                root.associations[ancestors] << obj
-              end
+            id_map[extract_key_alias[obj]].each do |root|
+              root.associations[ancestors] << obj
             end
           end
           parent_map.each do |parent_id, obj|
@@ -220,9 +217,12 @@ module Sequel
         end
         model.one_to_many ancestors, a
         
-        d = opts.merge(opts.fetch(:descendants, {}))
+        d = opts.merge(opts.fetch(:descendants, OPTS))
         descendants = d.fetch(:name, :descendants)
         d[:read_only] = true unless d.has_key?(:read_only)
+        d[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{descendants} association for #{self} does not support eager graphing"
+        end
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
           base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
@@ -296,17 +296,15 @@ module Sequel
               :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>{})) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end
             
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[childrena] = [] unless no_cache
               parent_map[opk] = obj