sequel 5.8.0 → 5.38.0

data/lib/sequel/extensions/core_refinements.rb

@@ -10,7 +10,9 @@
 #
 #   using Sequel::CoreRefinements
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::CoreRefinements
   refine Array do

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -39,7 +39,9 @@
 
 module Sequel
   module DuplicateColumnsHandler
+    # :nocov:
     CALLER_ARGS = (RUBY_VERSION >= '2.0' ? [0,1] : [0]).freeze
+    # :nocov:
 
     # Customize handling of duplicate columns for this dataset.
     def on_duplicate_columns(handler = (raise Error, "Must provide either an argument or a block to on_duplicate_columns" unless block_given?; nil), &block)

data/lib/sequel/extensions/escaped_like.rb

@@ -0,0 +1,100 @@
+# frozen-string-literal: true
+#
+# The escaped_like extension adds +escaped_like+ and +escaped_ilike+
+# methods to Sequel::SQL::StringMethods, which allow them to be easily
+# used with most of Sequel's expression objects.  Example:
+#
+#   DB[:table].where{string_column.escaped_like('?%', user_input)}
+#   # user_input is 'foo':
+#   #  SELECT * FROM table WHERE string_column LIKE 'foo%' ESCAPE '\'
+#   # user_input is '%foo':
+#   #  SELECT * FROM table WHERE string_column LIKE '\%foo%' ESCAPE '\'
+#
+# To load the extension:
+#
+#   Sequel.extension :escaped_like
+#
+# Related modules: Sequel::SQL::StringMethods, Sequel::SQL::EscapedLikeExpression
+
+#
+module Sequel
+  module SQL
+    # Represents an pattern match SQL expression, where the pattern can depend
+    # upon interpolated values in a database-dependent manner.
+    class EscapedLikeExpression < Expression
+      include AliasMethods
+      include BooleanMethods
+      include CastMethods
+      include OrderMethods
+
+      # Initialize the expression. Arguments:
+      # expr :: Right hand site of LIKE/ILIKE operator, what you are matching against the pattern
+      # case_insensitive :: Whether the match is case sensitive
+      # placeholder_pattern :: The pattern to match against, with +?+ for the placeholders
+      # placeholder_values :: The string values for each +?+ in the placeholder pattern.  Should be an
+      #                       array of strings, though it can be a single string if there is only
+      #                       a single placeholder.
+      def initialize(expr, case_sensitive, placeholder_pattern, placeholder_values)
+        @expr = expr
+        @method = case_sensitive ? :like : :ilike
+        @pattern = placeholder_pattern
+        unless placeholder_values.is_a?(Array)
+          placeholder_values = [placeholder_values].freeze
+        end
+        @values = placeholder_values
+        freeze
+      end
+
+      # Interpolate the pattern values into the placeholder pattern to get the final pattern,
+      # now that we have access to the dataset.  Use the expression and final pattern and
+      # add an appropriate LIKE/ILIKE expression to the SQL being built.
+      def to_s_append(ds, sql)
+        i = -1
+        match_len = @values.length - 1
+        like_pattern = String.new
+        pattern = @pattern
+        while true
+          previous, q, pattern = pattern.partition('?')
+          like_pattern << previous
+
+          unless q.empty?
+            if i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            like_pattern << ds.escape_like(@values.at(i+=1))
+          end
+
+          if pattern.empty?
+            unless i == match_len
+              raise Error, "Mismatched number of placeholders (#{i+1}) and placeholder arguments (#{@values.length}) for escaped like expression: #{@pattern.inspect}"
+            end
+            break
+          end
+        end
+        ds.literal_append(sql, Sequel.send(@method, @expr, like_pattern))
+      end
+    end
+
+    module StringMethods
+      # Create a +EscapedLikeExpression+ case insensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_ilike('?%', 'A') # "a" ILIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_ilike('?%', '%A') # "a" ILIKE '\%A%' ESCAPE '\'
+      def escaped_ilike(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, false, placeholder_pattern, placeholder_values)
+      end
+
+      # Create a +EscapedLikeExpression+ case sensitive pattern match of the receiver
+      # with the patterns, interpolated escaped values for each +?+ placeholder in the
+      # pattern. 
+      #
+      #   Sequel[:a].escaped_like('?%', 'A') # "a" LIKE 'A%' ESCAPE '\'
+      #   Sequel[:a].escaped_like('?%', '%A') # "a" LIKE '\%A%' ESCAPE '\'
+      def escaped_like(placeholder_pattern, placeholder_values)
+        EscapedLikeExpression.new(self, true, placeholder_pattern, placeholder_values)
+      end
+    end
+  end
+end

data/lib/sequel/extensions/eval_inspect.rb

@@ -26,7 +26,9 @@ module Sequel
     # for eval.
     def eval_inspect(obj)
       case obj
-      when Sequel::SQL::Blob, Sequel::LiteralString, BigDecimal
+      when BigDecimal
+        "Kernel::BigDecimal(#{obj.to_s.inspect})"
+      when Sequel::SQL::Blob, Sequel::LiteralString
         "#{obj.class}.new(#{obj.to_s.inspect})"
       when Sequel::SQL::ValueList
         "#{obj.class}.new(#{obj.to_a.inspect})"

data/lib/sequel/extensions/exclude_or_null.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+#
+# The exclude_or_null extension adds Dataset#exclude_or_null and
+# Dataset#exclude_or_null_having.  These methods are similar to
+# Dataset#exclude and Dataset#exclude_having, except that they
+# will also exclude rows where the condition IS NULL.
+#
+#   DB[:table].exclude_or_null(foo: 1)
+#   # SELECT * FROM table WHERE NOT coalesce((foo = 1), false)
+#   
+#   DB[:table].exclude_or_null{foo(bar) =~ 1}
+#   # SELECT * FROM table HAVING NOT coalesce((foo(bar) = 1), false))
+#   
+# You can load this extension into specific datasets:
+#
+#   ds = DB[:table]
+#   ds = ds.extension(:exclude_or_null)
+#
+# 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(:exclude_or_null)
+#
+# Note, this extension works correctly on PostgreSQL, SQLite, MySQL,
+# H2, and HSQLDB.  However, it does not work correctly on Microsoft SQL Server,
+# Oracle, DB2, SQLAnywhere, or Derby.
+#
+# Related module: Sequel::ExcludeOrNull
+
+#
+module Sequel
+  module ExcludeOrNull
+    # Performs the inverse of Dataset#where, but also excludes rows where the given
+    # condition IS NULL.
+    #
+    #   DB[:items].exclude_or_null(category: 'software')
+    #   # SELECT * FROM items WHERE NOT coalesce((category = 'software'), false)
+    #   
+    #   DB[:items].exclude_or_null(category: 'software', id: 3)
+    #   # SELECT * FROM items WHERE NOT coalesce(((category = 'software') AND (id = 3)), false)
+    def exclude_or_null(*cond, &block)
+      add_filter(:where, cond, :or_null, &block)
+    end
+
+    # The same as exclude_or_null, but affecting the HAVING clause instead of the
+    # WHERE clause.
+    #
+    #   DB[:items].select_group(:name).exclude_or_null_having{count(name) < 2}
+    #   # SELECT name FROM items GROUP BY name HAVING NOT coalesce((count(name) < 2), true)
+    def exclude_or_null_having(*cond, &block)
+      add_filter(:having, cond, :or_null, &block)
+    end
+
+    private
+
+    # Recognize :or_null value for invert, returning an expression for
+    # the invert of the condition or the condition being null.
+    def _invert_filter(cond, invert)
+      if invert == :or_null
+        ~SQL::Function.new(:coalesce, cond, SQL::Constants::SQLFALSE)
+      else
+        super
+      end
+    end
+  end
+
+  Dataset.register_extension(:exclude_or_null, ExcludeOrNull)
+end

data/lib/sequel/extensions/fiber_concurrency.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+#
+# The fiber_concurrency extension changes the default concurrency
+# primitive in Sequel to be Fiber.current instead of Thread.current.
+# This is the value used in various hash keys to implement safe
+# concurrency (thread-safe concurrency by default, fiber-safe
+# concurrency with this extension.  It can be enabled via:
+#
+#   Sequel.extension :fiber_concurrency
+#   
+# Related module: Sequel::FiberConcurrency
+
+require 'fiber'
+
+module Sequel
+  module FiberConcurrency
+    # Make the current concurrency primitive be Fiber.current.
+    def current
+      Fiber.current
+    end
+  end
+
+  extend FiberConcurrency
+end

data/lib/sequel/extensions/index_caching.rb

@@ -54,13 +54,6 @@ module Sequel
       db.instance_variable_set(:@indexes, {})
     end
     
-    # Remove the index cache for the given schema name
-    def remove_cached_schema(table)
-      k = quote_schema_table(table)
-      Sequel.synchronize{@indexes.delete(k)}
-      super
-    end
-    
     # Dump the index cache to the filename given in Marshal format.
     def dump_index_cache(file)
       File.open(file, 'wb'){|f| f.write(Marshal.dump(@indexes))}
@@ -101,6 +94,15 @@ module Sequel
       Sequel.synchronize{@indexes[quoted_name] = result}
       result
     end
+
+    private
+
+    # Remove the index cache for the given schema name
+    def remove_cached_schema(table)
+      k = quote_schema_table(table)
+      Sequel.synchronize{@indexes.delete(k)}
+      super
+    end
   end
 
   Database.register_extension(:index_caching, IndexCaching)

data/lib/sequel/extensions/integer64.rb

@@ -20,7 +20,9 @@
 #
 module Sequel
   module Integer64
-    # Use timestamptz by default for generic timestamp value.
+    private
+
+    # Use same type as used for :Bignum by default for generic integer value.
     def type_literal_generic_integer(column)
       type_literal_generic_bignum_symbol(column)
     end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -36,14 +36,14 @@ module Sequel
 
     if RUBY_VERSION >= '2.4'
       def _typecast_value_string_to_decimal(value)
-        BigDecimal.new(value)
+        BigDecimal(value)
       rescue
-        BigDecimal.new('0.0')
+        BigDecimal('0.0')
       end
     else
       # :nocov:
       def _typecast_value_string_to_decimal(value)
-        BigDecimal.new(value)
+        BigDecimal(value)
       end
       # :nocov:
     end

data/lib/sequel/extensions/migration.rb

@@ -68,6 +68,7 @@ module Sequel
       # Allow calling private methods for backwards compatibility
       @db.send(method_sym, *args, &block)
     end
+    ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
 
     # This object responds to all methods the database responds to.
     def respond_to_missing?(meth, include_private)
@@ -176,7 +177,7 @@ module Sequel
         just_raise = true
       end
       if just_raise
-        Proc.new{raise Sequel::Error, 'irreversible migration method used, you may need to write your own down method'}
+        Proc.new{raise Sequel::Error, "irreversible migration method used in #{block.source_location.first}, you may need to write your own down method"}
       else
         actions = @actions.reverse
         Proc.new do
@@ -329,7 +330,8 @@ module Sequel
   # schema_migrations for timestamped migrations). in the database to keep track
   # of the current migration version. If no migration version is stored in the
   # database, the version is considered to be 0. If no target version is 
-  # specified, the database is migrated to the latest version available in the
+  # specified, or the target version specified is greater than the latest
+  # version available, the database is migrated to the latest version available in the
   # migration directory.
   #
   # For example, to migrate the database to the latest version:
@@ -389,7 +391,8 @@ module Sequel
     #             using the :table and :column options.
     # :relative :: Run the given number of migrations, with a positive number being migrations to migrate
     #              up, and a negative number being migrations to migrate down (IntegerMigrator only).
-    # :table :: The table containing the schema version (default: :schema_info).
+    # :table :: The table containing the schema version (default: :schema_info for integer migrations and
+    #           :schema_migrations for timestamped migrations).
     # :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
     #
     # Examples: 
@@ -405,6 +408,7 @@ module Sequel
     # if the version number is greater than 20000101, otherwise uses the IntegerMigrator.
     def self.migrator_class(directory)
       if self.equal?(Migrator)
+        raise(Error, "Must supply a valid migration path") unless File.directory?(directory)
         Dir.new(directory).each do |file|
           next unless MIGRATION_FILE_PATTERN.match(file)
           return TimestampMigrator if file.split('_', 2).first.to_i > 20000101
@@ -516,10 +520,8 @@ module Sequel
     def initialize(db, directory, opts=OPTS)
       super
       @current = opts[:current] || current_migration_version
-      raise(Error, "No current version available") unless current
 
       latest_version = latest_migration_version
-
       @target = if opts[:target]
         opts[:target]
       elsif opts[:relative]
@@ -528,7 +530,7 @@ module Sequel
         latest_version
       end
 
-      raise(Error, "No target version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target
+      raise(Error, "No target and/or latest version available, probably because no migration files found or filenames don't follow the migration filename convention") unless target && latest_version
 
       if @target > latest_version
         @target = latest_version
@@ -537,6 +539,11 @@ module Sequel
       end
 
       @direction = current < target ? :up : :down
+
+      if @direction == :down && @current >= @files.length
+        raise Migrator::Error, "Missing migration version(s) needed to migrate down to target version (current: #{current}, target: #{target})"
+      end
+
       @migrations = get_migrations
     end
 

data/lib/sequel/extensions/named_timezones.rb

@@ -2,18 +2,21 @@
 #
 # Allows the use of named timezones via TZInfo (requires tzinfo).
 # Forces the use of DateTime as Sequel's datetime_class, since
-# ruby's Time class doesn't support timezones other than local
-# and UTC.
+# historically, Ruby's Time class doesn't support timezones other
+# than local and UTC. To continue using Ruby's Time class when using
+# the named_timezones extension:
+#
+#   # Load the extension
+#   Sequel.extension :named_timezones
+#
+#   # Set Sequel.datetime_class back to Time
+#   Sequel.datetime_class = Time
 #
 # This allows you to either pass strings or TZInfo::Timezone
 # instance to Sequel.database_timezone=, application_timezone=, and
 # typecast_timezone=.  If a string is passed, it is converted to a
 # TZInfo::Timezone using TZInfo::Timezone.get.
 #
-# To load the extension:
-#
-#   Sequel.extension :named_timezones
-#
 # Let's say you have the database server in New York and the
 # application server in Los Angeles.  For historical reasons, data
 # is stored in local New York time, but the application server only
@@ -37,7 +40,8 @@
 # Note that typecasting from the database timezone to the application
 # timezone when fetching rows is dependent on the database adapter,
 # and only works on adapters where Sequel itself does the conversion.
-# It should work on mysql, postgres, sqlite, ibmdb, and jdbc.
+# It should work with the mysql, postgres, sqlite, ibmdb, and jdbc
+# adapters.
 #
 # Related module: Sequel::NamedTimezones
 
@@ -63,24 +67,81 @@ module Sequel
 
     private 
     
-    # Assume the given DateTime has a correct time but a wrong timezone.  It is
-    # currently in UTC timezone, but it should be converted to the input_timezone.
-    # Keep the time the same but convert the timezone to the input_timezone.
-    # Expects the input_timezone to be a TZInfo::Timezone instance.
-    def convert_input_datetime_other(v, input_timezone)
-      local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
-      (v - local_offset).new_offset(local_offset)
+    if RUBY_VERSION >= '2.6'
+      # Convert the given input Time (which must be in UTC) to the given input timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_input_time_other(v, input_timezone)
+        Time.new(v.year, v.mon, v.day, v.hour, v.min, (v.sec + Rational(v.nsec, 1000000000)), input_timezone)
+      rescue TZInfo::AmbiguousTime
+        raise unless disamb = tzinfo_disambiguator_for(v)
+        period = input_timezone.period_for_local(v, &disamb)
+        offset = period.utc_total_offset
+        Time.at(v.to_i - offset, :in => input_timezone)
+      end
+
+      # Convert the given input Time to the given output timezone,
+      # which should be a TZInfo::Timezone instance.
+      def convert_output_time_other(v, output_timezone)
+        Time.at(v.to_i, :in => output_timezone)
+      end
+    else
+      # :nodoc:
+      # :nocov:
+      def convert_input_time_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+        Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+      end
+
+      if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i + local_offset
+        end
+      else
+        def convert_output_time_other(v, output_timezone)
+          v = output_timezone.utc_to_local(v.getutc)
+          local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset
+          Time.new(1970, 1, 1, 0, 0, 0, local_offset) + v.to_i
+        end
+      end
     end
 
-    # Convert the given DateTime to use the given output_timezone.
-    # Expects the output_timezone to be a TZInfo::Timezone instance.
-    def convert_output_datetime_other(v, output_timezone)
-      # TZInfo converts times, but expects the given DateTime to have an offset
-      # of 0 and always leaves the timezone offset as 0
-      v = output_timezone.utc_to_local(v.new_offset(0))
-      local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
-      # Convert timezone offset from UTC to the offset for the output_timezone
-      (v - local_offset).new_offset(local_offset)
+    # Handle both TZInfo 1 and TZInfo 2
+    if defined?(TZInfo::VERSION) && TZInfo::VERSION > '2'
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = Rational(input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset, 86400)
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      def convert_output_datetime_other(v, output_timezone)
+        v = output_timezone.utc_to_local(v.new_offset(0))
+
+        # Force DateTime output instead of TZInfo::DateTimeWithOffset
+        DateTime.jd(v.jd, v.hour, v.minute, v.second + v.sec_fraction, v.offset, v.start)
+      end
+      # :nodoc:
+      # :nocov:
+    else
+      # Assume the given DateTime has a correct time but a wrong timezone.  It is
+      # currently in UTC timezone, but it should be converted to the input_timezone.
+      # Keep the time the same but convert the timezone to the input_timezone.
+      # Expects the input_timezone to be a TZInfo::Timezone instance.
+      def convert_input_datetime_other(v, input_timezone)
+        local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        (v - local_offset).new_offset(local_offset)
+      end
+
+      # Convert the given DateTime to use the given output_timezone.
+      # Expects the output_timezone to be a TZInfo::Timezone instance.
+      def convert_output_datetime_other(v, output_timezone)
+        # TZInfo 1 converts times, but expects the given DateTime to have an offset
+        # of 0 and always leaves the timezone offset as 0
+        v = output_timezone.utc_to_local(v.new_offset(0))
+        local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
+        # Convert timezone offset from UTC to the offset for the output_timezone
+        (v - local_offset).new_offset(local_offset)
+      end
     end
     
     # Returns TZInfo::Timezone instance if given a String.