sequel 3.21.0 → 3.39.0

data/lib/sequel/plugins/nested_attributes.rb

@@ -1,20 +1,75 @@
 module Sequel
   module Plugins
-    # The nested_attributes plugin allows you to update attributes for associated
-    # objects directly through the parent object, similar to ActiveRecord's
-    # Nested Attributes feature.
-    #
-    # Nested attributes are created using the nested_attributes method:
+    # The nested_attributes plugin allows you to create, update, and delete
+    # associated objects directly by calling a method on the current object.
+    # Nested attributes are defined using the nested_attributes class method:
     #
     #   Artist.one_to_many :albums
     #   Artist.plugin :nested_attributes
     #   Artist.nested_attributes :albums
-    #   a = Artist.new(:name=>'YJM',
-    #    :albums_attributes=>[{:name=>'RF'}, {:name=>'MO'}])
-    #   # No database activity yet
     #
-    #   a.save # Saves artist and both albums
-    #   a.albums.map{|x| x.name} # ['RF', 'MO']
+    # The nested_attributes call defines a single method, <tt><i>association</i>_attributes=</tt>,
+    # (e.g. <tt>albums_attributes=</tt>).  So if you have an Artist instance:
+    #
+    #   a = Artist.new(:name=>'YJM')
+    #
+    # You can create new album instances related to this artist:
+    #
+    #   a.albums_attributes = [{:name=>'RF'}, {:name=>'MO'}]
+    #
+    # Note that this doesn't send any queries to the database yet.  That doesn't happen till
+    # you save the object:
+    #
+    #   a.save
+    #
+    # That will save the artist first, and then save both albums.  If either the artist
+    # is invalid or one of the albums is invalid, none of the objects will be saved to the
+    # database, and all related validation errors will be available in the artist's validation
+    # errors.
+    #
+    # In addition to creating new associated objects, you can also update existing associated
+    # objects.  You just need to make sure that the primary key field is filled in for the
+    # associated object:
+    #
+    #   a.update(:albums_attributes => [{:id=>1, :name=>'T'}])
+    #
+    # Since the primary key field is filled in, the plugin will update the album with id 1 instead
+    # of creating a new album.
+    #
+    # If you would like to delete the associated object instead of updating it, you add a _delete
+    # entry to the hash:
+    #
+    #   a.update(:albums_attributes => [{:id=>1, :_delete=>true}])
+    #
+    # This will delete the related associated object from the database.  If you want to leave the
+    # associated object in the database, but just remove it from the association, add a _remove
+    # entry in the hash:
+    #
+    #   a.update(:albums_attributes => [{:id=>1, :_remove=>true}])
+    #
+    # The above example was for a one_to_many association, but the plugin also works similarly
+    # for other association types.  For one_to_one and many_to_one associations, you need to
+    # pass a single hash instead of an array of hashes.
+    #
+    # This plugin is mainly designed to make it easy to use on html forms, where a single form
+    # submission can contained nested attributes (and even nested attributes of those attributes).
+    # You just need to name your form inputs correctly:
+    #
+    #   artist[name]
+    #   artist[albums_attributes][0][:name]
+    #   artist[albums_attributes][1][:id]
+    #   artist[albums_attributes][1][:name]
+    #
+    # Your web stack will probably parse that into a nested hash similar to:
+    #
+    #   {:artist=>{:name=>?, :albums_attributes=>{0=>{:name=>?}, 1=>{:id=>?, :name=>?}}}}
+    #
+    # Then you can do:
+    #
+    #   artist.update(params[:artist])
+    #
+    # To save changes to the artist, create the first album and associate it to the artist,
+    # and update the other existing associated album.
     module NestedAttributes
       # Depend on the instance_hooks plugin.
       def self.apply(model)
@@ -28,24 +83,37 @@ module Sequel
         
         # Allow nested attributes to be set for the given associations.  Options:
         # * :destroy - Allow destruction of nested records.
-        # * :fields - If provided, should be an Array.  Restricts the fields allowed to be
-        #   modified through the association_attributes= method to the specific fields given.
+        # * :fields - If provided, should be an Array or proc. If it is an array,
+        #   restricts the fields allowed to be modified through the
+        #   association_attributes= method to the specific fields given. If it is
+        #   a proc, it will be called with the associated object and should return an
+        #   array of the allowable fields.
         # * :limit - For *_to_many associations, a limit on the number of records
         #   that will be processed, to prevent denial of service attacks.
+        # * :reject_if - A proc that is given each attribute hash before it is
+        #   passed to its associated object. If the proc returns a truthy
+        #   value, the attribute hash is ignored.
         # * :remove - Allow disassociation of nested records (can remove the associated
         #   object from the parent object, but not destroy the associated object).
-        # * :strict - Set to false to not raise an error message if a primary key
-        #   is provided in a record, but it doesn't match an existing associated
-        #   object.
+        # * :strict - Kept for backward compatibility. Setting it to false is
+        #   equivalent to setting :unmatched_pk to :ignore.
+        # * :transform - A proc to transform attribute hashes before they are
+        #   passed to associated object. Takes two arguments, the parent object and
+        #   the attribute hash. Uses the return value as the new attribute hash.
+        # * :unmatched_pk - Specify the action to be taken if a primary key is
+        #   provided in a record, but it doesn't match an existing associated
+        #   object. Set to :create to create a new object with that primary
+        #   key, :ignore to ignore the record, or :raise to raise an error.
+        #   The default is :raise.
         #
-        # If a block is provided, it is passed each nested attribute hash.  If
-        # the hash should be ignored, the block should return anything except false or nil.
+        # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
           include(self.nested_attributes_module ||= Module.new) unless nested_attributes_module
           opts = associations.last.is_a?(Hash) ? associations.pop : {}
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
             r[:nested_attributes] = opts
+            r[:nested_attributes][:unmatched_pk] ||= opts.delete(:strict) == false ? :ignore : :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
           end
@@ -78,7 +146,9 @@ module Sequel
         def nested_attributes_check_key_modifications(reflection, obj)
           keys = reflection.associated_object_keys.map{|x| obj.send(x)}
           yield
-          raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed") unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+          unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+            raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed")
+          end
         end
         
         # Create a new associated object with the given attributes, validate
@@ -93,19 +163,19 @@ module Sequel
             after_save_hook{send(reflection.add_method, obj)}
           else
             associations[reflection[:name]] = obj
+
+            # Because we are modifying the associations cache manually before the
+            # setter is called, we still want to run the setter code even though
+            # the cached value will be the same as the given value.
+            @set_associated_object_if_same = true
+
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
-            send(reflection[:type] == :many_to_one ? :before_save_hook : :after_save_hook){send(reflection.setter_method, obj.save(:validate=>false))}
-          end
-          obj
-        end
-        
-        # Find an associated object with the matching pk.  If a matching option
-        # is not found and the :strict option is not false, raise an Error.
-        def nested_attributes_find(reflection, pk)
-          pk = pk.to_s
-          unless obj = Array(associated_objects = send(reflection[:name])).find{|x| x.pk.to_s == pk}
-            raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})") unless reflection[:nested_attributes][:strict] == false
+            if reflection[:type] == :many_to_one 
+              before_save_hook{send(reflection.setter_method, obj.save(:validate=>false))}
+            else
+              after_save_hook{send(reflection.setter_method, obj)}
+            end
           end
           obj
         end
@@ -122,72 +192,86 @@ module Sequel
           attributes_list.each{|a| nested_attributes_setter(reflection, a)}
         end
         
-        # Remove the matching associated object from the current object.
-        # If the :destroy option is given, destroy the object after disassociating it
+        # Remove the given associated object from the current object. If the
+        # :destroy option is given, destroy the object after disassociating it
         # (unless destroying the object would automatically disassociate it).
-        # Returns the object removed, if it exists.
-        def nested_attributes_remove(reflection, pk, opts={})
-          if obj = nested_attributes_find(reflection, pk)
-            if !opts[:destroy] || reflection.remove_before_destroy?
-              before_save_hook do
-                if reflection.returns_array?
-                  send(reflection.remove_method, obj)
-                else
-                  send(reflection.setter_method, nil)
-                end
+        # Returns the object removed.
+        def nested_attributes_remove(reflection, obj, opts={})
+          if !opts[:destroy] || reflection.remove_before_destroy?
+            before_save_hook do
+              if reflection.returns_array?
+                send(reflection.remove_method, obj)
+              else
+                send(reflection.setter_method, nil)
               end
             end
-            after_save_hook{obj.destroy} if opts[:destroy]
-            obj
           end
+          after_save_hook{obj.destroy} if opts[:destroy]
+          obj
         end
         
         # Set the fields in the obj based on the association, only allowing
         # specific :fields if configured.
         def nested_attributes_set_attributes(reflection, obj, attributes)
           if fields = reflection[:nested_attributes][:fields]
+            fields = fields.call(obj) if fields.respond_to?(:call)
             obj.set_only(attributes, fields)
           else
             obj.set(attributes)
           end
         end
 
-        # Modify the associated object based on the contents of the attribtues hash:
+        # Modify the associated object based on the contents of the attributes hash:
+        # * If a :transform block was given to nested_attributes, use it to modify the attribute hash.
         # * If a block was given to nested_attributes, call it with the attributes and return immediately if the block returns true.
+        # * If a primary key exists in the attributes hash and it matches an associated object:
+        # ** If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
+        # ** If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
+        # ** Otherwise, update the matching associated object with the contents of the hash.
+        # * If a primary key exists in the attributes hash but it does not match an associated object,
+        #   either raise an error, create a new object or ignore the hash, depending on the :unmatched_pk option.
         # * If no primary key exists in the attributes hash, create a new object.
-        # * If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
-        # * If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
-        # * Otherwise, update the matching associated object with the contents of the hash.
         def nested_attributes_setter(reflection, attributes)
+          if a = reflection[:nested_attributes][:transform]
+            attributes = a.call(self, attributes)
+          end
           return if (b = reflection[:nested_attributes][:reject_if]) && b.call(attributes)
           modified!
           klass = reflection.associated_class
-          if pk = attributes.delete(klass.primary_key) || attributes.delete(klass.primary_key.to_s)
-            if klass.db.send(:typecast_value_boolean, attributes[:_delete] || attributes['_delete']) && reflection[:nested_attributes][:destroy]
-              nested_attributes_remove(reflection, pk, :destroy=>true)
-            elsif klass.db.send(:typecast_value_boolean, attributes[:_remove] || attributes['_remove']) && reflection[:nested_attributes][:remove]
-              nested_attributes_remove(reflection, pk)
+          sym_keys = Array(klass.primary_key)
+          str_keys = sym_keys.map{|k| k.to_s}
+          if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
+            pk = pk.map{|k| k.to_s}
+            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map{|k| k.to_s} == pk}
+          end
+          if obj
+            attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
+            if reflection[:nested_attributes][:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
+              nested_attributes_remove(reflection, obj, :destroy=>true)
+            elsif reflection[:nested_attributes][:remove] && klass.db.send(:typecast_value_boolean, attributes.delete(:_remove) || attributes.delete('_remove'))
+              nested_attributes_remove(reflection, obj)
             else
-              nested_attributes_update(reflection, pk, attributes)
+              nested_attributes_update(reflection, obj, attributes)
+            end
+          elsif pk.all? && reflection[:nested_attributes][:unmatched_pk] != :create
+            if reflection[:nested_attributes][:unmatched_pk] == :raise
+              raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})")
             end
           else
             nested_attributes_create(reflection, attributes)
           end
         end
         
-        # Update the matching associated object with the attributes,
-        # validating it when the parent object is validated and saving it
-        # when the parent is saved.
-        # Returns the object updated, if it exists.
-        def nested_attributes_update(reflection, pk, attributes)
-          if obj = nested_attributes_find(reflection, pk)
-            nested_attributes_update_attributes(reflection, obj, attributes)
-            after_validation_hook{validate_associated_object(reflection, obj)}
-            # Don't need to validate the object twice if :validate association option is not false
-            # and don't want to validate it at all if it is false.
-            after_save_hook{obj.save_changes(:validate=>false)}
-            obj
-          end
+        # Update the given object with the attributes, validating it when the
+        # parent object is validated and saving it when the parent is saved.
+        # Returns the object updated.
+        def nested_attributes_update(reflection, obj, attributes)
+          nested_attributes_update_attributes(reflection, obj, attributes)
+          after_validation_hook{validate_associated_object(reflection, obj)}
+          # Don't need to validate the object twice if :validate association option is not false
+          # and don't want to validate it at all if it is false.
+          after_save_hook{obj.save_changes(:validate=>false)}
+          obj
         end
 
         # Update the attributes for the given object related to the current object through the association.

data/lib/sequel/plugins/optimistic_locking.rb

@@ -65,6 +65,14 @@ module Sequel
           lc = model.lock_column
           instance_filter(lc=>send(lc))
         end
+
+        # Clear the instance filters when refreshing, so that attempting to
+        # refresh after a failed save removes the previous lock column filter
+        # (the new one will be added before updating).
+        def _refresh(ds)
+          clear_instance_filters
+          super
+        end
         
         # Only update the row if it has the same lock version, and increment the
         # lock version.

data/lib/sequel/plugins/pg_row.rb

@@ -0,0 +1,121 @@
+module Sequel
+  module Plugins
+    # The pg_row plugin allows you to use Sequel::Model classes as composite type
+    # classes, via the pg_row extension.  So if you have an address table:
+    #
+    #   DB.create_table(:address) do
+    #     String :street
+    #     String :city
+    #     String :zip
+    #   end
+    #
+    # and a company table with an address:
+    #
+    #   DB.create_table(:company) do
+    #     String :name
+    #     address :address
+    #   end
+    # 
+    # You can create a Sequel::Model for the address table, and load the plugin,
+    # which registers the row type:
+    #
+    #   class Address < Sequel::Model(:address)
+    #     plugin :pg_row
+    #   end
+    #
+    # Then when you select from the company table (even using a plain dataset),
+    # it will return address values as instances of Address:
+    #
+    #   DB[:company].first
+    #   # => {:name=>'MS', :address=>
+    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345')}
+    #
+    # If you want a lot of your models to be used as row types, you can load the
+    # plugin into Sequel::Model itself:
+    #
+    #   Sequel::Model.plugin :pg_row
+    #
+    # And then call register_row_type in the class
+    #
+    #   Address.register_row_type
+    #
+    # Note that automatic conversion only works with the native postgres adapter.
+    # For other adapters that connect to PostgreSQL, you need to call the conversion
+    # proc manually.
+    #
+    # In addition to returning row-valued/composite types as instances of Sequel::Model,
+    # this also lets you use model instances in datasets when inserting, updating, and
+    # filtering:
+    #
+    #   DB[:company].insert(:name=>'MS', :address=>
+    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
+    module PgRow
+      # When loading the extension, make sure the database has the pg_row extension
+      # loaded, load the custom database extensions, and automatically register the
+      # row type if the model has a dataset.
+      def self.configure(model)
+        model.db.extension(:pg_row)
+        model.db.extend(DatabaseMethods)
+        model.register_row_type if model.instance_variable_get(:@dataset)
+      end
+
+      module DatabaseMethods
+        ESCAPE_RE = /("|\\)/.freeze
+        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        COMMA = ','
+
+        # Handle Sequel::Model instances in bound variables.
+        def bound_variable_arg(arg, conn)
+          case arg
+          when Sequel::Model
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
+          else
+            super
+          end
+        end
+
+        # If a Sequel::Model instance is given, return it as-is
+        # instead of attempting to convert it.
+        def row_type(db_type, v)
+          if v.is_a?(Sequel::Model)
+            v
+          else
+            super
+          end
+        end
+
+        private
+
+        # Handle Sequel::Model instances in bound variable arrays.
+        def bound_variable_array(arg)
+          case arg
+          when Sequel::Model
+            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+          else
+            super
+          end
+        end
+      end
+
+      module ClassMethods
+        # Register the model's row type with the database.
+        def register_row_type
+          db.register_row_type(model.table_name, :converter=>self, :typecaster=>method(:new))
+        end
+      end
+
+      module InstanceMethods
+        ROW = 'ROW'.freeze
+        CAST = '::'.freeze
+
+        # Literalize the model instance and append it to the sql.
+        def sql_literal_append(ds, sql)
+          sql << ROW
+          ds.literal_append(sql, values.values_at(*columns))
+          sql << CAST
+          ds.quote_schema_table_append(sql, model.table_name)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -0,0 +1,65 @@
+module Sequel
+  module Plugins
+    # The PgTypecastOnLoad plugin exists because when you connect to PostgreSQL
+    # using the do, swift, or jdbc adapter, Sequel doesn't have complete
+    # control over typecasting, and may return columns as strings instead of how
+    # the native postgres adapter would typecast them.  This is mostly needed for
+    # the additional support that the pg_* extensions add for advanced PostgreSQL
+    # types such as arrays.
+    #
+    # This plugin modifies Model#set_values to do the same conversion that the
+    # native postgres adapter would do for all columns given.  You can either
+    # specify the columns to typecast on load in the plugin call itself, or
+    # afterwards using add_pg_typecast_on_load_columns:
+    #
+    #   # aliases => text[] column
+    #   # config => hstore column
+    #
+    #   Album.plugin :pg_typecast_on_load, :aliases, :config
+    #   # or:
+    #   Album.plugin :pg_typecast_on_load
+    #   Album.add_pg_typecast_on_load_columns :aliases, :config
+    #
+    # This plugin only handles values that the adapter returns as strings.  If
+    # the adapter returns a value other than a string for a column, that value
+    # will be used directly without typecasting.
+    module PgTypecastOnLoad
+      # Call add_pg_typecast_on_load_columns on the passed column arguments.
+      def self.configure(model, *columns)
+        model.instance_eval do
+          @pg_typecast_on_load_columns ||= []
+          add_pg_typecast_on_load_columns(*columns)
+        end
+      end
+
+      module ClassMethods
+        # The columns to typecast on load for this model.
+        attr_reader :pg_typecast_on_load_columns
+
+        # Add additional columns to typecast on load for this model.
+        def add_pg_typecast_on_load_columns(*columns)
+          @pg_typecast_on_load_columns.concat(columns)
+        end
+
+        # Give the subclass a copy of the columns to typecast on load.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@pg_typecast_on_load_columns, pg_typecast_on_load_columns.dup)
+        end
+      end
+
+      module InstanceMethods
+        # Lookup the conversion proc for the column's oid in the Database
+        # object, and use it to convert the value.
+        def set_values(values)
+          model.pg_typecast_on_load_columns.each do |c|
+            if (v = values[c]).is_a?(String) && (oid = db_schema[c][:oid])
+              values[c] = db.conversion_procs[oid].call(v)
+            end
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/prepared_statements.rb

@@ -0,0 +1,167 @@
+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=>{}, :fixed=>{})
+      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=>{}, :fixed=>{})
+        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={})
+          ps = ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
+          ps.log_sql = true
+          ps
+        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
+          cached_prepared_statement(:fixed, :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)
+          cached_prepared_statement(: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?
+            cached_prepared_statement(: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
+          cached_prepared_statement(:fixed, :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
+          cached_prepared_statement(:fixed, :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)
+          if dataset.requires_placeholder_type_specifiers?
+            sch = db_schema
+            Array(keys).map do |k|
+              if (s = sch[k]) && (t = s[:type])
+                [k, :"$#{k}__#{t}"]
+              else
+                [k, :"$#{k}"]
+              end
+            end
+          else
+            Array(keys).map{|k| [k, :"$#{k}"]}
+          end
+        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)
+          cached_prepared_statement(: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
+
+        private
+
+        # If a prepared statement has already been cached for the given type and subtype,
+        # return it.  Otherwise, yield to the block to get the prepared statement, and cache it.
+        def cached_prepared_statement(type, subtype)
+          h = @prepared_statements[type]
+          Sequel.synchronize do
+            if v = h[subtype]
+              return v end
+          end
+          ps = yield
+          Sequel.synchronize{h[subtype] = ps}
+        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