sequel 4.49.0 → 5.0.0

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -53,10 +53,6 @@ module Sequel
 
     # DateTime subclass literalized as CURRENT_TIMESTAMP
     class DateTime < ::DateTime; end
-
-    # Mapping of Time/DateTime classes to subclasses literalized as CURRENT_TIMESTAMP
-    MAP = {::Time=>Time, ::DateTime=>DateTime}
-    Sequel::Deprecation.deprecate_constant(self, :MAP)
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)

data/lib/sequel/extensions/date_arithmetic.rb

@@ -10,8 +10,8 @@
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
 # to return Sequel expressions:
 #
-#   add = Sequel.date_add(:date_column, :years=>1, :months=>2, :days=>3)
-#   sub = Sequel.date_sub(:date_column, :hours=>1, :minutes=>2, :seconds=>3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, days: 3)
+#   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
 # support for specifying the interval as an ActiveSupport::Duration
@@ -66,8 +66,6 @@ module Sequel
         DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
-        FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
-        Sequel::Deprecation.deprecate_constant(self, :FDBSQL_DURATION_UNITS)
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
@@ -93,8 +91,7 @@ module Sequel
               args << "#{value} #{sql_unit}"
             end
             return function_sql_append(sql, Sequel.function(:datetime, *args))
-          # SEQUEL5: Remove cubrid
-          when :mysql, :hsqldb, :cubrid
+          when :mysql, :hsqldb
             if db_type == :hsqldb
               # HSQLDB requires 2.2.9+ for the DATE_ADD function
               expr = Sequel.cast(expr, Time)
@@ -181,12 +178,15 @@ module Sequel
                raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
              end
           end
-          interval
+          Hash[interval]
         else
           h = Hash.new(0)
           interval.parts.each{|unit, value| h[unit] += value}
           Hash[h]
         end
+
+        @interval.freeze
+        freeze
       end
 
       to_s_method :date_add_sql

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -10,24 +10,28 @@
 #
 #   DB.extension :duplicate_columns_handler
 #
+# or into individual datasets:
+#
+#   ds = DB[:items].extension(:duplicate_columns_handler)
+#
 # A database option is introduced: :on_duplicate_columns. It accepts a Symbol
 # or any object that responds to :call.
 #
-#   :on_duplicate_columns => :raise
-#   :on_duplicate_columns => :warn
-#   :on_duplicate_columns => :ignore
-#   :on_duplicate_columns => proc { |columns| arbitrary_condition? ? :raise : :warn }
+#   on_duplicate_columns: :raise
+#   on_duplicate_columns: :warn
+#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
 #
 # You may also configure duplicate columns handling for a specific dataset:
 #
 #   ds.on_duplicate_columns(:warn)
 #   ds.on_duplicate_columns(:raise)
 #   ds.on_duplicate_columns(:ignore)
-#   ds.on_duplicate_columns { |columns| arbitrary_condition? ? :raise : :warn }
-#   ds.on_duplicate_columns(proc { |columns| arbitrary_condition? ? :raise : :warn })
+#   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
+#   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
 #
 # If :raise is specified, a Sequel::DuplicateColumnError is raised.
-# If :warn is specified, you will receive a warning via `warn`.
+# If :warn is specified, you will receive a warning via +warn+.
 # If a callable is specified, it will be called.
 # If no on_duplicate_columns is specified, the default is :warn.
 #
@@ -45,8 +49,7 @@ module Sequel
 
     private
 
-    # Override the attr_writer to check for duplicate columns, and call
-    # handle_duplicate_columns if necessary.
+    # Call handle_duplicate_columns if there are duplicate columns.
     def columns=(cols)
       if cols && cols.uniq.size != cols.size
         handle_duplicate_columns(cols)

data/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -4,9 +4,9 @@
 # array value to consider NULL values if one of the referenced
 # columns is NULL:
 #
-#   DB[:test].where(:name=>[])
+#   DB[:test].where(name: [])
 #   # SELECT * FROM test WHERE (name != name)
-#   DB[:test].exclude(:name=>[])
+#   DB[:test].exclude(name: [])
 #   # SELECT * FROM test WHERE (name = name)
 #
 # The default Sequel behavior is to ignore NULLs, as the above

data/lib/sequel/extensions/eval_inspect.rb

@@ -36,16 +36,7 @@ module Sequel
         "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
       when Time
         datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
-        if RUBY_VERSION < '1.9'
-        # :nocov:
-          # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
-          hours, mins = obj.utc_offset.divmod(3600)
-          mins /= 60
-          "#{obj.class}.parse(#{obj.strftime("#{datepart}%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
-        # :nocov:
-        else
-          "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
-        end
+        "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
       when DateTime
         # Ignore date of calendar reform
         "DateTime.parse(#{obj.strftime('%FT%T.%N%z').inspect})"
@@ -73,9 +64,11 @@ module Sequel
         args = inspect_args.map do |arg|
           if arg.is_a?(String) && arg =~ /\A\*/
             # Special case string arguments starting with *, indicating that
-            # they should return an array to be splatted as the remaining arguments
+            # they should return an array to be splatted as the remaining arguments.
+            # Allow calling private methods to get inspect output.
             send(arg.sub('*', '')).map{|a| Sequel.eval_inspect(a)}.join(', ')
           else
+            # Allow calling private methods to get inspect output.
             Sequel.eval_inspect(send(arg))
           end
         end

data/lib/sequel/extensions/freeze_datasets.rb

@@ -1,71 +1,3 @@
 # frozen-string-literal: true
-#
-# The freeze_datasets extension freezes a databases's datasets by
-# default, and makes it so the databases's datasets are always
-# frozen.  This makes sure you can never accidentally modify a
-# dataset that may be used elsewhere (such as a model class's
-# dataset or the same dataset being used in another thread).
-# Frozen datasets can also perform caching for many
-# different methods that can significantly improve performance.
-#
-# In addition to the caching provided by frozen datasets, this
-# also adds caching of Database#from calls if the method is
-# called with a single Symbol argument and not a block.  In
-# addition to speeding up Dataset#from itself, because it
-# returns a cached dataset, all caching done by that dataset
-# can also improve performance.
-#
-# Usage:
-#
-#   DB.extension(:freeze_datasets)
-#
-# Related module: Sequel::FreezeDatasets
 
-#
-module Sequel
-  class Database
-    module FreezeDatasets
-      module DatasetMethods
-        # Make dup be an alias to clone, so that it
-        # returns a frozen dataset.
-        def dup
-          clone
-        end
-      end
-
-      # Reset the default dataset for this database after
-      # loading the extension.
-      def self.extended(db)
-        db.extend_datasets(DatasetMethods)
-      end
-
-      # Cache returned dataset if given a single argument and no block.
-      def from(*args, &block)
-        if !block && args.length == 1 && (table = args[0]).is_a?(Symbol)
-           @default_dataset.send(:cached_dataset, :"_from_#{table}_ds"){super}
-        else
-          super
-        end
-      end
-
-      # Freeze datasets created from this dataset.
-      def dataset
-        super.freeze
-      end
-
-      private
-
-      # Clear the cache of the default dataset when removing a cached
-      # schema, in order to clear the from table cache.
-      def remove_cached_schema(table)
-        cache = @default_dataset.send(:cache)
-        Sequel.synchronize{cache.clear}
-        super
-      end
-    end
-
-    register_extension(:freeze_datasets, FreezeDatasets)
-  end
-end
-
-# Sequel::Database.register_extension(:freeze_datasets){} # SEQUEL5
+Sequel::Database.register_extension(:freeze_datasets){}

data/lib/sequel/extensions/from_block.rb

@@ -1,37 +1,3 @@
 # frozen-string-literal: true
-#
-# The from_block extension changes Database#from so that blocks given
-# to it are treated as virtual rows applying to the FROM clause,
-# instead of virtual rows applying to the WHERE clause.  This will
-# probably be made the default in the next major version of Sequel.
-#
-# This makes it easier to use table returning functions:
-#
-#   DB.from{table_function(1)}
-#   # SELECT * FROM table_function(1)
-#
-# To load the extension into the database:
-#
-#   DB.extension :from_block
-#
-# Related module: Sequel::Database::FromBlock
 
-#
-module Sequel
-  module Database::FromBlock
-    # If a block is given, make it affect the FROM clause:
-    #   DB.from{table_function(1)}
-    #   # SELECT * FROM table_function(1)
-    def from(*args, &block)
-      if block
-        @default_dataset.from(*args, &block)
-      else
-        super
-      end
-    end
-  end
-
-  Database.register_extension(:from_block, Database::FromBlock)
-end
-
-# Sequel::Database.register_extension(:from_block){} # SEQUEL5
+Sequel::Database.register_extension(:from_block){}

data/lib/sequel/extensions/graph_each.rb

@@ -4,7 +4,7 @@
 # makes Dataset#each call #graph_each if the dataset has been graphed.
 # Dataset#graph_each splits result hashes into subhashes per table:
 #
-#   DB[:a].graph(:b, :id=>:b_id).all
+#   DB[:a].graph(:b, id: :b_id).all
 #   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
 #
 # You can load this extension into specific datasets:
@@ -56,7 +56,7 @@ module Sequel
       datasets = datasets.map{|ta, ds| [ta, ds, ds.row_proc]}
       # Use the manually set graph aliases, if any, otherwise
       # use the ones automatically created by .graph
-      column_aliases = @opts[:graph_aliases] || @opts[:graph][:column_aliases] # SEQUEL5: Remove :graph_aliases support
+      column_aliases = @opts[:graph][:column_aliases]
       fetch_rows(sql) do |r|
         graph = {}
         # Create the sub hashes, one per table

data/lib/sequel/extensions/identifier_mangling.rb

@@ -120,10 +120,9 @@ module Sequel
       # Reset the identifier mangling options.  Overrides any already set on
       # the instance.  Only for internal use by shared adapters.
       def reset_identifier_mangling
-        # SEQUEL5: Stop checking Database.*
-        @quote_identifiers = @opts.fetch(:quote_identifiers){(qi = Database.quote_identifiers).nil? ? quote_identifiers_default : qi}
-        @identifier_input_method = @opts.fetch(:identifier_input_method){(iim = Database.identifier_input_method).nil? ? identifier_input_method_default : (iim if iim)}
-        @identifier_output_method = @opts.fetch(:identifier_output_method){(iom = Database.identifier_output_method).nil? ? identifier_output_method_default : (iom if iom)}
+        @quote_identifiers = @opts.fetch(:quote_identifiers, quote_identifiers_default)
+        @identifier_input_method = @opts.fetch(:identifier_input_method, identifier_input_method_default)
+        @identifier_output_method = @opts.fetch(:identifier_output_method, identifier_output_method_default)
         reset_default_dataset
       end
     end
@@ -135,25 +134,12 @@ module Sequel
         @opts.fetch(:identifier_input_method, db.identifier_input_method)
       end
       
-      # Set the method to call on identifiers going into the database for this dataset
-      def identifier_input_method=(v)
-        raise_if_frozen!(%w"identifier_input_method= with_identifier_input_method")
-        skip_symbol_cache!
-        @opts[:identifier_input_method] = v
-      end
-      
       # The String instance method to call on identifiers before sending them to
       # the database.
       def identifier_output_method
         @opts.fetch(:identifier_output_method, db.identifier_output_method)
       end
     
-      # Set the method to call on identifiers coming the database for this dataset
-      def identifier_output_method=(v)
-        raise_if_frozen!(%w"identifier_output_method= with_identifier_output_method")
-        @opts[:identifier_output_method] = v
-      end
-
       # Check with the database to see if identifier quoting is enabled
       def quote_identifiers?
         @opts.fetch(:quote_identifiers, db.quote_identifiers?)
@@ -174,14 +160,18 @@ module Sequel
       # Convert the identifier to the version used in the database via
       # identifier_input_method.
       def input_identifier(v)
-        (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
+        (i = identifier_input_method) ? v.to_s.public_send(i) : v.to_s
       end
 
       # Modify the identifier returned from the database based on the
       # identifier_output_method.
       def output_identifier(v)
         v = 'untitled' if v == ''
-        (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
+        (i = identifier_output_method) ? v.to_s.public_send(i).to_sym : v.to_sym
+      end
+
+      def non_sql_option?(key)
+        super || key == :identifier_input_method || key == :identifier_output_method
       end
     end
   end

data/lib/sequel/extensions/implicit_subquery.rb

@@ -27,7 +27,7 @@
 module Sequel
   class Dataset
     module ImplicitSubquery
-      exceptions = [:and, :add_graph_aliases, :filter, :from, :from_self, :naked, :or, :order_more,
+      exceptions = [:add_graph_aliases, :filter, :from, :from_self, :naked, :or, :order_more,
                     :qualify, :reverse, :reverse_order, :select_all, :select_more, :server,
                     :set_graph_aliases, :unfiltered, :ungraphed, :ungrouped, :unlimited, :unordered,
                     :with_sql]
@@ -35,7 +35,7 @@ module Sequel
       (Dataset::QUERY_METHODS - Dataset::JOIN_METHODS - exceptions + additions).each do |meth|
         define_method(meth) do |*a, &b|
           if opts[:sql]
-            from_self.send(meth, *a, &b)
+            from_self.public_send(meth, *a, &b)
           else
             super(*a, &b)
           end

data/lib/sequel/extensions/inflector.rb

@@ -95,8 +95,8 @@ class String
       (@uncountables << words).flatten!
     end
 
-    Sequel.require('default_inflections', 'model')
-    instance_eval(&Sequel::DEFAULT_INFLECTIONS_PROC)
+    require_relative '../model/default_inflections'
+    instance_exec(&Sequel::DEFAULT_INFLECTIONS_PROC)
   end
 
   # Yield the Inflections module if a block is given, and return
@@ -151,7 +151,7 @@ class String
   # Example
   #   "puni_puni".dasherize #=> "puni-puni"
   def dasherize
-    gsub(/_/, '-')
+    gsub('_', '-')
   end
 
   # Removes the module part from the expression in the string
@@ -181,7 +181,7 @@ class String
   #   "employee_salary" #=> "Employee salary"
   #   "author_id" #=> "Author"
   def humanize
-    gsub(/_id$/, "").gsub(/_/, " ").capitalize
+    gsub(/_id$/, "").gsub('_', " ").capitalize
   end
 
   # Returns the plural form of the word in the string.

data/lib/sequel/extensions/migration.rb

@@ -41,7 +41,7 @@ module Sequel
     # direction.
     def self.apply(db, direction)
       raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
-      new(db).send(direction)
+      new(db).public_send(direction)
     end
 
     # Returns the list of Migration descendants.
@@ -65,6 +65,7 @@ module Sequel
     
     # Intercepts method calls intended for the database and sends them along.
     def method_missing(method_sym, *args, &block)
+      # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
 
@@ -99,29 +100,29 @@ module Sequel
     end
 
     # Apply the appropriate block on the +Database+
-    # instance using instance_eval.
+    # instance using instance_exec.
     def apply(db, direction)
       raise(ArgumentError, "Invalid migration direction specified (#{direction.inspect})") unless [:up, :down].include?(direction)
-      if prok = send(direction)
-        db.instance_eval(&prok)
+      if prok = public_send(direction)
+        db.instance_exec(&prok)
       end
     end
   end
 
   # Internal class used by the Sequel.migration DSL, part of the +migration+ extension.
   class MigrationDSL < BasicObject
-    # The underlying Migration instance
+    # The underlying SimpleMigration instance
     attr_reader :migration
 
     def self.create(&block)
       new(&block).migration
     end
 
-    # Create a new migration class, and instance_eval the block.
+    # Create a new migration class, and instance_exec the block.
     def initialize(&block)
       @migration = SimpleMigration.new
       Migration.descendants << migration
-      instance_eval(&block)
+      instance_exec(&block)
     end
 
     # Defines the migration's down action.
@@ -150,7 +151,7 @@ module Sequel
     # the block.
     #
     # There are no guarantees that this will work perfectly
-    # in all cases, but it should work for most common cases.
+    # in all cases, but it works for some simple cases.
     def change(&block)
       migration.up = block
       migration.down = MigrationReverser.new.reverse(&block)
@@ -170,7 +171,7 @@ module Sequel
     # the given block.
     def reverse(&block)
       begin
-        instance_eval(&block)
+        instance_exec(&block)
       rescue
         just_raise = true
       end
@@ -180,12 +181,9 @@ module Sequel
         actions = @actions.reverse
         Proc.new do
           actions.each do |a|
-            if a.last.is_a?(Proc)
-              pr = a.pop
-              send(*a, &pr)
-            else
-              send(*a)
-            end
+            pr = a.last.is_a?(Proc) ? a.pop : nil
+            # Allow calling private methods as the reversing methods are private
+            send(*a, &pr)
           end
         end
       end
@@ -233,8 +231,9 @@ module Sequel
     end
 
     def reverse(&block)
-      instance_eval(&block)
+      instance_exec(&block)
       actions = @actions.reverse
+      # Allow calling private methods as the reversing methods are private
       Proc.new{actions.each{|a| send(*a)}}
     end
 
@@ -339,25 +338,20 @@ module Sequel
   #
   # For example, to migrate the database all the way down:
   #
-  #   Sequel::Migrator.run(DB, '.', :target=>0)
+  #   Sequel::Migrator.run(DB, '.', target: 0)
   #
   # For example, to migrate the database to version 4:
   #
-  #   Sequel::Migrator.run(DB, '.', :target=>4)
+  #   Sequel::Migrator.run(DB, '.', target: 4)
   #
   # To migrate the database from version 1 to version 5:
   #
-  #   Sequel::Migrator.run(DB, '.', :target=>5, :current=>1)
+  #   Sequel::Migrator.run(DB, '.', target: 5, current: 1)
   #
   # Part of the +migration+ extension.
   class Migrator
     MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
 
-    MIGRATION_SPLITTER = '_'.freeze
-    Sequel::Deprecation.deprecate_constant(self, :MIGRATION_SPLITTER)
-    MINIMUM_TIMESTAMP = 20000101
-    Sequel::Deprecation.deprecate_constant(self, :MINIMUM_TIMESTAMP)
-
     # Exception class raised when there is an error with the migrator's
     # file structure, database, or arguments.
     class Error < Sequel::Error
@@ -397,16 +391,15 @@ module Sequel
     #
     # Examples: 
     #   Sequel::Migrator.run(DB, "migrations")
-    #   Sequel::Migrator.run(DB, "migrations", :target=>15, :current=>10)
-    #   Sequel::Migrator.run(DB, "app1/migrations", :column=> :app2_version)
-    #   Sequel::Migrator.run(DB, "app2/migrations", :column => :app2_version, :table=>:schema_info2)
+    #   Sequel::Migrator.run(DB, "migrations", target: 15, current: 10)
+    #   Sequel::Migrator.run(DB, "app1/migrations", column: :app2_version)
+    #   Sequel::Migrator.run(DB, "app2/migrations", column: :app2_version, table: :schema_info2)
     def self.run(db, directory, opts=OPTS)
       migrator_class(directory).new(db, directory, opts).run
     end
 
     # Choose the Migrator subclass to use.  Uses the TimestampMigrator
-    # if the version number appears to be a unix time integer for a year
-    # after 2005, otherwise uses the IntegerMigrator.
+    # if the version number is greater than 20000101, otherwise uses the IntegerMigrator.
     def self.migrator_class(directory)
       if self.equal?(Migrator)
         Dir.new(directory).each do |file|
@@ -508,11 +501,6 @@ module Sequel
   # version number starting with 1, where missing or duplicate migration file
   # versions are not allowed.  Part of the +migration+ extension.
   class IntegerMigrator < Migrator
-    DEFAULT_SCHEMA_COLUMN = :version
-    DEFAULT_SCHEMA_TABLE = :schema_info
-    Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SCHEMA_COLUMN)
-    Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SCHEMA_TABLE)
-
     Error = Migrator::Error
 
     # The current version for this migrator
@@ -663,17 +651,12 @@ module Sequel
     end
   end
 
-  # The migrator used if any migration file version appears to be a timestamp.
+  # The migrator used if any migration file version is greater than 20000101.
   # Stores filenames of migration files, and can figure out which migrations
   # have not been applied and apply them, even if earlier migrations are added
   # after later migrations.  If you plan to do that, the responsibility is on
   # you to make sure the migrations don't conflict. Part of the +migration+ extension.
   class TimestampMigrator < Migrator
-    DEFAULT_SCHEMA_COLUMN = :filename
-    DEFAULT_SCHEMA_TABLE = :schema_migrations
-    Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SCHEMA_COLUMN)
-    Sequel::Deprecation.deprecate_constant(self, :DEFAULT_SCHEMA_TABLE)
-    
     Error = Migrator::Error
 
     # Array of strings of applied migration filenames