sequel 4.49.0 → 5.0.0

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -1,11 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The many_to_one_pk_lookup plugin", "This plugin was integrated into the default model behavior in Sequel 4.0, and no longer has an effect")
-
-module Sequel
-  module Plugins
-    # Empty plugin module for backwards compatibility
-    module ManyToOnePkLookup
-    end
-  end
-end

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -1,90 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The pg_typecast_on_load plugin", "This plugin is only useful on the deprecated do and switch adapters")
-
-module Sequel
-  module Plugins
-    # The PgTypecastOnLoad plugin exists because when you connect to PostgreSQL
-    # using the do and swift adapters, 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 is not needed if using the postgres or
-    # jdbc/postgresql adapters.
-    #
-    # This plugin makes model loading 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, this plugin will have no
-    # effect.  You may be able to use the regular typecast_on_load plugin to
-    # handle those cases.
-    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
-
-        def call(values)
-          super(load_typecast_pg(values))
-        end
-
-        # Freeze the typecast on load columns when freezing the model class.
-        def freeze
-          @pg_typecast_on_load_columns.freeze
-
-          super
-        end
-
-        # Lookup the conversion proc for the column's oid in the Database
-        # object, and use it to convert the value.
-        def load_typecast_pg(values)
-          pg_typecast_on_load_columns.each do |c|
-            if (v = values[c]).is_a?(String) && (oid = db_schema[c][:oid]) && (pr = db.conversion_procs[oid])
-              values[c] = pr.call(v)
-            end
-          end
-          values
-        end
-
-        Plugins.inherited_instance_variables(self, :@pg_typecast_on_load_columns=>:dup)
-      end
-
-      module InstanceMethods
-        private
-
-        # Typecast specific columns using the conversion procs when manually refreshing.
-        def _refresh_set_values(values)
-          super(model.load_typecast_pg(values))
-        end
-
-        # Typecast specific columns using the conversion procs when refreshing after save.
-        def _save_set_values(values)
-          super(model.load_typecast_pg(values))
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -1,137 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The prepared_statements_associations plugin", "Stop using the plugin, it is probably unneeded and making the application slower")
-
-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.
-    #
-    # 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)
-    #   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 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)
-          Hash[*ks.zip(vs).map{|k, v| [:"#{table}.#{k}", get_column_value(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)
-          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])
-          when :one_to_many, :one_to_one
-            association_bound_variable_hash(opts.associated_class.table_name, opts[:keys], opts[:primary_keys])
-          when :many_to_many, :one_through_one
-            association_bound_variable_hash(opts.join_table_alias, opts[:left_keys], opts[:left_primary_keys])
-          when :many_through_many, :one_through_many
-            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.  Return false if such a prepared statement cannot be created.
-        def association_prepared_statement(opts, assoc_bv)
-          return unless model.cache_associations
-          ps = opts.send(:cached_fetch, :prepared_statement) do
-            unless opts[:instance_specific]
-              ds, bv = _associated_dataset(opts, {}).unbind
-
-              f = ds.opts[:from]
-              if f && f.length == 1
-                s = ds.opts[:select]
-                if ds.opts[:join]
-                  if opts.eager_loading_use_associated_key? && s && s.length == 1 && s.first.is_a?(SQL::ColumnAll)
-                    table = s.first.table
-                    ds = ds.select(*opts.associated_class.columns.map{|c| Sequel.identifier(c).qualify(table)})
-                  end
-                elsif !s || s.empty?
-                  ds = ds.select(*opts.associated_class.columns.map{|c| Sequel.identifier(c)})
-                end
-              end 
-          
-              if bv.length != assoc_bv.length
-                h = {}
-                bv.each do |k,v|
-                  h[k] = v unless assoc_bv.has_key?(k)
-                end
-                ds = ds.bind(h)
-              end
-              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))
-            ps.call(bv)
-          else
-            super
-          end
-        end
-
-        # 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))
-            ps.call(bv)
-          else
-            super
-          end
-        end
-
-        # 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))
-            ps.call(bv)
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -1,71 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The prepared_statements_with_pk plugin", "Stop using the plugin, it is probably unneeded and making the application slower")
-
-module Sequel
-  module Plugins
-    # The prepared_statements_with_pk plugin allows Dataset#with_pk for model datasets
-    # to use prepared statements by extract the values of previously bound variables
-    # using <tt>Dataset#unbind</tt>, and attempting to use a prepared statement if the
-    # variables can be unbound correctly. See  +Unbinder+ for details about what types of
-    # dataset filters can be unbound correctly.
-    #
-    # This plugin depends on the +prepared_statements+ plugin and should be considered unsafe.
-    # Unbinding dataset values cannot be done correctly in all cases, and use of this plugin
-    # in cases where not there are variables that are not unbound can lead to an denial of
-    # 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)
-    #   Sequel::Model.plugin :prepared_statements_with_pk
-    #
-    #   # Make the Album class use prepared statements for Dataset#with_pk
-    #   Album.plugin :prepared_statements_with_pk
-    module PreparedStatementsWithPk
-      # Depend on the prepared_statements plugin
-      def self.apply(model)
-        model.plugin(:prepared_statements)
-      end
-
-      module ClassMethods
-        private
-
-        # Return a prepared statement that can be used to lookup a row given a dataset for the row matching
-        # the primary key.
-        def prepared_lookup_dataset(ds)
-          cached_prepared_statement(:lookup_sql, ds.sql){prepare_statement(ds.where(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)}
-        end
-      end
-
-      module DatasetMethods
-        # Use a prepared statement to find a row with the matching primary key
-        # inside this dataset.
-        def with_pk(pk)
-          begin
-            ds, bv = unbind
-          rescue UnbindDuplicate
-            super
-          else
-            begin
-              bv = bv.merge!(model.primary_key_hash(pk)){|k, v1, v2| ((v1 == v2) ? v1 : raise(UnbindDuplicate))}
-            rescue UnbindDuplicate
-              super
-            else
-              ps = model.send(:prepared_lookup_dataset, ds)
-              if server = @opts[:server]
-                ps = ps.server(server)
-              end
-              ps.call(bv)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/schema.rb

@@ -1,84 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The schema plugin", "Switch to defining your schema using Database schema methods before creating your model classes")
-
-module Sequel
-  module Plugins
-    # Sequel's built in schema plugin allows you to define your schema
-    # directly in the model using Model.set_schema (which takes a block
-    # similar to Database#create_table), and use Model.create_table to
-    # create a table using the schema information.
-    #
-    # This plugin is mostly suited to test code.  If there is any
-    # chance that your application's schema could change, you should
-    # be using the migration extension instead.
-    # 
-    # Usage:
-    #
-    #   # Add the schema methods to all model subclasses (called before loading subclasses)
-    #   Sequel::Model.plugin :schema
-    #
-    #   # Add the schema methods to the Album class
-    #   Album.plugin :schema
-    module Schema
-      module ClassMethods
-        # Creates table, using the column information from set_schema.
-        def create_table(*args, &block)
-          set_schema(*args, &block) if block
-          db.create_table(table_name, :generator=>@schema)
-          @db_schema = get_db_schema(true)
-          columns
-        end
-        
-        # Drops the table if it exists and then runs create_table.  Should probably
-        # not be used except in testing.
-        def create_table!(*args, &block)
-          drop_table?
-          create_table(*args, &block)
-        end
-
-        # Creates the table unless the table already exists
-        def create_table?(*args, &block)
-          create_table(*args, &block) unless table_exists?
-        end
-        
-        # Drops table.  If the table doesn't exist, this will probably raise an error.
-        def drop_table
-          db.drop_table(table_name)
-        end
-    
-        # Drops table if it already exists, do nothing if it doesn't exist.
-        def drop_table?
-          db.drop_table?(table_name)
-        end
-    
-        # Returns table schema created with set_schema for direct descendant of Model.
-        # Does not retreive schema information from the database, see db_schema if you
-        # want that.
-        def schema
-          @schema || (superclass.schema unless superclass == Model)
-        end
-    
-        # Defines a table schema (see Schema::CreateTableGenerator for more information).
-        #
-        # This is only needed if you want to use the create_table/create_table! methods.
-        # Will also set the dataset if you provide a name, as well as setting
-        # the primary key if you defined one in the passed block.
-        #
-        # In general, it is a better idea to use migrations for production code, as
-        # migrations allow changes to existing schema.  set_schema is mostly useful for
-        # test code or simple examples.
-        def set_schema(name = nil, &block)
-          set_dataset(db[name]) if name
-          @schema = db.create_table_generator(&block)
-          set_primary_key(@schema.primary_key_name) if @schema.primary_key_name
-        end
-        
-        # Returns true if table exists, false otherwise.
-        def table_exists?
-          db.table_exists?(table_name)
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/scissors.rb

@@ -1,37 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The scissors plugin", "Running with scissors is dangerous")
-
-module Sequel
-  module Plugins
-    # The scissors plugin adds class methods for update, delete, and destroy.
-    # It is so named because this is considered dangerous, since it is easy
-    # to write:
-    #
-    #   Album.delete
-    #
-    # and delete all rows in the table, when you meant to write:
-    #
-    #   album.delete
-    #
-    # and only delete a single row.
-    #
-    # This plugin is mostly useful for backwards compatibility, and not
-    # recommended for use in production.  However, it can cut down on
-    # verbosity in non-transactional test code, so it may be appropriate
-    # to use when testing.
-    #
-    # Usage:
-    #
-    #   # Make all model subclass run with scissors
-    #   Sequel::Model.plugin :scissors
-    #
-    #   # Make the Album class run with scissors
-    #   Album.plugin :scissors
-    module Scissors
-      module ClassMethods
-        Plugins.def_dataset_methods(self, [:update, :delete, :destroy])
-      end
-    end
-  end
-end

data/spec/core/dataset_mutation_spec.rb

@@ -1,253 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-# SEQUEL5: Remove
-unless Sequel.mock.dataset.frozen?
-
-describe "Dataset" do
-  before do
-    @d = Sequel.mock.dataset.from(:x)
-  end
-
-  deprecated "should support self-changing select!" do
-    @d.select!(:y)
-    @d.sql.must_equal "SELECT y FROM x"
-  end
-  
-  deprecated "should support self-changing from!" do
-    @d.from!(:y)
-    @d.sql.must_equal "SELECT * FROM y"
-  end
-
-  deprecated "should support self-changing order!" do
-    @d.order!(:y)
-    @d.sql.must_equal "SELECT * FROM x ORDER BY y"
-  end
-  
-  deprecated "should support self-changing filter!" do
-    @d.filter!(:y => 1)
-    @d.sql.must_equal "SELECT * FROM x WHERE (y = 1)"
-  end
-
-  deprecated "should support self-changing filter! with block" do
-    @d.filter!{y < 2}
-    @d.sql.must_equal "SELECT * FROM x WHERE (y < 2)"
-  end
-  
-  deprecated "should raise for ! methods that don't return a dataset" do
-    proc {@d.opts!}.must_raise(NoMethodError)
-  end
-  
-  deprecated "should raise for missing methods" do
-    proc {@d.xuyz}.must_raise(NoMethodError)
-    proc {@d.xyz!}.must_raise(NoMethodError)
-    proc {@d.xyz?}.must_raise(NoMethodError)
-  end
-  
-  deprecated "should support chaining of bang methods" do
-      @d.order!(:y).filter!(:y => 1).sql.must_equal "SELECT * FROM x WHERE (y = 1) ORDER BY y"
-  end
-end
-
-describe "Frozen Datasets" do
-  before do
-    @ds = Sequel.mock[:test].freeze
-  end
-
-  deprecated "should have dups not be frozen" do
-    @ds.dup.wont_be :frozen?
-  end
-
-  deprecated "should raise an error when calling mutation methods" do
-    proc{@ds.select!(:a)}.must_raise RuntimeError
-    proc{@ds.row_proc = proc{}}.must_raise RuntimeError
-    proc{@ds.extension! :query}.must_raise RuntimeError
-    proc{@ds.naked!}.must_raise RuntimeError
-    proc{@ds.from_self!}.must_raise RuntimeError
-  end
-end
-
-describe "Dataset mutation methods" do
-  def m(&block)
-    ds = Sequel.mock[:t]
-    def ds.supports_cte?(*) true end
-    ds.instance_exec(&block)
-    ds.sql
-  end
-
-  deprecated "should modify the dataset in place" do
-    dsc = Sequel.mock[:u]
-    dsc.send(:columns=, [:v])
-
-    m{and!(:a=>1).or!(:b=>2)}.must_equal "SELECT * FROM t WHERE ((a = 1) OR (b = 2))"
-    m{select!(:f).graph!(dsc, :b=>:c).set_graph_aliases!(:e=>[:m, :n]).add_graph_aliases!(:d=>[:g, :c])}.must_equal "SELECT m.n AS e, g.c AS d FROM t LEFT OUTER JOIN u ON (u.b = t.c)"
-    m{cross_join!(:a)}.must_equal "SELECT * FROM t CROSS JOIN a"
-    m{distinct!}.must_equal "SELECT DISTINCT * FROM t"
-    m{except!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t EXCEPT SELECT * FROM u) AS t1"
-    m{exclude!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a != 1)"
-    m{exclude_having!(:a=>1)}.must_equal "SELECT * FROM t HAVING (a != 1)"
-    m{exclude_where!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a != 1)"
-    m{filter!(:a=>1)}.must_equal "SELECT * FROM t WHERE (a = 1)"
-    m{for_update!}.must_equal "SELECT * FROM t FOR UPDATE"
-    m{from!(:p)}.must_equal "SELECT * FROM p"
-    m{full_join!(:a, [:b])}.must_equal "SELECT * FROM t FULL JOIN a USING (b)"
-    m{full_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t FULL OUTER JOIN a USING (b)"
-    m{grep!(:a, 'b')}.must_equal "SELECT * FROM t WHERE ((a LIKE 'b' ESCAPE '\\'))"
-    m{group!(:a)}.must_equal "SELECT * FROM t GROUP BY a"
-    m{group_and_count!(:a)}.must_equal "SELECT a, count(*) AS count FROM t GROUP BY a"
-    m{group_by!(:a)}.must_equal "SELECT * FROM t GROUP BY a"
-    m{having!(:a)}.must_equal "SELECT * FROM t HAVING a"
-    m{inner_join!(:a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
-    m{intersect!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t INTERSECT SELECT * FROM u) AS t1"
-    m{where!(:a).invert!}.must_equal "SELECT * FROM t WHERE NOT a"
-    m{join!(:a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
-    m{join_table!(:inner, :a, [:b])}.must_equal "SELECT * FROM t INNER JOIN a USING (b)"
-    m{left_join!(:a, [:b])}.must_equal "SELECT * FROM t LEFT JOIN a USING (b)"
-    m{left_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t LEFT OUTER JOIN a USING (b)"
-    m{limit!(1)}.must_equal "SELECT * FROM t LIMIT 1"
-    m{lock_style!(:update)}.must_equal "SELECT * FROM t FOR UPDATE"
-    m{natural_full_join!(:a)}.must_equal "SELECT * FROM t NATURAL FULL JOIN a"
-    m{natural_join!(:a)}.must_equal "SELECT * FROM t NATURAL JOIN a"
-    m{natural_left_join!(:a)}.must_equal "SELECT * FROM t NATURAL LEFT JOIN a"
-    m{natural_right_join!(:a)}.must_equal "SELECT * FROM t NATURAL RIGHT JOIN a"
-    m{offset!(1)}.must_equal "SELECT * FROM t OFFSET 1"
-    m{order!(:a).reverse_order!}.must_equal "SELECT * FROM t ORDER BY a DESC"
-    m{order_by!(:a).order_more!(:b).order_append!(:c).order_prepend!(:d).reverse!}.must_equal "SELECT * FROM t ORDER BY d DESC, a DESC, b DESC, c DESC"
-    m{qualify!}.must_equal "SELECT t.* FROM t"
-    m{right_join!(:a, [:b])}.must_equal "SELECT * FROM t RIGHT JOIN a USING (b)"
-    m{right_outer_join!(:a, [:b])}.must_equal "SELECT * FROM t RIGHT OUTER JOIN a USING (b)"
-    m{select!(:a)}.must_equal "SELECT a FROM t"
-    m{select_all!(:t).select_more!(:b).select_append!(:c)}.must_equal "SELECT t.*, b, c FROM t"
-    m{select_group!(:a)}.must_equal "SELECT a FROM t GROUP BY a"
-    m{where!(:a).unfiltered!}.must_equal "SELECT * FROM t"
-    m{group!(:a).ungrouped!}.must_equal "SELECT * FROM t"
-    m{limit!(1).unlimited!}.must_equal "SELECT * FROM t"
-    m{order!(:a).unordered!}.must_equal "SELECT * FROM t"
-    m{union!(dsc)}.must_equal "SELECT * FROM (SELECT * FROM t UNION SELECT * FROM u) AS t1"
-    m{with!(:a, dsc)}.must_equal "WITH a AS (SELECT * FROM u) SELECT * FROM t"
-    m{with_recursive!(:a, dsc, dsc)}.must_equal "WITH a AS (SELECT * FROM u UNION ALL SELECT * FROM u) SELECT * FROM t"
-    m{with_sql!('SELECT foo')}.must_equal "SELECT foo"
-
-    dsc.server!(:a)
-    dsc.opts[:server].must_equal :a
-    dsc.graph!(dsc, {:b=>:c}, :table_alias=>:foo).ungraphed!.opts[:graph].must_be_nil
-  end
-
-  deprecated "should clear the cache" do
-    ds = Sequel.mock[:a]
-    ds.columns
-    ds.send(:cache_set, :columns, [:a])
-    ds.select!(:foo, :bar).send(:cache_get, :columns).must_be_nil
-  end
-end
-
-describe "Dataset#clone" do
-  before do
-    @dataset = Sequel.mock.dataset.from(:items)
-  end
-
-  deprecated "should copy the dataset opts" do
-    clone = @dataset.clone
-    clone.opts.must_equal @dataset.opts
-    @dataset.filter!(:a => 'b')
-    clone.opts[:filter].must_be_nil
-  end
-end
-  
-describe "Dataset extensions" do
-  before(:all) do
-    class << Sequel
-      alias _extension extension
-      remove_method :extension
-      def extension(*)
-      end
-    end
-  end
-  after(:all) do
-    class << Sequel
-      remove_method :extension
-      alias extension _extension
-      remove_method :_extension
-    end
-  end
-  before do
-    @ds = Sequel.mock.dataset
-  end
-
-  deprecated "should have #extension! modify the receiver" do
-    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
-    @ds.extension!(:foo)
-    @ds.a.must_equal 1
-  end
-
-  deprecated "should have #extension! return the receiver" do
-    Sequel::Dataset.register_extension(:foo, Module.new{def a; 1; end})
-    @ds.extension!(:foo).must_be_same_as(@ds)
-  end
-end
-
-describe "Dataset#naked!" do
-  deprecated "should remove any existing row_proc" do
-    d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
-    d.naked!.row_proc.must_be_nil
-    d.row_proc.must_be_nil
-  end
-end
-
-describe "Dataset#row_proc=" do
-  deprecated "should set the row_proc" do
-    d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
-    d.row_proc.wont_be_nil
-    d.row_proc = nil
-    d.row_proc.must_be_nil
-  end
-end
-
-describe "Dataset#quote_identifiers=" do
-  deprecated "should change quote identifiers setting" do
-    d = Sequel.mock.dataset.with_quote_identifiers(true)
-    d.literal(:a).must_equal '"a"'
-    d.quote_identifiers = false
-    d.literal(:a).must_equal 'a'
-  end
-end
-
-describe "Dataset#from_self!" do
-  deprecated "should work" do
-    Sequel.mock.dataset.from(:test).select(:name).limit(1).from_self!.sql.must_equal 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
-  end
-end
-
-describe "Sequel Mock Adapter" do
-  deprecated "should be able to set the rows returned by each on a per dataset basis using _fetch" do
-    rs = []
-    db = Sequel.mock(:fetch=>{:a=>1})
-    ds = db[:t]
-    ds.each{|r| rs << r}
-    rs.must_equal [{:a=>1}]
-    ds._fetch = {:b=>2}
-    ds.each{|r| rs << r}
-    rs.must_equal [{:a=>1}, {:b=>2}]
-  end
-
-  deprecated "should be able to set the number of rows modified by update and delete on a per dataset basis" do
-    db = Sequel.mock(:numrows=>2)
-    ds = db[:t]
-    ds.update(:a=>1).must_equal 2
-    ds.delete.must_equal 2
-    ds.numrows = 3
-    ds.update(:a=>1).must_equal 3
-    ds.delete.must_equal 3
-  end
-
-  deprecated "should be able to set the autogenerated primary key returned by insert on a per dataset basis" do
-    db = Sequel.mock(:autoid=>1)
-    ds = db[:t]
-    ds.insert(:a=>1).must_equal 1
-    ds.autoid = 5
-    ds.insert(:a=>1).must_equal 5
-    ds.insert(:a=>1).must_equal 6
-    db[:t].insert(:a=>1).must_equal 2
-  end
-end
-
-end