sequel 4.49.0 → 5.3.0

data/lib/sequel/extensions/meta_def.rb

@@ -1,37 +0,0 @@
-# frozen-string-literal: true
-#
-# The meta_def extension is designed for backwards compatibility
-# with older Sequel code that uses the meta_def method on
-# Database, Dataset, and Model classes and/or instances.  It is
-# not recommended for usage in new code.  To load this extension:
-#
-#   Sequel.extension :meta_def
-#
-# Related module: Sequel::Metaprogramming
-
-Sequel::Deprecation.deprecate("The meta_def extension", "Replace meta_def usage with define_singleton_method")
-
-#
-module Sequel
-  # Contains meta_def method for adding methods to objects via blocks.
-  # Only recommended for backwards compatibility with existing code.
-  module Metaprogramming
-    # Define a method with the given name and block body on the receiver.
-    #
-    #   ds = DB[:items]
-    #   ds.meta_def(:x){42}
-    #   ds.x # => 42
-    def meta_def(name, &block)
-      (class << self; self end).send(:define_method, name, &block)
-    end
-  end
-
-  Database.extend Metaprogramming
-  Database.send(:include, Metaprogramming)
-  Dataset.extend Metaprogramming
-  Dataset.send(:include, Metaprogramming)
-  if defined?(Model)
-    Model.extend Metaprogramming
-    Model.send(:include, Metaprogramming)
-  end
-end

data/lib/sequel/extensions/query_literals.rb

@@ -1,86 +0,0 @@
-# frozen-string-literal: true
-#
-# The query_literals extension changes Sequel's default behavior of
-# the select, order and group methods so that if the first argument
-# is a regular string, it is treated as a literal string, with the
-# rest of the arguments (if any) treated as placeholder values. This
-# allows you to write code such as:
-#
-#   DB[:table].select('a, b, ?', 2).group('a, b').order('c')
-#
-# The default Sequel behavior would literalize that as:
-#
-#   SELECT 'a, b, ?', 2 FROM table GROUP BY 'a, b' ORDER BY 'c'
-#
-# Using this extension changes the literalization to:
-#
-#   SELECT a, b, 2, FROM table GROUP BY a, b ORDER BY c
-#
-# This extension makes select, group, and order methods operate
-# like filter methods, which support the same interface.  Note
-# that this extension can add SQL injection vulnerabilities to existing
-# code if any of the strings passed to one of the supported
-# methods is derived from user input.  For that reason, it should
-# be used with caution.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:query_literals)
-#
-# 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(:query_literals)
-#
-# Related module: Sequel::QueryLiterals
-
-Sequel::Deprecation.deprecate("The query_literals extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-#
-module Sequel
-  # The QueryLiterals module can be used to make select, group, and
-  # order methods operate similar to the filter methods if the first
-  # argument is a plain string, treating it like a literal string,
-  # with any remaining arguments treated as placeholder values.
-  #
-  # This adds such support to the following methods: select, select_append,
-  # select_group, select_more, group, group_and_count, order, order_append,
-  # and order_more.
-  #
-  # Note that if you pass a block to these methods, it will use the default
-  # implementation without the special literal handling.
-  module QueryLiterals
-    %w'select select_append select_group select_more group group_and_count group_append order order_append order_more'.each do |m|
-      class_eval(<<-END, __FILE__, __LINE__ + 1)
-        def #{m}(*args)
-          if !block_given? && (l = query_literal(args))
-            super(l)
-          else
-            super
-          end
-        end
-      END
-    end
-
-    private
-
-    # If the first argument is a plain string, return a literal string
-    # if there are no additional args or a placeholder literal string with
-    # the remaining args.  Otherwise, return nil.
-    def query_literal(args)
-      case (s = args[0])
-      when LiteralString, SQL::Blob
-        nil
-      when String
-        if args.length == 1
-          LiteralString.new(s)
-        else
-          SQL::PlaceholderLiteralString.new(s, args[1..-1])
-        end
-      end
-    end
-  end
-
-  Dataset.register_extension(:query_literals, QueryLiterals)
-end

data/lib/sequel/extensions/ruby18_symbol_extensions.rb

@@ -1,26 +0,0 @@
-# frozen-string-literal: true
-#
-# 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
-
-# SEQUEL5: Remove extension

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -1,133 +0,0 @@
-# frozen-string-literal: true
-#
-# 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)
-#
-# Related module: Sequel::Sequel3DatasetMethods
-
-Sequel::Deprecation.deprecate("The sequel_3_dataset_methods extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-#
-module Sequel
-  module Sequel3DatasetMethods
-    COMMA = ', '
-    Sequel::Deprecation.deprecate_constant(self, :COMMA)
-
-    # Change the database for this dataset.
-    def db=(v)
-      raise_if_frozen!("db=")
-      @db = v
-      @cache = {}
-    end
-
-    # Change the options for this dataset.
-    def opts=(v)
-      raise_if_frozen!("opts=")
-      @opts = v
-      @cache = {}
-    end
-
-    # 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)
-      where(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].where(: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].where(: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 = String.new
-      csv << "#{cols.join(', ')}\r\n" if include_column_titles
-      n.each{|r| csv << "#{cols.map{|c| r[c]}.join(', ')}\r\n"}
-      csv
-    end
-  end
-
-  Dataset.register_extension(:sequel_3_dataset_methods, Sequel3DatasetMethods)
-end

data/lib/sequel/extensions/set_overrides.rb

@@ -1,82 +0,0 @@
-# frozen-string-literal: true
-#
-# 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)
-#
-# Related module: Sequel::SetOverrides
-
-Sequel::Deprecation.deprecate("The set_overrides extension", "Please consider maintaining it yourself as an external sequel extension if you want to continue using it")
-
-#
-module Sequel
-  module SetOverrides
-    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
-
-    # Dataset options that do not affect the generated SQL.
-    def non_sql_option?(key)
-      super || key == :defaults || key == :overrides
-    end
-  end
-
-  Dataset.register_extension(:set_overrides, SetOverrides)
-end

data/lib/sequel/no_core_ext.rb

@@ -1,4 +0,0 @@
-# frozen-string-literal: true
-
-require 'sequel'
-Sequel::Deprecation.deprecate("requiring 'sequel/no_core_ext'", "Just require 'sequel' instead")

data/lib/sequel/plugins/association_autoreloading.rb

@@ -1,11 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The association_autoreloading 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 AssociationAutoreloading
-    end
-  end
-end

data/lib/sequel/plugins/identifier_columns.rb

@@ -1,49 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::Deprecation.deprecate("The identifier_columns plugin", "Set Sequel.split_symbols = false instead")
-
-module Sequel
-  module Plugins
-    # The identifier_columns plugin makes Sequel automatically
-    # handle column names containing 2 or more consecutive
-    # underscores when creating or updating model objects.
-    # By default, this doesn't work correctly in Sequel, as it
-    # handles such symbols specially.
-    #
-    # This behavior isn't the default as it hurts performance,
-    # and is rarely necessary.
-    #
-    # Usage:
-    #
-    #   # Make all model subclasses handle column names
-    #   # with two or more underscores when saving
-    #   Sequel::Model.plugin :identifier_columns
-    #
-    #   # Make the Album class handle column names
-    #   # with two or more underscores when saving
-    #   Album.plugin :identifier_columns
-    module IdentifierColumns
-      module InstanceMethods
-        private
-
-        # Use identifiers for value hash keys when inserting.
-        def _insert_values
-          identifier_hash(super)
-        end
-
-        # Use identifiers for value hash keys when updating.
-        def _update_without_checking(columns)
-          super(identifier_hash(columns))
-        end
-
-        # Convert the given columns hash from symbol
-        # keys to Sequel::SQL::Identifier keys.
-        def identifier_hash(columns)
-          h = {}
-          columns.each{|k,v| h[Sequel.identifier(k)] = v}
-          h
-        end
-      end
-    end
-  end
-end

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