sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/filter_having.rb

@@ -1,63 +0,0 @@
-# frozen-string-literal: true
-#
-# The filter_having extension allows Dataset#filter, #and, #or
-# and #exclude to operate on the HAVING clause if the dataset
-# already has a HAVING clause, which was the historical behavior
-# before Sequel 4.  It is only recommended to use this for
-# backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:filter_having)
-#
-# 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(:filter_having)
-#
-# Related module: Sequel::FilterHaving
-
-#
-module Sequel
-  module FilterHaving
-    # Operate on HAVING clause if HAVING clause already present.
-    def and(*cond, &block)
-      if @opts[:having]
-        having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def exclude(*cond, &block)
-      if @opts[:having]
-        exclude_having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def filter(*cond, &block)
-      if @opts[:having]
-        having(*cond, &block)
-      else
-        super
-      end
-    end
-
-    # Operate on HAVING clause if HAVING clause already present.
-    def or(*cond, &block)
-      if having = @opts[:having]
-        cond = cond.first if cond.size == 1
-        clone(:having => SQL::BooleanExpression.new(:OR, having, filter_expr(cond, &block)))
-      else
-        super
-      end
-    end
-  end
-
-  Dataset.register_extension(:filter_having, FilterHaving)
-end

data/lib/sequel/extensions/hash_aliases.rb

@@ -1,49 +0,0 @@
-# frozen-string-literal: true
-#
-# The hash_aliases extension allows Dataset#select and Dataset#from
-# to treat a hash argument as an alias specification, with keys
-# being the expressions and values being the aliases, 
-# which was the historical behavior before Sequel 4.
-# It is only recommended to use this for backwards compatibility.
-#
-# You can load this extension into specific datasets:
-#
-#   ds = DB[:table]
-#   ds = ds.extension(:hash_aliases)
-#
-# 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(:hash_aliases)
-#
-# Related module: Sequel::HashAliases
-
-#
-module Sequel
-  module HashAliases
-    def from(*source)
-      super(*convert_hash_aliases(source))
-    end
-
-    def select(*columns, &block)
-      virtual_row_columns(columns, block)
-      super(*convert_hash_aliases(columns), &nil)
-    end
-
-    private
-
-    def convert_hash_aliases(columns)
-      m = []
-      columns.each do |i|
-        if i.is_a?(Hash)
-          m.concat(i.map{|k, v| SQL::AliasedExpression.new(k,v)})
-        else
-          m << i
-        end
-      end
-      m
-    end
-  end
-
-  Dataset.register_extension(:hash_aliases, HashAliases)
-end

data/lib/sequel/extensions/meta_def.rb

@@ -1,35 +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
-
-#
-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,84 +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
-
-#
-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,24 +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

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -1,122 +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
-
-#
-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 = String.new
-      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,76 +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
-
-#
-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,3 +0,0 @@
-# frozen-string-literal: true
-
-require 'sequel'

data/lib/sequel/plugins/association_autoreloading.rb

@@ -1,9 +0,0 @@
-# frozen-string-literal: true
-
-module Sequel
-  module Plugins
-    # Empty plugin module for backwards compatibility
-    module AssociationAutoreloading
-    end
-  end
-end

data/lib/sequel/plugins/identifier_columns.rb

@@ -1,47 +0,0 @@
-# frozen-string-literal: true
-
-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,9 +0,0 @@
-# frozen-string-literal: true
-
-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,81 +0,0 @@
-# frozen-string-literal: true
-
-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
-
-        # 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