sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/index_caching.rb

@@ -0,0 +1,109 @@
+# frozen-string-literal: true
+#
+# The index_caching extension adds a few methods to Sequel::Database
+# that make it easy to dump information about database indexes to a file,
+# and load it from that file.  Loading index information from a
+# dumped file is faster than parsing it from the database, so this
+# can save bootup time for applications with large numbers of index.
+#
+# Basic usage in application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+# Then, whenever database indicies are modified, write a new cached
+# file.  You can do that with <tt>bin/sequel</tt>'s -X option:
+#
+#   bin/sequel -X /path/to/index_cache.dump postgres://...
+#
+# Alternatively, if you don't want to dump the index information for
+# all tables, and you don't worry about race conditions, you can
+# choose to use the following in your application code:
+#
+#   DB = Sequel.connect('...')
+#   DB.extension :index_caching
+#   DB.load_index_cache?('/path/to/index_cache.dump')
+#
+#   # load model files
+#
+#   DB.dump_index_cache?('/path/to/index_cache.dump')
+#
+# With this method, you just have to delete the index dump file if
+# the schema is modified, and the application will recreate it for you
+# using just the tables that your models use.
+#
+# Note that it is up to the application to ensure that the dumped
+# index cache reflects the current state of the database.  Sequel
+# does no checking to ensure this, as checking would take time and the
+# purpose of this code is to take a shortcut.
+#
+# The index cache is dumped in Marshal format, since it is the fastest
+# and it handles all ruby objects used in the indexes hash.  Because of this,
+# you should not attempt to load from an untrusted file.
+#
+# Related module: Sequel::IndexCaching
+
+#
+module Sequel
+  module IndexCaching
+    # Set index cache to the empty hash.
+    def self.extended(db)
+      db.instance_variable_set(:@indexes, {})
+    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))}
+      nil
+    end
+
+    # Dump the index cache to the filename given unless the file
+    # already exists.
+    def dump_index_cache?(file)
+      dump_index_cache(file) unless File.exist?(file)
+    end
+
+    # Replace the index cache with the data from the given file, which
+    # should be in Marshal format.
+    def load_index_cache(file)
+      @indexes = Marshal.load(File.read(file))
+      nil
+    end
+
+    # Replace the index cache with the data from the given file if the
+    # file exists.
+    def load_index_cache?(file)
+      load_index_cache(file) if File.exist?(file)
+    end
+
+    # If no options are provided and there is cached index information for
+    # the table, return the cached information instead of querying the
+    # database.
+    def indexes(table, opts=OPTS)
+      return super unless opts.empty?
+
+      quoted_name = literal(table)
+      if v = Sequel.synchronize{@indexes[quoted_name]}
+        return v
+      end
+
+      result = super
+      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)
+end

data/lib/sequel/extensions/inflector.rb

@@ -95,16 +95,24 @@ 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
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
+  
+  %w'classify constantize dasherize demodulize foreign_key humanize pluralize singularize tableize underscore'.each do |m|
+    # :nocov:
+    if method_defined?(m)
+      alias_method(m, m)
+    end
+    # :nocov:
+  end
 
   # By default, camelize converts the string to UpperCamelCase. If the argument to camelize
   # is set to :lower then camelize produces lowerCamelCase.
@@ -151,7 +159,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 +189,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/integer64.rb

@@ -0,0 +1,32 @@
+# frozen-string-literal: true
+#
+# The integer64 extension changes the default type used for Integer
+# to be the same type as used for :Bignum.  In general, this means that
+# instead of Integer resulting in a 32-bit database integer type, it will
+# result in a 64-bit database integer type.  This affects the default
+# type used for primary_key and foreign_key when using the schema
+# modification methods.
+#
+# Note that it doesn't make sense to use this extension on SQLite, since
+# the integer type will automatically handle 64-bit integers, and it treats
+# the integer type specially when the column is also the primary key.
+# 
+# To load the extension into the database:
+#
+#   DB.extension :integer64
+#
+# Related module: Sequel::Integer64
+
+#
+module Sequel
+  module Integer64
+    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
+  end
+
+  Database.register_extension(:integer64, Integer64)
+end

data/lib/sequel/extensions/is_distinct_from.rb

@@ -0,0 +1,141 @@
+# frozen-string-literal: true
+#
+# The is_distinct_from extension adds the ability to use the
+# SQL standard IS DISTINCT FROM operator, which is similar to the
+# not equals operator, except that NULL values are considered
+# equal.  PostgreSQL, SQLite 3.39+, and H2 currently support this operator.  On 
+# other databases, support is emulated.
+#
+# First, you need to load the extension into the database:
+#
+#   DB.extension :is_distinct_from
+#
+# Then you can use the Sequel.is_distinct_from to create the expression
+# objects:  
+#
+#   expr = Sequel.is_distinct_from(:column_a, :column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#
+# You can also use the +is_distinct_from+ method on most Sequel expressions:
+#
+#   expr = Sequel[:column_a].is_distinct_from(:column_b)
+#   # (column_a IS DISTINCT FROM column_b)
+#   
+# These expressions can be used in your datasets, or anywhere else that
+# Sequel expressions are allowed:
+#
+#   DB[:table].where(expr)
+#
+# Related module: Sequel::SQL::IsDistinctFrom
+
+#
+module Sequel
+  module SQL
+    module Builders
+      # Return a IsDistinctFrom expression object, using the IS DISTINCT FROM operator
+      # with the given left hand side and right hand side.
+      def is_distinct_from(lhs, rhs)
+        BooleanExpression.new(:NOOP, IsDistinctFrom.new(lhs, rhs))
+      end
+    end
+
+    # Represents an SQL expression using the IS DISTINCT FROM operator.
+    class IsDistinctFrom < GenericExpression
+      # These methods are added to expressions, allowing them to return IS DISTINCT
+      # FROM expressions based on the receiving expression.
+      module Methods
+        # Return a IsDistinctFrom expression, using the IS DISTINCT FROM operator,
+        # with the receiver as the left hand side and the argument as the right hand side.
+        def is_distinct_from(rhs)
+          BooleanExpression.new(:NOOP, IsDistinctFrom.new(self, rhs))
+        end
+      end
+
+      # These methods are added to datasets using the is_distinct_from extension
+      # extension, for the purposes of correctly literalizing IsDistinctFrom
+      # expressions for the appropriate database type.
+      module DatasetMethods
+        # Append the SQL fragment for the IS DISTINCT FROM expression to the SQL query.
+        def is_distinct_from_sql_append(sql, idf)
+          lhs = idf.lhs
+          rhs = idf.rhs
+
+          if supports_is_distinct_from?
+            sql << "("
+            literal_append(sql, lhs)
+            sql << " IS DISTINCT FROM "
+            literal_append(sql, rhs)
+            sql << ")"
+          elsif db.database_type == :derby && (lhs == nil || rhs == nil)
+            if lhs == nil && rhs == nil
+              sql << literal_false
+            elsif lhs == nil
+              literal_append(sql, ~Sequel.expr(rhs=>nil))
+            else
+              literal_append(sql, ~Sequel.expr(lhs=>nil))
+            end
+          else
+            literal_append(sql, Sequel.case({(Sequel.expr(lhs=>rhs) | [[lhs, nil], [rhs, nil]]) => 0}, 1) => 1)
+          end
+        end
+
+        private
+
+        # Whether the database supports IS DISTINCT FROM.
+        def supports_is_distinct_from?
+          if defined?(super)
+            return super
+          end
+        
+          case db.database_type
+          when :postgres, :h2
+            true
+          when :sqlite
+            db.sqlite_version >= 33900
+          else
+            false
+          end
+        end
+      end
+
+      # The left hand side of the IS DISTINCT FROM expression.
+      attr_reader :lhs
+
+      # The right hand side of the IS DISTINCT FROM expression.
+      attr_reader :rhs
+
+      def initialize(lhs, rhs)
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      to_s_method :is_distinct_from_sql
+    end
+  end
+
+  class SQL::GenericExpression
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  class LiteralString
+    include SQL::IsDistinctFrom::Methods
+  end
+
+  Dataset.register_extension(:is_distinct_from, SQL::IsDistinctFrom::DatasetMethods)
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQL::IsDistinctFrom::Methods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQL::IsDistinctFrom::Methods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/extensions/looser_typecasting.rb

@@ -5,9 +5,12 @@
 #
 # :float :: use to_f instead of Float()
 # :integer :: use to_i instead of Integer()
-# :decimal :: don't check string conversion with Float()
+# :decimal :: use 0.0 for unsupported strings
 # :string :: silently allow hash and array conversion to string
 #
+# This also removes bytesize checks for string inputs for float, integer
+# and decimal conversions.
+#
 # To load the extension into the database:
 #
 #   DB.extension :looser_typecasting
@@ -17,6 +20,8 @@
 #
 module Sequel
   module LooserTypecasting
+    private
+
     # Typecast the value to a Float using to_f instead of Kernel.Float
     def typecast_value_float(value)
       value.to_f
@@ -32,14 +37,18 @@ module Sequel
       value.to_s
     end
 
-    # Typecast the value to a BigDecimal, without checking if strings
-    # have a valid format.
-    def typecast_value_decimal(value)
-      if value.is_a?(String)
-        BigDecimal.new(value)
-      else
-        super
+    if RUBY_VERSION >= '2.4'
+      def _typecast_value_string_to_decimal(value)
+        BigDecimal(value)
+      rescue
+        BigDecimal('0.0')
+      end
+    else
+      # :nocov:
+      def _typecast_value_string_to_decimal(value)
+        BigDecimal(value)
       end
+      # :nocov:
     end
   end