sequel 4.42.1 → 4.43.0

data/lib/sequel/plugins/pg_row.rb

@@ -56,49 +56,10 @@ module Sequel
       # 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.db.extension(:pg_row, :_model_pg_row)
         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

data/lib/sequel/plugins/prepared_statements.rb

@@ -1,22 +1,11 @@
 # frozen-string-literal: true
 
 module Sequel
-  class Model
-    module InstanceMethods
-      # Whether prepared statements should be used for the given type of query
-      # (:insert, :insert_select, :refresh, :update, or :delete).  True by default,
-      # can be overridden in other plugins to disallow prepared statements for
-      # specific types of queries.
-      def use_prepared_statements_for?(type)
-        true
-      end
-    end
-  end
-
   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.
+    # instance level saves (inserts and updates).  It also will use prepared statements for
+    # deletes, refreshes, and class level lookups by primary key, if it thinks that using
+    # a prepared statement will be faster in such cases.
     #
     # 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
@@ -132,7 +121,7 @@ module Sequel
 
         # Use a prepared statement to query the database for the row matching the given primary key.
         def primary_key_lookup(pk)
-          return super if dataset.joined_dataset?
+          return super unless use_prepared_statements_for_pk_lookup?
           prepared_lookup.call(primary_key_hash(pk))
         end
 
@@ -148,6 +137,12 @@ module Sequel
           ps = yield
           Sequel.synchronize{h[subtype] = ps}
         end
+
+        # Whether to use prepared statements for lookups by primary key.  True if the default
+        # primary key lookup isn't optimized.
+        def use_prepared_statements_for_pk_lookup?
+          !@fast_pk_lookup_sql && !dataset.joined_dataset?
+        end
       end
 
       module InstanceMethods
@@ -156,7 +151,7 @@ module Sequel
         # Use a prepared statement to delete the row.
         def _delete_without_checking
           if use_prepared_statements_for?(:delete)
-            model.send(:prepared_delete).call(pk_hash)
+            _set_prepared_statement_server(model.send(:prepared_delete)).call(pk_hash)
           else
             super
           end
@@ -165,7 +160,7 @@ module Sequel
         # Use a prepared statement to insert the values into the model's dataset.
         def _insert_raw(ds)
           if use_prepared_statements_for?(:insert)
-            model.send(:prepared_insert, @values.keys).call(@values)
+            _set_prepared_statement_server(model.send(:prepared_insert, @values.keys)).call(@values)
           else
             super
           end
@@ -176,7 +171,7 @@ module Sequel
         def _insert_select_raw(ds)
           if use_prepared_statements_for?(:insert_select)
             if ps = model.send(:prepared_insert_select, @values.keys)
-              ps.call(@values)
+              _set_prepared_statement_server(ps).call(@values)
             end
           else
             super
@@ -186,7 +181,7 @@ module Sequel
         # Use a prepared statement to refresh this model's column values.
         def _refresh_get(ds)
           if use_prepared_statements_for?(:refresh)
-            model.send(:prepared_refresh).call(pk_hash)
+            _set_prepared_statement_server(model.send(:prepared_refresh)).call(pk_hash)
           else
             super
           end
@@ -195,11 +190,47 @@ module Sequel
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
           if use_prepared_statements_for?(:update)
-            model.send(:prepared_update, columns.keys).call(Hash[columns].merge!(pk_hash))
+            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(Hash[columns].merge!(pk_hash))
           else
             super
           end
         end
+
+        # If a server is set for the instance, return a prepared statement that will use that server.
+        def _set_prepared_statement_server(ps)
+          if @server
+            ps.server(@server)
+          else
+            ps
+          end
+        end
+
+        # Whether prepared statements should be used for the given type of query
+        # (:insert, :insert_select, :refresh, :update, or :delete).  True by default,
+        # can be overridden in other plugins to disallow prepared statements for
+        # specific types of queries.
+        def use_prepared_statements_for?(type)
+          if defined?(super)
+            result = super
+            return result unless result.nil?
+          end
+
+          case type
+          when :insert, :insert_select, :update
+            true
+          when :delete
+            return true unless model.fast_instance_delete_sql
+
+            # Using deletes for prepared statements appears faster on Oracle and DB2,
+            # but not for most other database types if optimized SQL is used.
+            db_type = model.db.database_type
+            db_type == :oracle || db_type == :db2
+          when :refresh
+            !model.fast_pk_lookup_sql
+          else
+            raise Error, "unsupported type used: #{type.inspect}"
+          end
+        end
       end
     end
   end

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -8,6 +8,10 @@ module Sequel
     # statements for associations where it will not work, assuming you load the
     # plugin before defining the associations.
     #
+    # Note that in most cases, this plugin will probably make things slower,
+    # so you should only use it if you really want to use prepared statements
+    # to load associations.
+    #
     # Usage:
     #
     #   # Make all model subclasses more safe when using prepared statements (called before loading subclasses)
@@ -27,6 +31,12 @@ module Sequel
       module InstanceMethods
         private
 
+        # Mark that associated objects should use the same server.
+        def _associated_objects_use_same_server?
+          return super if defined?(super)
+          false
+        end
+
         # 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)
@@ -36,6 +46,8 @@ module Sequel
         # Given an association reflection, return a bound variable hash for the given
         # association for this instance's values.
         def association_bound_variables(opts)
+          return if opts[:instance_specific]
+
           case opts[:type]
           when :many_to_one
             association_bound_variable_hash(opts.associated_class.table_name, opts.primary_keys, opts[:keys])
@@ -53,7 +65,7 @@ module Sequel
         # instance.  Return false if such a prepared statement cannot be created.
         def association_prepared_statement(opts, assoc_bv)
           return unless model.cache_associations
-          opts.send(:cached_fetch, :prepared_statement) do
+          ps = opts.send(:cached_fetch, :prepared_statement) do
             unless opts[:instance_specific]
               ds, bv = _associated_dataset(opts, {}).unbind
 
@@ -80,12 +92,18 @@ module Sequel
               ds.clone(:log_sql=>true).prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
             end
           end
+
+          if ps && @server && _associated_objects_use_same_server?
+            ps = ps.server(@server)
+          end
+
+          ps
         end
 
         # Use a prepared statement if possible to load the associated object,
         # unless a dynamic callback is given.
         def _load_associated_object(opts, dynamic_opts)
-          if !dynamic_opts[:callback] && (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+          if !dynamic_opts[:callback] && (bv = association_bound_variables(opts)) && (ps = association_prepared_statement(opts, bv))
             ps.call(bv)
           else
             super
@@ -95,7 +113,7 @@ module Sequel
         # Use a prepared statement if possible to load the associated object,
         # unless the associated model uses caching.
         def _load_associated_object_via_primary_key(opts)
-          if !opts.associated_class.respond_to?(:cache_get_pk) && (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+          if !opts.associated_class.respond_to?(:cache_get_pk) && (bv = association_bound_variables(opts)) && (ps = association_prepared_statement(opts, bv))
             ps.call(bv)
           else
             super
@@ -105,7 +123,7 @@ module Sequel
         # Use a prepared statement if possible to load the associated objects,
         # unless a dynamic callback is given.
         def _load_associated_object_array(opts, dynamic_opts)
-          if !dynamic_opts[:callback] && (bv = association_bound_variables(opts)) && (ps ||= association_prepared_statement(opts, bv))
+          if !dynamic_opts[:callback] && (bv = association_bound_variables(opts)) && (ps = association_prepared_statement(opts, bv))
             ps.call(bv)
           else
             super

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -14,6 +14,10 @@ module Sequel
     # service attack by allocating an arbitrary number of prepared statements.  You have been
     # warned.
     #
+    # Note that in most cases, this plugin will probably make things slower,
+    # so you should only use it if you really want to use prepared statements
+    # for Dataset#with_pk.
+    #
     # Usage:
     #
     #   # Make all model subclasses use prepared statements for Dataset#with_pk (called before loading subclasses)
@@ -51,7 +55,11 @@ module Sequel
             rescue UnbindDuplicate
               super
             else
-              model.send(:prepared_lookup_dataset, ds).call(bv)
+              ps = model.send(:prepared_lookup_dataset, ds)
+              if server = @opts[:server]
+                ps = ps.server(server)
+              end
+              ps.call(bv)
             end
           end
         end

data/lib/sequel/plugins/sharding.rb

@@ -83,6 +83,11 @@ module Sequel
           nil
         end
 
+        # Mark that associated objects should use the same server.
+        def _associated_objects_use_same_server?
+          true
+        end
+
         # Ensure that the join table for many_to_many associations uses the correct shard.
         def _join_table_dataset(opts)
           use_server(super)

data/lib/sequel/plugins/update_primary_key.rb

@@ -63,7 +63,7 @@ module Sequel
           if type == :update
             false
           else
-            super
+            super if defined?(super)
           end
         end
       end

data/lib/sequel/version.rb

@@ -5,10 +5,10 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 42
+  MINOR = 43
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
-  TINY  = 1
+  TINY  = 0
   
   # The version of Sequel you are using, as a string (e.g. "2.11.0")
   VERSION = [MAJOR, MINOR, TINY].join('.').freeze

data/spec/adapters/spec_helper.rb

@@ -20,6 +20,10 @@ Sequel.split_symbols = false if ENV['SEQUEL_NO_SPLIT_SYMBOLS']
 Sequel::Database.extension :duplicate_column_handler if ENV['SEQUEL_DUPLICATE_COLUMN_HANDLER']
 Sequel::Database.extension :columns_introspection if ENV['SEQUEL_COLUMNS_INTROSPECTION']
 Sequel::Model.cache_associations = false if ENV['SEQUEL_NO_CACHE_ASSOCIATIONS']
+if ENV['SEQUEL_MODEL_PREPARED_STATEMENTS']
+  Sequel::Model.plugin :prepared_statements
+  Sequel::Model.plugin :prepared_statements_associations
+end
 Sequel.cache_anonymous_models = false
 
 class Sequel::Database

data/spec/core/connection_pool_spec.rb

@@ -905,6 +905,16 @@ describe "A single threaded pool with multiple servers" do
 end
 
 AllConnectionPoolClassesSpecs = shared_description do
+  it "should work correctly after being frozen" do
+    o = Object.new
+    db = mock_db.call{o}
+    cp = @class.new(db, {})
+    db.instance_variable_set(:@pool, cp)
+    db.freeze
+    cp.frozen?.must_equal true
+    db.synchronize{|c| c.must_be_same_as o}
+  end
+
   it "should have pool correctly handle disconnect errors not raised as DatabaseDisconnectError" do
     db = mock_db.call{Object.new}
     def db.dec; @dec ||= Class.new(StandardError) end

data/spec/core/database_spec.rb

@@ -109,6 +109,28 @@ describe "A new Database" do
   end if RUBY_VERSION >= '1.9.3'
 end
 
+describe "Database#freeze" do
+  before do
+    @db = Sequel.mock.freeze
+  end
+
+  it "should freeze internal structures" do
+    @db.instance_exec do
+      frozen?.must_equal true
+      opts.frozen?.must_equal true
+      pool.frozen?.must_equal true
+      loggers.frozen?.must_equal true
+      @dataset_class.frozen?.must_equal true
+      @dataset_modules.frozen?.must_equal true
+      @schema_type_classes.frozen?.must_equal true
+      from(:a).frozen?.must_equal  true
+      metadata_dataset.frozen?.must_equal true
+    end
+
+    proc{@db.extend_datasets{}}.must_raise RuntimeError, TypeError
+  end
+end
+
 describe "Database#disconnect" do
   it "should call pool.disconnect" do
     d = Sequel::Database.new
@@ -2390,6 +2412,13 @@ describe "Database extensions" do
     @db.extension(:foo).a.must_equal 1
   end
 
+  it "should not call the block multiple times if extension loaded more than once" do
+    @db.opts[:foo] = []
+    Sequel::Database.register_extension(:foo){|db| db.opts[:foo] << 1}
+    @db.extension(:foo).opts[:foo].must_equal [1]
+    @db.extension(:foo).opts[:foo].must_equal [1]
+  end
+
   it "should be able to register an extension with a block and have Database#extension call the block" do
     Sequel::Database.register_extension(:foo){|db| db.opts[:foo] = 1}
     @db.extension(:foo).opts[:foo].must_equal 1

data/spec/extensions/blacklist_security_spec.rb

@@ -31,9 +31,9 @@ describe Sequel::Model, "#(set|update)_except" do
 
   it "#update_except should not update given attributes" do
     @o1.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
-    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
     @c.new.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, :y, :z)
-    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
   end
 end
 
@@ -68,7 +68,7 @@ describe Sequel::Model, ".restricted_columns " do
     i = @c.new
     i.update(:x => 7, :z => 9)
     i.values.must_equal(:x => 7)
-    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
   end
 
   it "should have allowed take precedence over restricted" do
@@ -83,6 +83,6 @@ describe Sequel::Model, ".restricted_columns " do
     i = @c.new
     i.update(:y => 7, :z => 9)
     i.values.must_equal(:y => 7)
-    DB.sqls.must_equal ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    DB.sqls.must_equal ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
   end
 end

data/spec/extensions/defaults_setter_spec.rb

@@ -57,7 +57,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
     o = c.new
     o.a = o.a
     o.save
-    @db.sqls.must_equal ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE (id = 1) LIMIT 1"]
+    @db.sqls.must_equal ["INSERT INTO foo (a) VALUES (CURRENT_TIMESTAMP)", "SELECT * FROM foo WHERE id = 1"]
   end
 
   it "should not override a given value" do

data/spec/extensions/force_encoding_spec.rb

@@ -2,8 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 if RUBY_VERSION >= '1.9.0'
 describe "force_encoding plugin" do
   before do
-    @c = Class.new(Sequel::Model) do
-    end
+    @c = Class.new(Sequel::Model)
     @c.columns :id, :x
     @c.plugin :force_encoding, 'UTF-8'
     @e1 = Encoding.find('UTF-8')
@@ -90,6 +89,7 @@ describe "force_encoding plugin" do
         {:id=>1, :x=>s}
       end
     end
+    @c.instance_variable_set(:@fast_pk_lookup_sql, nil)
     o.save
     o.x.must_equal 'blah'
     o.x.encoding.must_equal @e1
@@ -104,6 +104,7 @@ describe "force_encoding plugin" do
         {:id=>1, :x=>s}
       end
     end
+    @c.instance_variable_set(:@fast_pk_lookup_sql, nil)
     o.refresh
     o.x.must_equal 'blah'
     o.x.encoding.must_equal @e1