sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/ruby18_symbol_extensions.rb

@@ -1,22 +0,0 @@
-# The ruby18_symbol_extensions adds the <, <=, >, >= to Symbol
-# to reflect the mathmatical operators.  It also adds the [] method
-# to Symbol for creating SQL functions.
-#
-# Usage of this extension is not recommended. This extension will
-# only load on ruby 1.8, so you will not be able to upgrade to
-# newer ruby versions if you use it. If you still want to use it,
-# you can load it via:
-#
-#   Sequel.extension :ruby18_symbol_extensions
-
-raise(Sequel::Error, "The ruby18_symbol_extensions is only available on ruby 1.8.") unless RUBY_VERSION < '1.9.0'
-
-class Symbol
-  include Sequel::SQL::InequalityMethods
-
-  # Create an SQL Function with the receiver as the function name
-  # and the given arguments.
-  def [](*args)
-    Sequel::SQL::Function.new(self, *args)
-  end
-end

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -1,118 +0,0 @@
-# This adds the following dataset methods:
-#
-# []= :: filter with the first argument, update with the second
-# insert_multiple :: insert multiple rows at once
-# set :: alias for update
-# to_csv :: return string in csv format for the dataset
-# db= :: change the dataset's database
-# opts= :: change the dataset's opts
-#
-# It is only recommended to use this for backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:sequel_3_dataset_methods)
-#
-# Or you can load it into all of a database's datasets, which
-# is probably the desired behavior if you are using this extension:
-#
-#   DB.extension(:sequel_3_dataset_methods)
-
-#
-module Sequel
-  module Sequel3DatasetMethods
-    COMMA = Dataset::COMMA
-    # The database related to this dataset.  This is the Database instance that
-    # will execute all of this dataset's queries.
-    attr_writer :db
-
-    # The hash of options for this dataset, keys are symbols.
-    attr_writer :opts
-
-    # Update all records matching the conditions with the values specified.
-    # Returns the number of rows affected.
-    #
-    #   DB[:table][:id=>1] = {:id=>2} # UPDATE table SET id = 2 WHERE id = 1
-    #   # => 1 # number of rows affected
-    def []=(conditions, values)
-      filter(conditions).update(values)
-    end
-
-    # Inserts multiple values. If a block is given it is invoked for each
-    # item in the given array before inserting it.  See +multi_insert+ as
-    # a possibly faster version that may be able to insert multiple
-    # records in one SQL statement (if supported by the database).
-    # Returns an array of primary keys of inserted rows.
-    #
-    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}])
-    #   # => [4, 5]
-    #   # INSERT INTO table (x) VALUES (1)
-    #   # INSERT INTO table (x) VALUES (2)
-    #
-    #   DB[:table].insert_multiple([{:x=>1}, {:x=>2}]){|row| row[:y] = row[:x] * 2; row }
-    #   # => [6, 7]
-    #   # INSERT INTO table (x, y) VALUES (1, 2)
-    #   # INSERT INTO table (x, y) VALUES (2, 4)
-    def insert_multiple(array, &block)
-      if block
-        array.map{|i| insert(block.call(i))}
-      else
-        array.map{|i| insert(i)}
-      end
-    end
-    
-    # Return a copy of the dataset with unqualified identifiers in the
-    # SELECT, WHERE, GROUP, HAVING, and ORDER clauses qualified by the
-    # given table. If no columns are currently selected, select all
-    # columns of the given table.
-    #
-    #   DB[:items].filter(:id=>1).qualify_to(:i)
-    #   # SELECT i.* FROM items WHERE (i.id = 1)
-    def qualify_to(table)
-      qualify(table)
-    end
-    
-    # Qualify the dataset to its current first source.  This is useful
-    # if you have unqualified identifiers in the query that all refer to
-    # the first source, and you want to join to another table which
-    # has columns with the same name as columns in the current dataset.
-    # See +qualify_to+.
-    #
-    #   DB[:items].filter(:id=>1).qualify_to_first_source
-    #   # SELECT items.* FROM items WHERE (items.id = 1)
-    def qualify_to_first_source
-      qualify
-    end
-    
-    # Alias for update, but not aliased directly so subclasses
-    # don't have to override both methods.
-    def set(*args)
-      update(*args)
-    end
-    
-    # Returns a string in CSV format containing the dataset records. By 
-    # default the CSV representation includes the column titles in the
-    # first line. You can turn that off by passing false as the 
-    # include_column_titles argument.
-    #
-    # This does not use a CSV library or handle quoting of values in
-    # any way.  If any values in any of the rows could include commas or line
-    # endings, you shouldn't use this.
-    #
-    #   puts DB[:table].to_csv # SELECT * FROM table
-    #   # id,name
-    #   # 1,Jim
-    #   # 2,Bob
-    def to_csv(include_column_titles = true)
-      n = naked
-      cols = n.columns
-      csv = ''
-      csv << "#{cols.join(COMMA)}\r\n" if include_column_titles
-      n.each{|r| csv << "#{cols.collect{|c| r[c]}.join(COMMA)}\r\n"}
-      csv
-    end
-  end
-
-  Dataset.register_extension(:sequel_3_dataset_methods, Sequel3DatasetMethods)
-end

data/lib/sequel/extensions/set_overrides.rb

@@ -1,72 +0,0 @@
-# The set_overrides extension adds the Dataset#set_overrides and
-# Dataset#set_defaults methods which provide a crude way to
-# control the values used in INSERT/UPDATE statements if a hash
-# of values is passed to Dataset#insert or Dataset#update.
-# It is only recommended to use this for backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:set_overrides)
-#
-# Or you can load it into all of a database's datasets, which
-# is probably the desired behavior if you are using this extension:
-#
-#   DB.extension(:set_overrides)
-
-#
-module Sequel
-  module SetOverrides
-    Dataset::NON_SQL_OPTIONS.concat([:defaults, :overrides])
-    Dataset.def_mutation_method(:set_defaults, :set_overrides, :module=>self)
-
-    # Set overrides/defaults for insert hashes
-    def insert_sql(*values)
-      if values.size == 1 && (vals = values.first).is_a?(Hash)
-        super(merge_defaults_overrides(vals))
-      else
-        super
-      end
-    end
-
-    # Set the default values for insert and update statements.  The values hash passed
-    # to insert or update are merged into this hash, so any values in the hash passed
-    # to insert or update will override values passed to this method.  
-    #
-    #   DB[:items].set_defaults(:a=>'a', :c=>'c').insert(:a=>'d', :b=>'b')
-    #   # INSERT INTO items (a, c, b) VALUES ('d', 'c', 'b')
-    def set_defaults(hash)
-      clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
-    end
-
-    # Set values that override hash arguments given to insert and update statements.
-    # This hash is merged into the hash provided to insert or update, so values
-    # will override any values given in the insert/update hashes.
-    #
-    #   DB[:items].set_overrides(:a=>'a', :c=>'c').insert(:a=>'d', :b=>'b')
-    #   # INSERT INTO items (a, c, b) VALUES ('a', 'c', 'b')
-    def set_overrides(hash)
-      clone(:overrides=>hash.merge(@opts[:overrides]||{}))
-    end
-
-    # Set overrides/defaults for update hashes
-    def update_sql(values = {})
-      if values.is_a?(Hash)
-        super(merge_defaults_overrides(values))
-      else
-        super
-      end
-    end
-
-    private
-
-    # Return new hashe with merged defaults and overrides.
-    def merge_defaults_overrides(vals)
-      vals = @opts[:defaults].merge(vals) if @opts[:defaults]
-      vals = vals.merge(@opts[:overrides]) if @opts[:overrides]
-      vals
-    end
-  end
-
-  Dataset.register_extension(:set_overrides, SetOverrides)
-end

data/lib/sequel/no_core_ext.rb

@@ -1 +0,0 @@
-require 'sequel'

data/lib/sequel/plugins/association_autoreloading.rb

@@ -1,7 +0,0 @@
-module Sequel
-  module Plugins
-    # Empty plugin module for backwards compatibility
-    module AssociationAutoreloading
-    end
-  end
-end

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -1,7 +0,0 @@
-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,78 +0,0 @@
-module Sequel
-  module Plugins
-    # The PgTypecastOnLoad plugin exists because when you connect to PostgreSQL
-    # using the do, swift, or jdbc adapter, 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 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
-
-        # 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,117 +0,0 @@
-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,59 +0,0 @@
-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