sequel 4.41.0 → 4.42.0

data/lib/sequel/extensions/columns_introspection.rb

@@ -28,7 +28,9 @@ module Sequel
     # Symbols, SQL::Identifiers, SQL::QualifiedIdentifiers, and
     # SQL::AliasedExpressions.
     def columns
-      return @columns if @columns
+      if cols = _columns
+        return cols
+      end
       if (pcs = probable_columns) && pcs.all?
         self.columns = pcs
       else

data/lib/sequel/extensions/core_extensions.rb

@@ -42,9 +42,9 @@ class Array
   # this array as a value in a filter, but may be necessary if you are using it as a
   # value with placeholder SQL:
   #
-  #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
-  #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
-  #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
+  #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
+  #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+  #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
   def sql_value_list
     ::Sequel::SQL::ValueList.new(self)
   end
@@ -174,10 +174,10 @@ class String
   # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
   # literalization, e.g.:
   #
-  #   DB[:items].filter(:abc => 'def').sql #=>
+  #   DB[:items].where(:abc => 'def').sql #=>
   #     "SELECT * FROM items WHERE (abc = 'def')"
   #
-  #   DB[:items].filter(:abc => 'def'.lit).sql #=>
+  #   DB[:items].where(:abc => 'def'.lit).sql #=>
   #     "SELECT * FROM items WHERE (abc = def)"
   #
   # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:

data/lib/sequel/extensions/core_refinements.rb

@@ -38,9 +38,9 @@ module Sequel::CoreRefinements
     # this array as a value in a filter, but may be necessary if you are using it as a
     # value with placeholder SQL:
     #
-    #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
-    #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
-    #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
+    #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
+    #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
+    #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
     def sql_value_list
       ::Sequel::SQL::ValueList.new(self)
     end
@@ -167,10 +167,10 @@ module Sequel::CoreRefinements
     # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
     # literalization, e.g.:
     #
-    #   DB[:items].filter(:abc => 'def').sql #=>
+    #   DB[:items].where(:abc => 'def').sql #=>
     #     "SELECT * FROM items WHERE (abc = 'def')"
     #
-    #   DB[:items].filter(:abc => 'def'.lit).sql #=>
+    #   DB[:items].where(:abc => 'def'.lit).sql #=>
     #     "SELECT * FROM items WHERE (abc = def)"
     #
     # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -35,6 +35,8 @@
 
 module Sequel
   module DuplicateColumnsHandler
+    CALLER_ARGS = RUBY_VERSION >= '2.0' ? [0,1] : [0]
+
     # 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)
       raise Error, "Cannot provide both an argument and a block to on_duplicate_columns" if handler && block
@@ -47,14 +49,14 @@ module Sequel
       if cols && cols.uniq.size != cols.size
         handle_duplicate_columns(cols)
       end
-      @columns = cols
+      super
     end
 
     private
 
     # Invoke the appropriate behavior when duplicate columns are present.
     def handle_duplicate_columns(cols)
-      message = "One or more duplicate columns present in #{cols.inspect}"
+      message = "#{caller(*CALLER_ARGS).first}: One or more duplicate columns present in #{cols.inspect}"
 
       case duplicate_columns_handler_type(cols)
       when :raise

data/lib/sequel/extensions/freeze_datasets.rb

@@ -0,0 +1,69 @@
+# 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

data/lib/sequel/extensions/identifier_mangling.rb

@@ -0,0 +1,196 @@
+# frozen-string-literal: true
+#
+# The identifier_mangling extension adds support for to change
+# the default identifier mangling for datasets, as well as all
+# datasets for a given database.
+#
+#   # Use uppercase identifiers in database, and lowercase in ruby.
+#   # Default behavior of Sequel, as the SQL standard behavior
+#   # folds unquoted identifiers to uppercase.
+#   DB.identifier_input_method = :upcase
+#   DB.identifier_output_method = :downcase
+#   
+#   # Don't modify identifiers.
+#   # Default behavior of Sequel on PostgreSQL, MySQL, SQLite,
+#   # as they fold unquoted identifiers to lowercase.
+#   DB.identifier_input_method = nil
+#   DB.identifier_output_method = nil
+#
+# You can also choose to turn on or off identifier quoting:
+#
+#   # Quote identifiers.  Sequel's default behavior.
+#   DB.quote_identifiers = true
+# 
+#   # Don't quote identifiers.  Sequel's default behavior on DB2.
+#   DB.quote_identifiers = false
+#   
+# To modify the identifiers on a per-dataset basis:
+#
+#   ds = DB[:a].with_input_indentifier(:upcase).
+#               with_output_identifier(:downcase).
+#               with_quote_identifiers(true)
+#
+# To load the extension into the database:
+#
+#   DB.extension :identifier_mangling
+#
+# Historically, Sequel supported these methods by default on
+# Databases and Datasets.  Sequel 4 will continue to support
+# the methods for backwards compatibility, by loading this
+# extension automatically for databases unless the
+# <tt>:identifier_mangling=>false</tt> Database option is
+# used.
+#
+# Related modules: Sequel::IdentifierMangling::DatabaseMethods,
+# Sequel::IdentifierMangling::DatasetMethods
+
+#
+module Sequel
+  module IdentifierMangling
+    module DatabaseMethods
+      def self.extended(db)
+        db.instance_exec do
+          @identifier_input_method = nil
+          @identifier_output_method = nil
+          @quote_identifiers = nil
+          reset_identifier_mangling
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      # The identifier input method to use by default for this database (default: adapter default)
+      attr_reader :identifier_input_method
+
+      # The identifier output method to use by default for this database (default: adapter default)
+      attr_reader :identifier_output_method
+
+      # Set the method to call on identifiers going into the database:
+      #
+      #   DB[:items] # SELECT * FROM items
+      #   DB.identifier_input_method = :upcase
+      #   DB[:items] # SELECT * FROM ITEMS
+      def identifier_input_method=(v)
+        reset_default_dataset
+        @identifier_input_method = v
+      end
+      
+      # Set the method to call on identifiers coming from the database:
+      #
+      #   DB[:items].first # {:id=>1, :name=>'foo'}
+      #   DB.identifier_output_method = :upcase
+      #   DB[:items].first # {:ID=>1, :NAME=>'foo'}
+      def identifier_output_method=(v)
+        reset_default_dataset
+        @identifier_output_method = v
+      end
+
+      # Set whether to quote identifiers (columns and tables) for this database:
+      #
+      #   DB[:items] # SELECT * FROM items
+      #   DB.quote_identifiers = true
+      #   DB[:items] # SELECT * FROM "items"
+      def quote_identifiers=(v)
+        reset_default_dataset
+        @quote_identifiers = v
+      end
+      
+      # Returns true if the database quotes identifiers.
+      def quote_identifiers?
+        @quote_identifiers
+      end
+
+      private
+
+      # Return a dataset that uses the default identifier input and output methods
+      # for this database.  Used when parsing metadata so that column symbols are
+      # returned as expected.
+      def _metadata_dataset
+        super.
+          with_identifier_input_method(identifier_input_method_default).
+          with_identifier_output_method(identifier_output_method_default)
+      end
+
+      # Upcase identifiers on input if database folds unquoted identifiers to
+      # uppercase.
+      def identifier_input_method_default
+        return super if defined?(super)
+        :upcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      # Downcase identifiers on output if database folds unquoted identifiers to
+      # uppercase.
+      def identifier_output_method_default
+        return super if defined?(super)
+        :downcase if folds_unquoted_identifiers_to_uppercase?
+      end
+
+      # Reset the identifier mangling options.  Overrides any already set on
+      # the instance.  Only for internal use by shared adapters.
+      def reset_identifier_mangling
+        @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)}
+        reset_default_dataset
+      end
+    end
+
+    module DatasetMethods
+      # The String instance method to call on identifiers before sending them to
+      # the database.
+      def identifier_input_method
+        @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!
+        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!
+        @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?)
+      end
+
+      # Return a modified dataset with identifier_input_method set.
+      def with_identifier_input_method(meth)
+        clone(:identifier_input_method=>meth, :skip_symbol_cache=>true)
+      end
+      
+      # Return a modified dataset with identifier_output_method set.
+      def with_identifier_output_method(meth)
+        clone(:identifier_output_method=>meth)
+      end
+
+      private
+
+      # 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
+      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
+      end
+    end
+  end
+
+  Database.register_extension(:identifier_mangling, IdentifierMangling::DatabaseMethods)
+end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -5,7 +5,7 @@
 #
 # :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
 #
 # To load the extension into the database:
@@ -17,6 +17,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,13 +34,15 @@ 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)
+    if RUBY_VERSION >= '2.4'
+      def _typecast_value_string_to_decimal(value)
+        BigDecimal.new(value)
+      rescue
+        BigDecimal.new('0.0')
+      end
+    else
+      def _typecast_value_string_to_decimal(value)
         BigDecimal.new(value)
-      else
-        super
       end
     end
   end

data/lib/sequel/extensions/migration.rb

@@ -687,7 +687,7 @@ module Sequel
         checked_transaction(m) do
           m.apply(db, direction)
           fi = f.downcase
-          direction == :up ? ds.insert(column=>fi) : ds.filter(column=>fi).delete
+          direction == :up ? ds.insert(column=>fi) : ds.where(column=>fi).delete
         end
         db.log_info("Finished applying migration #{f}, direction: #{direction}, took #{sprintf('%0.6f', Time.now - t)} seconds")
       end

data/lib/sequel/extensions/null_dataset.rb

@@ -41,7 +41,7 @@ module Sequel
     module Nullifiable
       # Return a cloned nullified dataset.
       def nullify
-        clone.nullify!
+        clone.with_extend(NullDataset)
       end
 
       # Nullify the current dataset
@@ -54,7 +54,10 @@ module Sequel
       # Create a new dataset from the dataset (which won't
       # be nulled) to get the columns if they aren't already cached.
       def columns
-        @columns ||= db.dataset.clone(@opts).columns
+        if cols = _columns
+          return cols
+        end
+        self.columns = db.dataset.clone(@opts).columns
       end
 
       # Return 0 without sending a database query.

data/lib/sequel/extensions/pagination.rb

@@ -39,9 +39,14 @@ module Sequel
     # number of records for this dataset.
     def paginate(page_no, page_size, record_count=nil)
       raise(Error, "You cannot paginate a dataset that already has a limit") if @opts[:limit]
-      paginated = limit(page_size, (page_no - 1) * page_size)
-      paginated.extend(Dataset::Pagination)
-      paginated.set_pagination_info(page_no, page_size, record_count || count)
+
+      record_count ||= count
+      page_count = (record_count / page_size.to_f).ceil
+      page_count = 1 if page_count == 0
+
+      limit(page_size, (page_no - 1) * page_size).
+        with_extend(Dataset::Pagination).
+        clone(:page_size=>page_size, :current_page=>page_no, :pagination_record_count=>record_count, :page_count=>page_count)
     end
       
     # Yields a paginated dataset for each page and returns the receiver. Does
@@ -61,49 +66,59 @@ module Sequel
     # Holds methods that only relate to paginated datasets. Paginated dataset
     # have pages starting at 1 (page 1 is offset 0, page 1 is offset page_size).
     module Pagination
+      Sequel::Dataset.def_deprecated_opts_setter(self, :page_size, :page_count, :current_page, :pagination_record_count)
+
       # The number of records per page (the final page may have fewer than
       # this number of records).
-      attr_accessor :page_size
+      def page_size
+        @opts[:page_size]
+      end
 
       # The number of pages in the dataset before pagination, of which
       # this paginated dataset is one.  Empty datasets are considered
       # to have a single page.
-      attr_accessor :page_count
+      def page_count
+        @opts[:page_count]
+      end
 
       # The current page of the dataset, starting at 1 and not 0.
-      attr_accessor :current_page
+      def current_page
+        @opts[:current_page]
+      end
 
       # The total number of records in the dataset before pagination.
-      attr_accessor :pagination_record_count
+      def pagination_record_count
+        @opts[:pagination_record_count]
+      end
 
       # Returns the record range for the current page
       def current_page_record_range
-        return (0..0) if @current_page > @page_count
+        return (0..0) if current_page > page_count
         
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
         a..b
       end
 
       # Returns the number of records in the current page
       def current_page_record_count
-        return 0 if @current_page > @page_count
+        return 0 if current_page > page_count
         
-        a = 1 + (@current_page - 1) * @page_size
-        b = a + @page_size - 1
-        b = @pagination_record_count if b > @pagination_record_count
+        a = 1 + (current_page - 1) * page_size
+        b = a + page_size - 1
+        b = pagination_record_count if b > pagination_record_count
         b - a + 1
       end
 
       # Returns true if the current page is the first page
       def first_page?
-        @current_page == 1
+        current_page == 1
       end
 
       # Returns true if the current page is the last page
       def last_page?
-        @current_page == @page_count
+        current_page == page_count
       end
 
       # Returns the next page number or nil if the current page is the last page
@@ -121,15 +136,19 @@ module Sequel
         current_page > 1 ? (current_page - 1) : nil
       end
 
-      # Sets the pagination info for this paginated dataset, and returns self.
+      # SEQUEL5: Remove
+      # :nocov:
       def set_pagination_info(page_no, page_size, record_count)
-        @current_page = page_no
-        @page_size = page_size
-        @pagination_record_count = record_count
-        @page_count = (record_count / page_size.to_f).ceil
-        @page_count = 1 if @page_count == 0
+        Sequel::Deprecation.deprecate("Dataset#set_pagination_info", "It should no longer be necessary to call this method.")
+        self.current_page = page_no
+        self.page_size = page_size
+        self.pagination_record_count = record_count
+        page_count = (record_count / page_size.to_f).ceil
+        page_count = 1 if page_count == 0
+        self.page_count = page_count
         self
       end
+      # :nocov:
     end
   end