sequel 4.49.0 → 5.0.0

data/lib/sequel/extensions/hash_aliases.rb

@@ -1,51 +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
-
-Sequel::Deprecation.deprecate("The hash_aliases extension", "Please consider maintaining it yourself as an external gem if you want to continue using it")
-
-#
-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,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