sequel 4.26.0 → 5.37.0

data/lib/sequel/dataset/misc.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Dataset
     # ---------------------
@@ -5,11 +7,6 @@ module Sequel
     # These methods don't fit cleanly into another section.
     # ---------------------
     
-    NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
-    ARRAY_ACCESS_ERROR_MSG = 'You cannot call Dataset#[] with an integer or with no arguments.'.freeze
-    ARG_BLOCK_ERROR_MSG = 'Must use either an argument or a block, not both'.freeze
-    IMPORT_ERROR_MSG = 'Using Sequel::Dataset#import an empty column array is not allowed'.freeze
-    
     # The database related to this dataset.  This is the Database instance that
     # will execute all of this dataset's queries.
     attr_reader :db
@@ -28,12 +25,14 @@ module Sequel
     def initialize(db)
       @db = db
       @opts = OPTS
+      @cache = {}
+      freeze
     end
 
-    # Define a hash value such that datasets with the same DB, opts, and SQL
+    # Define a hash value such that datasets with the same class, DB, and opts
     # will be considered equal.
     def ==(o)
-      o.is_a?(self.class) && db == o.db && opts == o.opts && sql == o.sql
+      o.is_a?(self.class) && db == o.db && opts == o.opts
     end
 
     # An object representing the current date or time, should be an instance
@@ -47,18 +46,16 @@ module Sequel
       self == o
     end
 
-    # Similar to #clone, but returns an unfrozen clone if the receiver is frozen.
+    # Return self, as datasets are always frozen.
     def dup
-      o = clone
-      o.instance_variable_set(:@frozen, false) if frozen?
-      o
+      self
     end
     
     # Yield a dataset for each server in the connection pool that is tied to that server.
     # Intended for use in sharded environments where all servers need to be modified
     # with the same data:
     #
-    #   DB[:configs].where(:key=>'setting').each_server{|ds| ds.update(:value=>'new_value')}
+    #   DB[:configs].where(key: 'setting').each_server{|ds| ds.update(value: 'new_value')}
     def each_server
       db.servers.each{|s| yield server(s)}
     end
@@ -72,15 +69,22 @@ module Sequel
       string.gsub(/[\\%_]/){|m| "\\#{m}"}
     end
 
-    # Sets the frozen flag on the dataset, so you can't modify it. Returns the receiver.
-    def freeze
-      @frozen = true
-      self
-    end
+    if TRUE_FREEZE
+      # Freeze the opts when freezing the dataset.
+      def freeze
+        @opts.freeze
+        super
+      end
+    else
+      # :nocov:
+      def freeze # :nodoc:
+        self
+      end
 
-    # Whether the object is frozen.
-    def frozen?
-      @frozen == true
+      def frozen?  # :nodoc:
+        true
+      end
+      # :nocov:
     end
    
     # Alias of +first_source_alias+
@@ -94,7 +98,7 @@ module Sequel
     #   DB[:table].first_source_alias
     #   # => :table
     #
-    #   DB[:table___t].first_source_alias
+    #   DB[Sequel[:table].as(:t)].first_source_alias
     #   # => :t
     def first_source_alias
       source = @opts[:from]
@@ -119,7 +123,7 @@ module Sequel
     #   DB[:table].first_source_table
     #   # => :table
     #
-    #   DB[:table___t].first_source_table
+    #   DB[Sequel[:table].as(:t)].first_source_table
     #   # => :table
     def first_source_table
       source = @opts[:from]
@@ -137,30 +141,10 @@ module Sequel
       end
     end
 
-    # Define a hash value such that datasets with the same DB, opts, and SQL
-    # will have the same hash value
+    # Define a hash value such that datasets with the same class, DB, and opts,
+    # will have the same hash value.
     def hash
-      [db, opts, sql].hash
-    end
-    
-    # The String instance method to call on identifiers before sending them to
-    # the database.
-    def identifier_input_method
-      if defined?(@identifier_input_method)
-        @identifier_input_method
-      else
-        @identifier_input_method = db.identifier_input_method
-      end
-    end
-    
-    # The String instance method to call on identifiers before sending them to
-    # the database.
-    def identifier_output_method
-      if defined?(@identifier_output_method)
-        @identifier_output_method
-      else
-        @identifier_output_method = db.identifier_output_method
-      end
+      [self.class, db, opts].hash
     end
     
     # Returns a string representation of the dataset including the class name 
@@ -180,6 +164,12 @@ module Sequel
       :x_sequel_row_number_x
     end
 
+    # The row_proc for this database, should be any object that responds to +call+ with
+    # a single hash argument and returns the object you want #each to return.
+    def row_proc
+      @opts[:row_proc]
+    end
+    
     # Splits a possible implicit alias in +c+, handling both SQL::AliasedExpressions
     # and Symbols.  Returns an array of two elements, with the first being the
     # main expression, and the second being the alias.
@@ -201,7 +191,7 @@ module Sequel
     # SQL identifier that represents the unqualified column for the given value.
     # The given value should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier,
     # or SQL::AliasedExpression containing one of those.  In other cases, this
-    # returns nil
+    # returns nil.
     def unqualified_column_for(v)
       unless v.is_a?(String)
         _unqualified_column_for(v)
@@ -236,7 +226,7 @@ module Sequel
       used_aliases += opts[:join].map{|j| j.table_alias ? alias_alias_symbol(j.table_alias) : alias_symbol(j.table)} if opts[:join]
       if used_aliases.include?(table_alias)
         i = 0
-        loop do
+        while true
           ta = :"#{table_alias}_#{i}"
           return ta unless used_aliases.include?(ta)
           i += 1 
@@ -246,8 +236,110 @@ module Sequel
       end
     end
 
+    # Return a modified dataset with quote_identifiers set.
+    def with_quote_identifiers(v)
+      clone(:quote_identifiers=>v, :skip_symbol_cache=>true)
+    end
+      
+    protected
+
+    # Access the cache for the current dataset.  Should be used with caution,
+    # as access to the cache is not thread safe without a mutex if other
+    # threads can reference the dataset.  Symbol keys prefixed with an
+    # underscore are reserved for internal use.
+    attr_reader :cache
+
+    # Retreive a value from the dataset's cache in a thread safe manner.
+    def cache_get(k)
+      Sequel.synchronize{@cache[k]}
+    end
+
+    # Set a value in the dataset's cache in a thread safe manner.
+    def cache_set(k, v)
+      Sequel.synchronize{@cache[k] = v}
+    end
+
+    # Clear the columns hash for the current dataset.  This is not a
+    # thread safe operation, so it should only be used if the dataset
+    # could not be used by another thread (such as one that was just
+    # created via clone).
+    def clear_columns_cache
+      @cache.delete(:_columns)
+    end
+
+    # The cached columns for the current dataset.
+    def _columns
+      cache_get(:_columns)
+    end
+
     private
 
+    # Check the cache for the given key, returning the value.
+    # Otherwise, yield to get the dataset and cache the dataset under the given key.
+    def cached_dataset(key)
+      unless ds = cache_get(key)
+        ds = yield
+        cache_set(key, ds)
+      end
+
+      ds
+    end
+
+    # Return a cached placeholder literalizer for the given key if there
+    # is one for this dataset.  If there isn't one, increment the counter
+    # for the number of calls for the key, and if the counter is at least
+    # three, then create a placeholder literalizer by yielding to the block,
+    # and cache it.
+    def cached_placeholder_literalizer(key)
+      if loader = cache_get(key)
+        return loader unless loader.is_a?(Integer)
+        loader += 1
+
+        if loader >= 3
+          loader = Sequel::Dataset::PlaceholderLiteralizer.loader(self){|pl, _| yield pl}
+          cache_set(key, loader)
+        else
+          cache_set(key, loader + 1)
+          loader = nil
+        end
+      elsif cache_sql?
+        cache_set(key, 1)
+      end
+
+      loader
+    end
+
+    # Return a cached placeholder literalizer for the key, unless where_block is
+    # nil and where_args is an empty array or hash.  This is designed to guard
+    # against placeholder literalizer use when passing arguments to where
+    # in the uncached case and filter_expr if a cached placeholder literalizer
+    # is used.
+    def cached_where_placeholder_literalizer(where_args, where_block, key, &block)
+      where_args = where_args[0] if where_args.length == 1
+      unless where_block
+        return if where_args == OPTS || where_args == EMPTY_ARRAY
+      end
+
+      cached_placeholder_literalizer(key, &block)
+    end
+
+    # Set the columns for the current dataset.
+    def columns=(v)
+      cache_set(:_columns, v)
+    end
+
+    # Set the db, opts, and cache for the copy of the dataset.
+    def initialize_clone(c, _=nil)
+      @db = c.db
+      @opts = Hash[c.opts]
+      if cols = c.cache_get(:_columns)
+        @cache = {:_columns=>cols}
+      else
+        @cache = {}
+      end
+    end
+    alias initialize_copy initialize_clone
+
     # Internal recursive version of unqualified_column_for, handling Strings inside
     # of other objects.
     def _unqualified_column_for(v)

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Dataset
     # PlaceholderLiteralizer allows you to record the application of arbitrary changes
@@ -13,7 +15,7 @@ module Sequel
     # Example:
     #
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
-    #     ds.where(:id=>pl.arg).exclude(:name=>pl.arg).limit(1)
+    #     ds.where(id: pl.arg).exclude(name: pl.arg).limit(1)
     #   end
     #   loader.first(1, "foo")
     #   # SELECT * FROM items WHERE ((id = 1) AND (name != 'foo')) LIMIT 1
@@ -25,7 +27,7 @@ module Sequel
     # Note that this method does not handle all possible cases.  For example:
     #
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
-    #     ds.join(pl.arg, :item_id=>:id)
+    #     ds.join(pl.arg, item_id: :id)
     #   end
     #   loader.all(:cart_items)
     #  
@@ -33,7 +35,7 @@ module Sequel
     # best to add a table alias when joining:
     #
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
-    #     ds.join(Sequel.as(pl.arg, :t), :item_id=>:id)
+    #     ds.join(Sequel.as(pl.arg, :t), item_id: :id)
     #   end
     #   loader.all(:cart_items)
     #
@@ -49,6 +51,7 @@ module Sequel
           @recorder = recorder
           @pos = pos
           @transformer = transformer
+          freeze
         end
 
         # Record the SQL query offset, argument position, and transforming block where the
@@ -74,23 +77,8 @@ module Sequel
         # Yields the receiver and the dataset to the block, which should
         # call #arg on the receiver for each placeholder argument, and
         # return the dataset that you want to load.
-        def loader(dataset)
-          @argn = -1
-          @args = []
-          ds = yield self, dataset
-          sql = ds.clone(:placeholder_literalizer=>self).sql
-
-          last_offset = 0
-          fragments = @args.map do |used_sql, offset, arg, t|
-            raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
-            a = [sql[last_offset...offset], arg, t]
-            last_offset = offset
-            a
-          end
-          final_sql = sql[last_offset..-1]
-
-          arity = @argn+1
-          PlaceholderLiteralizer.new(ds.clone, fragments, final_sql, arity)
+        def loader(dataset, &block)
+          PlaceholderLiteralizer.new(*process(dataset, &block))
         end
 
         # Return an Argument with the specified position, or the next position. In
@@ -104,10 +92,53 @@ module Sequel
         end
 
         # Record the offset at which the argument is used in the SQL query, and any
-        # transforming
+        # transforming block.
         def use(sql, arg, transformer)
           @args << [sql, sql.length, arg, transformer]
         end
+
+        private
+
+        # Return an array with two elements, the first being an
+        # SQL string with interpolated prepared argument placeholders
+        # (suitable for inspect), the the second being an array of
+        # SQL fragments suitable for using for creating a 
+        # Sequel::SQL::PlaceholderLiteralString. Designed for use with
+        # emulated prepared statements.
+        def prepared_sql_and_frags(dataset, prepared_args, &block)
+          _, frags, final_sql, _ = process(dataset, &block)
+
+          frags = frags.map(&:first)
+          prepared_sql = String.new
+          frags.each_with_index do |sql, i|
+            prepared_sql << sql
+            prepared_sql << "$#{prepared_args[i]}"
+          end
+          frags << final_sql
+          prepared_sql << final_sql
+
+          [prepared_sql, frags]
+        end
+
+        # Internals of #loader and #prepared_sql_and_frags.
+        def process(dataset)
+          @argn = -1
+          @args = []
+          ds = yield self, dataset
+          sql = ds.clone(:placeholder_literalizer=>self).sql
+
+          last_offset = 0
+          fragments = @args.map do |used_sql, offset, arg, t|
+            raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
+            a = [sql[last_offset...offset], arg, t]
+            last_offset = offset
+            a
+          end
+          final_sql = sql[last_offset..-1]
+
+          arity = @argn+1
+          [ds, fragments, final_sql, arity]
+        end
       end
 
       # Create a PlaceholderLiteralizer by yielding a Recorder and dataset to the
@@ -123,13 +154,24 @@ module Sequel
         @fragments = fragments
         @final_sql = final_sql
         @arity = arity
+        freeze
+      end
+
+      # Freeze the fragments and final SQL when freezing the literalizer.
+      def freeze
+        @fragments.freeze
+        @final_sql.freeze
+        super
       end
 
       # Return a new PlaceholderLiteralizer with a modified dataset.  This yields the
       # receiver's dataset to the block, and the block should return the new dataset
       # to use.
       def with_dataset
-        dup.instance_exec{@dataset = yield @dataset; self}
+        dataset = yield @dataset
+        other = dup
+        other.instance_variable_set(:@dataset, dataset)
+        other.freeze
       end
 
       # Return an array of all objects by running the SQL query for the given arguments.
@@ -157,7 +199,7 @@ module Sequel
       # Return the SQL query to use for the given arguments.
       def sql(*args)
         raise Error, "wrong number of arguments (#{args.length} for #{@arity})" unless args.length == @arity
-        s = ''
+        s = String.new
         ds = @dataset
         @fragments.each do |sql, i, transformer|
           s << sql
@@ -169,9 +211,7 @@ module Sequel
           end
           ds.literal_append(s, v)
         end
-        if sql = @final_sql
-          s << sql
-        end
+        s << @final_sql
         s
       end
     end

data/lib/sequel/dataset/prepared_statements.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel 
   class Dataset
     # ---------------------
@@ -34,33 +36,44 @@ module Sequel
       end
     end
     private_class_method :prepared_statements_module
-    
+
     # Default implementation of the argument mapper to allow
     # native database support for bind variables and prepared
     # statements (as opposed to the emulated ones used by default).
     module ArgumentMapper
       # The name of the prepared statement, if any.
-      attr_accessor :prepared_statement_name
-      
+      def prepared_statement_name
+        @opts[:prepared_statement_name]
+      end
+
       # The bind arguments to use for running this prepared statement
-      attr_accessor :bind_arguments
+      def bind_arguments
+        @opts[:bind_arguments]
+      end
 
       # Set the bind arguments based on the hash and call super.
-      def call(bind_vars={}, &block)
-        ds = bind(bind_vars)
-        ds.prepared_sql
-        ds.bind_arguments = ds.map_to_prepared_args(ds.opts[:bind_vars])
-        ds.run(&block)
+      def call(bind_vars=OPTS, &block)
+        sql = prepared_sql
+        prepared_args.freeze
+        ps = bind(bind_vars)
+        ps.clone(:bind_arguments=>ps.map_to_prepared_args(ps.opts[:bind_vars]), :sql=>sql, :prepared_sql=>sql).run(&block)
       end
         
       # Override the given *_sql method based on the type, and
       # cache the result of the sql.
       def prepared_sql
-        return @prepared_sql if @prepared_sql
-        @prepared_args ||= []
-        @prepared_sql = super
-        @opts[:sql] = @prepared_sql
-        @prepared_sql
+        if sql = @opts[:prepared_sql] || cache_get(:_prepared_sql)
+          return sql
+        end
+        cache_set(:_prepared_sql, super)
+      end
+
+      private
+
+      # Report that prepared statements are not emulated, since
+      # all adapters that use this use native prepared statements.
+      def emulate_prepared_statements?
+        false
       end
     end
 
@@ -71,29 +84,37 @@ module Sequel
     # into the query, which works on all databases, as it is no different
     # from using the dataset without bind variables.
     module PreparedStatementMethods
-      PLACEHOLDER_RE = /\A\$(.*)\z/
-      
       # Whether to log the full SQL query.  By default, just the prepared statement
       # name is generally logged on adapters that support native prepared statements.
-      attr_accessor :log_sql
+      def log_sql
+        @opts[:log_sql]
+      end
       
       # The type of prepared statement, should be one of :select, :first,
-      # :insert, :update, or :delete
-      attr_accessor :prepared_type
+      # :insert, :update, :delete, or :single_value
+      def prepared_type
+        @opts[:prepared_type]
+      end
       
       # The array/hash of bound variable placeholder names.
-      attr_accessor :prepared_args
+      def prepared_args
+        @opts[:prepared_args]
+      end
       
       # The dataset that created this prepared statement.
-      attr_accessor :orig_dataset
+      def orig_dataset
+        @opts[:orig_dataset]
+      end
       
       # The argument to supply to insert and update, which may use
       # placeholders specified by prepared_args
-      attr_accessor :prepared_modify_values
+      def prepared_modify_values
+        @opts[:prepared_modify_values]
+      end
 
       # Sets the prepared_args to the given hash and runs the
       # prepared statement.
-      def call(bind_vars={}, &block)
+      def call(bind_vars=OPTS, &block)
         bind(bind_vars).run(&block)
       end
 
@@ -110,21 +131,27 @@ module Sequel
         orig_dataset.columns
       end
       
+      # Disallow use of delayed evaluations in prepared statements.
+      def delayed_evaluation_sql_append(sql, delay)
+        raise Error, "delayed evaluations cannot be used in prepared statements" if @opts[:no_delayed_evaluations]
+        super
+      end
+
       # Returns the SQL for the prepared statement, depending on
       # the type of the statement and the prepared_modify_values.
       def prepared_sql
-        case @prepared_type
+        case prepared_type
         when :select, :all, :each
           # Most common scenario, so listed first.
           select_sql
-        when :first
+        when :first, :single_value
           clone(:limit=>1).select_sql
         when :insert_select
-          insert_select_sql(*@prepared_modify_values)
-        when :insert
-          insert_sql(*@prepared_modify_values)
+          insert_select_sql(*prepared_modify_values)
+        when :insert, :insert_pk
+          insert_sql(*prepared_modify_values)
         when :update
-          update_sql(*@prepared_modify_values)
+          update_sql(*prepared_modify_values)
         when :delete
           delete_sql
         else
@@ -136,13 +163,8 @@ module Sequel
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
       def literal_symbol_append(sql, v)
-        if @opts[:bind_vars] and match = PLACEHOLDER_RE.match(v.to_s)
-          s = match[1].to_sym
-          if prepared_arg?(s)
-            literal_append(sql, prepared_arg(s))
-          else
-            sql << v.to_s
-          end
+        if @opts[:bind_vars] && /\A\$(.*)\z/ =~ v
+          literal_append(sql, prepared_arg($1.to_sym))
         else
           super
         end
@@ -157,13 +179,10 @@ module Sequel
       
       protected
       
-      # Run the method based on the type of prepared statement, with
-      # :select running #all to get all of the rows, and the other
-      # types running the method with the same name as the type.
+      # Run the method based on the type of prepared statement.
       def run(&block)
-        case @prepared_type
+        case prepared_type
         when :select, :all
-          # Most common scenario, so listed first
           all(&block)
         when :each
           each(&block)
@@ -172,20 +191,24 @@ module Sequel
         when :first
           first
         when :insert, :update, :delete
-          if opts[:returning] && supports_returning?(@prepared_type)
+          if opts[:returning] && supports_returning?(prepared_type)
             returning_fetch_rows(prepared_sql)
-          elsif @prepared_type == :delete
+          elsif prepared_type == :delete
             delete
           else
-            send(@prepared_type, *@prepared_modify_values)
+            public_send(prepared_type, *prepared_modify_values)
           end
+        when :insert_pk
+          fetch_rows(prepared_sql){|r| return r.values.first}
         when Array
-          case @prepared_type.at(0)
-          when :map, :to_hash, :to_hash_groups
-            send(*@prepared_type, &block) 
+          case prepared_type[0]
+          when :map, :as_hash, :to_hash, :to_hash_groups
+            public_send(*prepared_type, &block) 
           end
+        when :single_value
+          single_value
         else
-          all(&block)
+          raise Error, "unsupported prepared statement type used: #{prepared_type.inspect}"
         end
       end
       
@@ -196,13 +219,7 @@ module Sequel
         @opts[:bind_vars][k]
       end
 
-      # Whether there is a bound value for the given key.
-      def prepared_arg?(k)
-        @opts[:bind_vars].has_key?(k)
-      end
-
-      # The symbol cache should always be skipped, since placeholders
-      # are symbols.
+      # The symbol cache should always be skipped, since placeholders are symbols.
       def skip_symbol_cache?
         true
       end
@@ -211,10 +228,12 @@ module Sequel
       # support and using the same argument hash so that you can use
       # bind variables/prepared arguments in subselects.
       def subselect_sql_append(sql, ds)
-        ps = ds.clone(:append_sql=>sql).prepare(:select)
-        ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-        ps.prepared_args = prepared_args
-        ps.prepared_sql
+        subselect_sql_dataset(sql, ds).prepared_sql
+      end
+
+      def subselect_sql_dataset(sql, ds)
+        super.clone(:prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+          send(:to_prepared_statement, :select, nil, :extend=>prepared_statement_modules)
       end
     end
     
@@ -242,56 +261,126 @@ module Sequel
         prepared_args << k
         prepared_arg_placeholder
       end
+    end
+    
+    # Prepared statements emulation support for adapters that don't
+    # support native prepared statements.  Uses a placeholder
+    # literalizer to hold the prepared sql with the ability to
+    # interpolate arguments to prepare the final SQL string.
+    module EmulatePreparedStatementMethods
+      include UnnumberedArgumentMapper
+
+      def run(&block)
+        if @opts[:prepared_sql_frags]
+          sql = literal(Sequel::SQL::PlaceholderLiteralString.new(@opts[:prepared_sql_frags], @opts[:bind_arguments], false))
+          clone(:prepared_sql_frags=>nil, :sql=>sql, :prepared_sql=>sql).run(&block)
+        else
+          super
+        end
+      end
+
+      private
       
-      # Always assume there is a prepared arg in the argument mapper.
-      def prepared_arg?(k)
+      # Turn emulation of prepared statements back on, since ArgumentMapper
+      # turns it off.
+      def emulate_prepared_statements?
         true
       end
+        
+      def emulated_prepared_statement(type, name, values)
+        prepared_sql, frags = Sequel::Dataset::PlaceholderLiteralizer::Recorder.new.send(:prepared_sql_and_frags, self, prepared_args) do |pl, ds|
+          ds = ds.clone(:recorder=>pl)
+
+          case type
+          when :first, :single_value
+            ds.limit(1)
+          when :update, :insert, :insert_select, :delete
+            ds.with_sql(:"#{type}_sql", *values)
+          when :insert_pk
+            ds.with_sql(:insert_sql, *values)
+          else
+            ds
+          end
+        end
+
+        prepared_args.freeze
+        clone(:prepared_sql_frags=>frags, :prepared_sql=>prepared_sql, :sql=>prepared_sql)
+      end
+
+      # Associates the argument with name k with the next position in
+      # the output array.
+      def prepared_arg(k)
+        prepared_args << k
+        @opts[:recorder].arg
+      end
+
+      def subselect_sql_dataset(sql, ds)
+        super.clone(:recorder=>@opts[:recorder]).
+          with_extend(EmulatePreparedStatementMethods)
+      end
     end
     
     # Set the bind variables to use for the call.  If bind variables have
     # already been set for this dataset, they are updated with the contents
     # of bind_vars.
     #
-    #   DB[:table].filter(:id=>:$id).bind(:id=>1).call(:first)
+    #   DB[:table].where(id: :$id).bind(id: 1).call(:first)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
-    def bind(bind_vars={})
-      clone(:bind_vars=>@opts[:bind_vars] ? Hash[@opts[:bind_vars]].merge!(bind_vars) : bind_vars)
+    def bind(bind_vars=OPTS)
+      bind_vars = if bv = @opts[:bind_vars]
+        bv.merge(bind_vars).freeze
+      else
+        if bind_vars.frozen?
+          bind_vars
+        else
+          Hash[bind_vars]
+        end
+      end
+
+      clone(:bind_vars=>bind_vars)
     end
     
-    # For the given type (:select, :first, :insert, :insert_select, :update, or :delete),
+    # For the given type (:select, :first, :insert, :insert_select, :update, :delete, or :single_value),
     # run the sql with the bind variables specified in the hash.  +values+ is a hash passed to
     # insert or update (if one of those types is used), which may contain placeholders.
     #
-    #   DB[:table].filter(:id=>:$id).call(:first, :id=>1)
+    #   DB[:table].where(id: :$id).call(:first, id: 1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
-    def call(type, bind_variables={}, *values, &block)
-      prepare(type, nil, *values).call(bind_variables, &block)
+    def call(type, bind_variables=OPTS, *values, &block)
+      to_prepared_statement(type, values, :extend=>bound_variable_modules).call(bind_variables, &block)
     end
     
     # Prepare an SQL statement for later execution.  Takes a type similar to #call,
-    # and the +name+ symbol of the prepared statement.  While +name+ defaults to +nil+,
-    # it should always be provided as a symbol for the name of the prepared statement,
-    # as some databases require that prepared statements have names.
+    # and the +name+ symbol of the prepared statement.
     #
     # This returns a clone of the dataset extended with PreparedStatementMethods,
     # which you can +call+ with the hash of bind variables to use.
     # The prepared statement is also stored in
-    # the associated database, where it can be called by name.
+    # the associated Database, where it can be called by name.
     # The following usage is identical:
     #
-    #   ps = DB[:table].filter(:name=>:$name).prepare(:first, :select_by_name)
+    #   ps = DB[:table].where(name: :$name).prepare(:first, :select_by_name)
     #
-    #   ps.call(:name=>'Blah')
+    #   ps.call(name: 'Blah')
     #   # SELECT * FROM table WHERE name = ? -- ('Blah')
     #   # => {:id=>1, :name=>'Blah'}
     #
-    #   DB.call(:select_by_name, :name=>'Blah') # Same thing
-    def prepare(type, name=nil, *values)
-      ps = to_prepared_statement(type, values)
-      db.set_prepared_statement(name, ps) if name
+    #   DB.call(:select_by_name, name: 'Blah') # Same thing
+    def prepare(type, name, *values)
+      ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules, :no_delayed_evaluations=>true)
+
+      ps = if ps.send(:emulate_prepared_statements?)
+        ps = ps.with_extend(EmulatePreparedStatementMethods)
+        ps.send(:emulated_prepared_statement, type, name, values)
+      else
+        sql = ps.prepared_sql
+        ps.prepared_args.freeze
+        ps.clone(:prepared_sql=>sql, :sql=>sql)
+      end
+
+      db.set_prepared_statement(name, ps)
       ps
     end
     
@@ -299,13 +388,13 @@ module Sequel
     
     # Return a cloned copy of the current dataset extended with
     # PreparedStatementMethods, setting the type and modify values.
-    def to_prepared_statement(type, values=nil)
-      ps = bind
-      ps.extend(PreparedStatementMethods)
-      ps.orig_dataset = self
-      ps.prepared_type = type
-      ps.prepared_modify_values = values
-      ps
+    def to_prepared_statement(type, values=nil, opts=OPTS)
+      mods = opts[:extend] || []
+      mods += [PreparedStatementMethods]
+
+      bind.
+        clone(:prepared_statement_name=>opts[:name], :prepared_type=>type, :prepared_modify_values=>values, :orig_dataset=>self, :no_cache_sql=>true, :prepared_args=>@opts[:prepared_args]||[], :no_delayed_evaluations=>opts[:no_delayed_evaluations]).
+        with_extend(*mods)
     end
 
     private
@@ -315,6 +404,20 @@ module Sequel
       false
     end
 
+    def bound_variable_modules
+      prepared_statement_modules
+    end
+
+    # Whether prepared statements should be emulated.  True by
+    # default so that adapters have to opt in.
+    def emulate_prepared_statements?
+      true
+    end
+
+    def prepared_statement_modules
+      []
+    end
+
     # The argument placeholder.  Most databases used unnumbered
     # arguments with question marks, so that is the default.
     def prepared_arg_placeholder