sequel 4.49.0 → 5.3.0

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