sequel 3.21.0 → 3.28.0

data/lib/sequel/model/errors.rb

@@ -40,7 +40,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}"}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
           m
         end
       end

data/lib/sequel/model/exceptions.rb

@@ -1,6 +1,10 @@
 module Sequel
   # Exception class raised when +raise_on_save_failure+ is set and a before hook returns false
-  class BeforeHookFailed < Error; end
+  # or an around hook doesn't call super or yield.
+  class HookFailed < Error; end
+
+  # Deprecated alias for HookFailed, kept for backwards compatibility
+  BeforeHookFailed = HookFailed
   
   # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
   # modify a single row.

data/lib/sequel/model.rb

@@ -11,9 +11,9 @@ module Sequel
   #             with the +Database+ in +source+ to create the
   #             dataset to use) 
   # Dataset :: Sets the dataset for this model to +source+. 
-  # Symbol :: Sets the table name for this model to +source+. The
-  #           class will use the default database for model
-  #           classes in order to create the dataset.
+  # other :: Sets the table name for this model to +source+. The
+  #          class will use the default database for model
+  #          classes in order to create the dataset.
   #
   # The purpose of this method is to set the dataset/database automatically
   # for a model class, if the table name doesn't match the implicit
@@ -49,10 +49,11 @@ module Sequel
   # called directly on the class.  Model datasets return rows as model instances,
   # which have fairly standard ORM instance behavior.
   #
-  # <tt>Sequel::Model</tt> is built completely out of plugins, the only method not part of a
-  # plugin is the plugin method itself.  Plugins can override any class, instance, or
-  # dataset method defined by a previous plugin and call super to get the default
-  # behavior.
+  # <tt>Sequel::Model</tt> is built completely out of plugins.  Plugins can override any class,
+  # instance, or dataset method defined by a previous plugin and call super to get the default
+  # behavior.  By default, <tt>Sequel::Model</tt> loads two plugins, <tt>Sequel::Model</tt>
+  # (which is itself a plugin) for the base support, and <tt>Sequel::Model::Associations</tt>
+  # for the associations support.
   #
   # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
   # make Sequel not load the associations plugin by default.
@@ -80,6 +81,11 @@ module Sequel
     # +super+ on the first line of your method, so later hooks are called after earlier hooks.
     AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
 
+    # Hooks that are called around an action.  If overridden, these methods must call super
+    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
+    # raised by the code they wrap or ensure that some behavior is executed no matter what.
+    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
+
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
     # call +super+ to get the default behavior (while empty by default, they can also be defined

data/lib/sequel/plugins/association_pks.rb

@@ -14,7 +14,7 @@ module Sequel
     #
     # Note that it uses the singular form of the association name. Also note
     # that the setter both associates to new primary keys not in the assocation
-    # and disassociated from primary keys not provided to the method.
+    # and disassociates from primary keys not provided to the method.
     #
     # This plugin makes modifications directly to the underlying tables,
     # it does not create or return any model objects, and therefore does
@@ -56,6 +56,7 @@ module Sequel
             _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key])).select_map(opts[:right_key])
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key]))
               ds.exclude(opts[:right_key]=>pks).delete
@@ -71,17 +72,34 @@ module Sequel
           super
           return if opts[:type] == :one_to_one
           def_association_pks_getter(opts) do
-            send(opts.dataset_method).select_map(opts[:primary_key])
+            send(opts.dataset_method).select_map(opts.associated_class.primary_key)
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = send(opts.dataset_method)
-              ds.unfiltered.filter(opts[:primary_key]=>pks).update(opts[:key]=>pk)
-              ds.exclude(opts[:primary_key]=>pks).update(opts[:key]=>nil)
+              primary_key = opts.associated_class.primary_key
+              key = opts[:key]
+              ds.unfiltered.filter(primary_key=>pks).update(key=>pk)
+              ds.exclude(primary_key=>pks).update(key=>nil)
             end
           end
         end
       end
+
+      module InstanceMethods
+        private
+
+        # If the associated class's primary key column type is integer,
+        # typecast all provided values to integer before using them.
+        def convert_pk_array(opts, pks)
+          if klass = opts.associated_class and sch = klass.db_schema and col = sch[klass.primary_key] and col[:type] == :integer
+            pks.map{|pk| model.db.typecast_value(:integer, pk)}
+          else
+            pks
+          end
+        end
+      end
     end
   end
 end

data/lib/sequel/plugins/defaults_setter.rb

@@ -0,0 +1,58 @@
+module Sequel
+  module Plugins
+    # DefaultsSetter is a simple plugin that sets non-nil/NULL default values upon
+    # initialize:
+    #
+    #   # column a default NULL
+    #   # column b default 2
+    #   album = Album.new.values # {:b => 2}
+    #   album = Album.new(:a=>1, :b=>3).values # {:a => 1, :b => 3}
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances set defaults (called before loading subclasses)
+    #   Sequel::Model.plugin :defaults_setter
+    #
+    #   # Make the Album class set defaults 
+    #   Album.plugin :defaults_setter
+    module DefaultsSetter
+      # Set the default values based on the model schema
+      def self.configure(model)
+        model.send(:set_default_values)
+      end
+
+      module ClassMethods
+        # The default values to set in initialize for this model.  A hash with column symbol
+        # keys and default values.  If the default values respond to +call+, it will be called
+        # to get the value, otherwise the value will be used directly.  You can manually modify
+        # this hash to set specific default values, by default the ones will be parsed from the database.
+        attr_reader :default_values
+        
+        # Set the default values when loading the dataset.
+        def set_dataset(*)
+          x = super
+          set_default_values
+          x
+        end
+
+        private
+
+        def set_default_values
+          h = {}
+          @db_schema.each{|k, v| h[k] = v[:ruby_default] if v[:ruby_default]} if @db_schema
+          @default_values = h
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Set default values if they are not already set by the hash provided to initialize.
+        def initialize_set(h)
+          super
+          model.default_values.each{|k,v| self[k] = (v.respond_to?(:call) ? v.call : v) unless values.has_key?(k)}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/identity_map.rb

@@ -22,10 +22,7 @@ module Sequel
     # Identity maps are thread-local and only persist for the duration of the block,
     # so they should only be considered as a possible performance enhancer.
     #
-    # The identity_map plugin is not compatible with the standard eager loading of
-    # many_to_many and many_through_many associations.  If you want to use the identity_map plugin,
-    # you should use +eager_graph+ instead of +eager+ for those associations. It is also
-    # not compatible with the eager loading in the +rcte_tree+ plugin.
+    # The identity_map plugin is not compatible with the eager loading in the +rcte_tree+ plugin.
     #
     # Usage:
     #
@@ -37,6 +34,116 @@ module Sequel
     #   # would need to do Album.with_identity_map{} to use the identity map
     module IdentityMap
       module ClassMethods
+        # Override the default :eager_loader option for many_*_many associations to work
+        # with an identity_map.  If the :eager_graph association option is used, you'll probably have to use
+        # :uniq=>true on the current association amd :cartesian_product_number=>2 on the association
+        # mentioned by :eager_graph, otherwise you'll end up with duplicates because the row proc will be
+        # getting called multiple times for the same object.  If you do have duplicates and you use :eager_graph,
+        # they'll probably be lost.  Making that work correctly would require changing a lot of the core
+        # architecture, such as how graphing and eager graphing work.
+        def associate(type, name, opts = {}, &block)
+          if opts[:eager_loader]
+            super
+          elsif type == :many_to_many
+            opts = super
+            el = opts[:eager_loader] 
+            model = self
+            left_pk = opts[:left_primary_key]
+            uses_lcks = opts[:uses_left_composite_keys]
+            uses_rcks = opts[:uses_right_composite_keys]
+            right = opts[:right_key]
+            join_table = opts[:join_table]
+            left = opts[:left_key]
+            lcks = opts[:left_keys]
+            left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
+            opts[:eager_loader] = lambda do |eo|
+              return el.call(eo) unless model.identity_map
+              h = eo[:key_hash][left_pk]
+              eo[:rows].each{|object| object.associations[name] = []}
+              r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
+              l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, h.keys]] : [[left, h.keys]]
+
+              # Replace the row proc to remove the left key alias before calling the previous row proc.
+              # Associate the value of the left key alias with the associated object (through its object_id).
+              # When loading the associated objects, lookup the left key alias value and associate the
+              # associated objects to the main objects if the left key alias value matches the left primary key
+              # value of the main object.
+              # 
+              # The deleting of the left key alias from the hash before calling the previous row proc
+              # is necessary when an identity map is used, otherwise if the same associated object is returned more than
+              # once for the association, it won't know which of current objects to associate it to.
+              ds = opts.associated_class.inner_join(join_table, r + l)
+              pr = ds.row_proc
+              h2 = {}
+              ds.row_proc = proc do |hash|
+                hash_key = if uses_lcks
+                  left_key_alias.map{|k| hash.delete(k)}
+                else
+                  hash.delete(left_key_alias)
+                end
+                obj = pr.call(hash)
+                (h2[obj.object_id] ||= []) << hash_key
+                obj
+              end
+              model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo) .all do |assoc_record|
+                if hash_keys = h2.delete(assoc_record.object_id)
+                  hash_keys.each do |hash_key|
+                    if objects = h[hash_key]
+                      objects.each{|object| object.associations[name].push(assoc_record)}
+                    end
+                  end
+                end
+              end
+            end
+            opts
+          elsif type == :many_through_many
+            opts = super
+            el = opts[:eager_loader] 
+            model = self
+            left_pk = opts[:left_primary_key]
+            left_key = opts[:left_key]
+            uses_lcks = opts[:uses_left_composite_keys]
+            left_keys = Array(left_key)
+            left_key_alias = opts[:left_key_alias]
+            opts[:eager_loader] = lambda do |eo|
+              return el.call(eo) unless model.identity_map
+              h = eo[:key_hash][left_pk]
+              eo[:rows].each{|object| object.associations[name] = []}
+              ds = opts.associated_class 
+              opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+              ft = opts[:final_reverse_edge]
+              conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
+
+              # See above comment in many_to_many eager_loader
+              ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
+              pr = ds.row_proc
+              h2 = {}
+              ds.row_proc = proc do |hash|
+                hash_key = if uses_lcks
+                  left_key_alias.map{|k| hash.delete(k)}
+                else
+                  hash.delete(left_key_alias)
+                end
+                obj = pr.call(hash)
+                (h2[obj.object_id] ||= []) << hash_key
+                obj
+              end
+              model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
+                if hash_keys = h2.delete(assoc_record.object_id)
+                  hash_keys.each do |hash_key|
+                    if objects = h[hash_key]
+                      objects.each{|object| object.associations[name].push(assoc_record)}
+                    end
+                  end
+                end
+              end
+            end
+            opts
+          else
+            super
+          end
+        end
+          
         # Returns the current thread-local identity map.  Should be a hash if
         # there is an active identity map, and nil otherwise.
         def identity_map
@@ -121,9 +228,9 @@ module Sequel
         # key option has a value and the association uses the primary key of
         # the associated class as the :primary_key option, check the identity
         # map for the associated object and return it if present.
-        def _load_associated_objects(opts)
+        def _load_associated_objects(opts, dynamic_opts={})
           klass = opts.associated_class
-          if klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts[:primary_key] == klass.primary_key and
+          if !dynamic_opts[:callback] && klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts.primary_key == klass.primary_key and
            opts[:key] and pk = _associated_object_pk(opts[:key]) and o = idm[klass.identity_map_key(pk)]
             o
           else

data/lib/sequel/plugins/many_through_many.rb

@@ -58,6 +58,19 @@ module Sequel
           self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
 
+        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
+        def eager_loading_predicate_key
+          self[:eager_loading_predicate_key] ||= begin
+            calculate_edges
+            e = self[:edges].first
+            if self[:uses_left_composite_keys]
+              e[:right].map{|k| SQL::QualifiedIdentifier.new(e[:table], k)}
+            else
+              SQL::QualifiedIdentifier.new(e[:table], e[:right])
+            end
+          end
+        end
+    
         # The list of joins to use when eager graphing
         def edges
           self[:edges] || calculate_edges || self[:edges]
@@ -116,6 +129,7 @@ module Sequel
           nil
         end
       end
+
       module ClassMethods
         # Create a many_through_many association.  Arguments:
         # * name - Same as associate, the name of the association.
@@ -181,13 +195,28 @@ module Sequel
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:eager_loader] ||= lambda do |eo|
             h = eo[:key_hash][left_pk]
-            eo[:rows].each{|object| object.associations[name] = []}
+            rows = eo[:rows]
+            rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
             ft = opts[:final_reverse_edge]
             conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
             ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
-            model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
+            ds = model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo)
+            case opts.eager_limit_strategy
+            when :window_function
+              delete_rn = true
+              rn = ds.row_number_column
+              ds = apply_window_function_eager_limit_strategy(ds, opts)
+            when :correlated_subquery
+              ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
+                dsa = ds.send(:dataset_alias, 2)
+                opts.reverse_edges.each{|t| xds = xds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+                xds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + left_keys.map{|k| [k, SQL::QualifiedIdentifier.new(ft[:table], k)]}, :table_alias=>dsa)
+              end
+            end
+            ds.all do |assoc_record|
+              assoc_record.values.delete(rn) if delete_rn
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
@@ -196,6 +225,10 @@ module Sequel
               next unless objects = h[hash_key]
               objects.each{|object| object.associations[name].push(assoc_record)}
             end
+            if opts.eager_limit_strategy == :ruby
+              limit, offset = opts.limit_and_offset
+              rows.each{|o| o.associations[name] = o.associations[name].slice(offset||0, limit) || []}
+            end
           end
 
           join_type = opts[:graph_join_type]
@@ -204,19 +237,48 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           use_only_conditions = opts.include?(:graph_only_conditions)
           conditions = opts[:graph_conditions]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            iq = table_alias
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            iq = eo[:implicit_qualifier]
             opts.edges.each do |t|
               ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
               iq = nil
             end
             fe = opts[:final_edge]
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
           end
 
           def_association_dataset_methods(opts)
         end
       end
+
+      module DatasetMethods
+        private
+
+        # Use a subquery to filter rows to those related to the given associated object
+        def many_through_many_association_filter_expression(op, ref, obj)
+          lpks = ref[:left_primary_keys]
+          lpks = lpks.first if lpks.length == 1
+          edges = ref.edges
+          first, rest = edges.first, edges[1..-1]
+          last = edges.last
+          ds = model.db[first[:table]].select(*Array(first[:right]).map{|x| ::Sequel::SQL::QualifiedIdentifier.new(first[:table], x)})
+          rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), &e[:block])}
+          last_alias = if rest.empty?
+            first[:table]
+          else
+            last_join = ds.opts[:join].last
+            last_join.table_alias || last_join.table
+          end
+          exp = association_filter_key_expression(Array(ref[:final_edge][:left]).map{|x| ::Sequel::SQL::QualifiedIdentifier.new(last_alias, x)}, ref.right_primary_keys, obj)
+          if exp == SQL::Constants::FALSE
+            association_filter_handle_inversion(op, exp, Array(lpks))
+          else
+            ds = ds.where(exp).exclude(SQL::BooleanExpression.from_value_pairs(ds.opts[:select].zip([]), :OR))
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>ds), Array(lpks))
+          end
+        end
+      end
     end
   end
 end

data/lib/sequel/plugins/prepared_statements.rb

@@ -0,0 +1,140 @@
+module Sequel
+  module Plugins
+    # The prepared_statements plugin modifies the model to use prepared statements for
+    # instance level deletes and saves, as well as class level lookups by
+    # primary key.
+    #
+    # Note that this plugin is unsafe in some circumstances, as it can allow up to
+    # 2^N prepared statements to be created for each type of insert and update query, where
+    # N is the number of colums in the table. It is recommended that you use the
+    # +prepared_statements_safe+ plugin in addition to this plugin to reduce the number
+    # of prepared statements that can be created, unless you tightly control how your
+    # model instances are saved.
+    # 
+    # This plugin probably does not work correctly with the instance filters plugin.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses use prepared statements  (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements
+    #
+    #   # Make the Album class use prepared statements
+    #   Album.plugin :prepared_statements
+    module PreparedStatements
+      # Synchronize access to the integer sequence so that no two calls get the same integer.
+      MUTEX = Mutex.new
+      
+      i = 0
+      # This plugin names prepared statements uniquely using an integer sequence, this
+      # lambda returns the next integer to use.
+      NEXT = lambda{MUTEX.synchronize{i += 1}}
+
+      # Setup the datastructure used to hold the prepared statements in the model.
+      def self.apply(model)
+        model.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{})
+      end
+
+      module ClassMethods
+        # Setup the datastructure used to hold the prepared statements in the subclass.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{})
+        end
+
+        private
+
+        # Create a prepared statement based on the given dataset with a unique name for the given
+        # type of query and values.
+        def prepare_statement(ds, type, vals={})
+          ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
+        end
+
+        # Return a sorted array of columns for use as a hash key.
+        def prepared_columns(cols)
+          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by{|c| c.to_s}
+        end
+
+        # Return a prepared statement that can be used to delete a row from this model's dataset.
+        def prepared_delete
+          @prepared_statements[:delete] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)
+        end
+
+        # Return a prepared statement that can be used to insert a row using the given columns.
+        def prepared_insert(cols)
+          @prepared_statements[:insert][prepared_columns(cols)] ||= prepare_statement(dataset, :insert, prepared_statement_key_hash(cols))
+        end
+
+        # 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?
+            @prepared_statements[:insert_select][prepared_columns(cols)] ||= prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))
+          end
+        end
+
+        # Return a prepared statement that can be used to lookup a row solely based on the primary key.
+        def prepared_lookup
+          @prepared_statements[:lookup] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :first)
+        end
+
+        # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
+        def prepared_refresh
+          @prepared_statements[:refresh] ||= prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)
+        end
+
+        # Return an array of two element arrays with the column symbol as the first entry and the
+        # placeholder symbol as the second entry.
+        def prepared_statement_key_array(keys)
+          Array(keys).map{|k| [k, :"$#{k}"]}
+        end
+
+        # Return a hash mapping column symbols to placeholder symbols.
+        def prepared_statement_key_hash(keys)
+          Hash[*(prepared_statement_key_array(keys).flatten)]
+        end
+
+        # Return a prepared statement that can be used to update row using the given columns.
+        def prepared_update(cols)
+          @prepared_statements[:update][prepared_columns(cols)] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))
+        end
+
+        # Use a prepared statement to query the database for the row matching the given primary key.
+        def primary_key_lookup(pk)
+          prepared_lookup.call(primary_key_hash(pk))
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Use a prepared statement to delete the row.
+        def _delete_without_checking
+          model.send(:prepared_delete).call(pk_hash)
+        end
+
+        # Use a prepared statement to insert the values into the model's dataset.
+        def _insert_raw(ds)
+          model.send(:prepared_insert, @values.keys).call(@values)
+        end
+
+        # Use a prepared statement to insert the values into the model's dataset
+        # and return the new column values.
+        def _insert_select_raw(ds)
+          if ps = model.send(:prepared_insert_select, @values.keys)
+            ps.call(@values)
+          end
+        end
+
+        # Use a prepared statement to refresh this model's column values.
+        def _refresh_get(ds)
+          model.send(:prepared_refresh).call(pk_hash)
+        end
+
+        # Use a prepared statement to update this model's columns in the database.
+        def _update_without_checking(columns)
+          model.send(:prepared_update, columns.keys).call(columns.merge(pk_hash))
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -0,0 +1,84 @@
+module Sequel
+  module Plugins
+    # The prepared_statements_associations plugin modifies the regular association
+    # load method to use a cached prepared statement to load the associations.
+    # It will not work on all associations, but it should skip the use of prepared
+    # statements for associations where it will not work, assuming you load the
+    # plugin before defining the associations.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses more safe when using prepared statements (called before loading subclasses)
+    #   Sequel::Model.plugin :prepared_statements_associations
+    #
+    #   # Make the Album class more safe when using prepared statements
+    #   Album.plugin :prepared_statements_associations
+    module PreparedStatementsAssociations
+      # Synchronize access to the integer sequence so that no two calls get the same integer.
+      MUTEX = Mutex.new
+
+      i = 0
+      # This plugin names prepared statements uniquely using an integer sequence, this
+      # lambda returns the next integer to use.
+      NEXT = lambda{MUTEX.synchronize{i += 1}}
+
+      module ClassMethods
+        # Disable prepared statement use if a block is given, or the :dataset or :conditions
+        # options are used, or you are cloning an association.
+        def associate(type, name, opts = {}, &block)
+          if block || opts[:dataset] || opts[:conditions] || (opts[:clone] && association_reflection(opts[:clone])[:prepared_statement] == false)
+            opts = opts.merge(:prepared_statement=>false)
+          end
+          super(type, name, opts, &block)
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Return a bound variable hash that maps the keys in +ks+ (qualified by the +table+)
+        # to the values of the results of sending the methods in +vs+.
+        def association_bound_variable_hash(table, ks, vs)
+          Hash[*ks.zip(vs).map{|k, v| [:"#{table}.#{k}", send(v)]}.flatten]
+        end
+
+        # Given an association reflection, return a bound variable hash for the given
+        # association for this instance's values.
+        def association_bound_variables(opts)
+          case opts[:type]
+          when :many_to_one
+            association_bound_variable_hash(opts.associated_class.table_name, opts.primary_keys, opts[:keys])
+          when :one_to_many
+            association_bound_variable_hash(opts.associated_class.table_name, opts[:keys], opts[:primary_keys])
+          when :many_to_many
+            association_bound_variable_hash(opts[:join_table], opts[:left_keys], opts[:left_primary_keys])
+          when :many_through_many
+            opts.reverse_edges
+            association_bound_variable_hash(opts[:final_reverse_edge][:alias], Array(opts[:left_key]), opts[:left_primary_keys])
+          end
+        end
+
+        # Given an association reflection, return and cache a prepared statement for this association such
+        # that, given appropriate bound variables, the prepared statement will work correctly for any
+        # instance.
+        def association_prepared_statement(opts)
+          opts[:prepared_statement] ||= _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
+        end
+
+        # If a prepared statement can be used to load the associated objects, execute it to retrieve them.  Otherwise,
+        # fall back to the default implementation.
+        def _load_associated_objects(opts, dynamic_opts={})
+          if !opts.can_have_associated_objects?(self) || dynamic_opts[:callback] || (ps = opts[:prepared_statement]) == false
+            super
+          else 
+            if bv = association_bound_variables(opts)
+              (ps || association_prepared_statement(opts)).call(bv)
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end