sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -1,119 +0,0 @@
-# frozen-string-literal: true
-
-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.
-    #
-    # 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
-
-        # 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)
-          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
-          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
-              ps = ds.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
-              ps.log_sql = true
-              ps
-            end
-          end
-        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,61 +0,0 @@
-# frozen-string-literal: true
-
-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.
-    #
-    # 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.filter(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
-              model.send(:prepared_lookup_dataset, ds).call(bv)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/schema.rb

@@ -1,82 +0,0 @@
-# frozen-string-literal: true
-
-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::Generator 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,35 +0,0 @@
-# frozen-string-literal: true
-
-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/adapter_spec.rb

@@ -1,4 +0,0 @@
-if !ARGV.empty? && ARGV.first != 'none'
-  require "./spec/adapters/#{ARGV.first}_spec.rb"
-end
-Dir['./spec/integration/*_test.rb'].each{|f| require f}

data/spec/adapters/db2_spec.rb

@@ -1,160 +0,0 @@
-SEQUEL_ADAPTER_TEST = :db2
-
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-
-if DB.table_exists?(:test)
-  DB.drop_table(:test)
-end
-
-describe Sequel::Database do
-  before do
-    @db = DB
-    @db.create_table(:test){String :a}
-    @ds = @db[:test]
-  end
-
-  after do
-    @db.drop_table(:test)
-  end
-  
-  it "should provide disconnect functionality after preparing a connection" do
-    @ds.prepare(:first, :a).call
-    @db.disconnect
-    @db.pool.size.must_equal 0
-  end
-
-  it "should return version correctly" do
-    @db.db2_version.must_match(/DB2 v/i)
-  end
-end
-
-describe "Simple Dataset operations" do
-  before(:all) do
-    Sequel::DB2.use_clob_as_blob = true
-    DB.create_table!(:items) do
-      Integer :id, :primary_key => true
-      Integer :number
-      column  :bin_string, 'varchar(20) for bit data'
-      column  :bin_clob, 'clob'
-    end
-    @ds = DB[:items]
-  end
-  after(:each) do
-    @ds.delete
-  end
-  after(:all) do
-    Sequel::DB2.use_clob_as_blob = false
-    DB.drop_table(:items)
-  end
-
-  it "should insert with a primary key specified" do
-    @ds.insert(:id => 1,   :number => 10)
-    @ds.insert(:id => 100, :number => 20)
-    @ds.select_hash(:id, :number).must_equal(1 => 10, 100 => 20)
-  end
-
-  it "should insert into binary columns" do
-    @ds.insert(:id => 1, :bin_string => Sequel.blob("\1"), :bin_clob => Sequel.blob("\2"))
-    @ds.select(:bin_string, :bin_clob).first.must_equal(:bin_string => "\1", :bin_clob => "\2")
-  end
-end
-
-describe Sequel::Database do
-  before do
-    @db = DB
-  end
-  after do
-    @db.drop_table(:items)
-  end
-
-  it "should parse primary keys from the schema properly" do
-    @db.create_table!(:items){Integer :number}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal []
-    @db.create_table!(:items){primary_key :number}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number]
-    @db.create_table!(:items){Integer :number1, :null => false; Integer :number2, :null => false; primary_key [:number1, :number2]}
-    @db.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.must_equal [:number1, :number2]
-  end
-
-  it "should not error on alter_table operations that need REORG" do
-    @db.create_table!(:items) do
-      varchar :a
-    end
-    @db.alter_table(:items) do
-      add_column :b, :varchar, :null => true
-      set_column_allow_null :a, false
-      add_index :a, :unique => true
-    end
-  end
-end
-
-describe "Sequel::IBMDB.convert_smallint_to_bool" do
-  before do
-    @db = DB
-    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-    @ds = @db[:booltest]
-  end
-  after do
-    Sequel::IBMDB.convert_smallint_to_bool = true
-    @db.drop_table(:booltest)
-  end
-  
-  it "should consider smallint datatypes as boolean if set, but not larger smallints" do
-    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-    Sequel::IBMDB.convert_smallint_to_bool = false
-    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
-    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-  end
-  
-  it "should return smallints as bools and integers as integers when set" do
-    Sequel::IBMDB.convert_smallint_to_bool = true
-    @ds.delete
-    @ds << {:b=>true, :i=>10}
-    @ds.all.must_equal [{:b=>true, :i=>10}]
-    @ds.delete
-    @ds << {:b=>false, :i=>0}
-    @ds.all.must_equal [{:b=>false, :i=>0}]
-    @ds.delete
-    @ds << {:b=>true, :i=>1}
-    @ds.all.must_equal [{:b=>true, :i=>1}]
-  end
-
-  it "should return all smallints as integers when unset" do
-    Sequel::IBMDB.convert_smallint_to_bool = false
-    @ds.delete
-    @ds << {:b=>true, :i=>10}
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-    @ds.delete
-    @ds << {:b=>false, :i=>0}
-    @ds.all.must_equal [{:b=>0, :i=>0}]
-    
-    @ds.delete
-    @ds << {:b=>1, :i=>10}
-    @ds.all.must_equal [{:b=>1, :i=>10}]
-    @ds.delete
-    @ds << {:b=>0, :i=>0}
-    @ds.all.must_equal [{:b=>0, :i=>0}]
-  end
-end if DB.adapter_scheme == :ibmdb
-
-describe "Simple Dataset operations in transactions" do
-  before do
-    DB.create_table!(:items_insert_in_transaction) do
-      Integer :id, :primary_key => true
-      integer :number
-    end
-    @ds = DB[:items_insert_in_transaction]
-  end
-  after do
-    DB.drop_table(:items_insert_in_transaction)
-  end
-
-  it "should insert correctly with a primary key specified inside a transaction" do
-    DB.transaction do
-      @ds.insert(:id=>100, :number=>20)
-      @ds.count.must_equal 1
-      @ds.order(:id).all.must_equal [{:id=>100, :number=>20}]
-    end
-  end
-end