sequel 4.43.0 → 4.44.0

data/lib/sequel/core.rb

@@ -204,7 +204,7 @@ module Sequel
     array.map do |i|
       if i.is_a?(Array)
         recursive_map(i, converter)
-      elsif i
+      elsif !i.nil?
         converter.call(i)
       end
     end

data/lib/sequel/database/schema_generator.rb

@@ -414,6 +414,33 @@ module Sequel
       # CreateTableGenerator#index for available options.
       #
       #   add_index(:artist_id) # CREATE INDEX table_artist_id_index ON table (artist_id)
+      #
+      # Options:
+      #
+      # :name :: Give a specific name for the index. Highly recommended if you plan on
+      #          dropping the index later.
+      # :where :: A filter expression, used to setup a partial index (if supported).
+      # :unique :: Create a unique index.
+      #
+      # PostgreSQL specific options:
+      #
+      # :concurrently :: Create the index concurrently, so it doesn't require an exclusive lock
+      #                  on the table.
+      # :index_type :: The underlying index type to use for a full_text index, gin by default).
+      # :language :: The language to use for a full text index (simple by default).
+      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
+      #             custom SQL).
+      # :type :: Set the index type (e.g. full_text, spatial, hash, gin, gist, btree).
+      #
+      # MySQL specific options:
+      #
+      # :type :: Set the index type, with full_text and spatial indexes handled specially.
+      #
+      # Microsoft SQL Server specific options:
+      #
+      # :include :: Includes additional columns in the index.
+      # :key_index :: Sets the KEY INDEX to the given value.
+      # :type :: clustered uses a clustered index, full_text uses a full text index.
       def add_index(columns, opts = OPTS)
         @operations << {:op => :add_index, :columns => Array(columns)}.merge!(opts)
       end

data/lib/sequel/dataset/actions.rb

@@ -791,7 +791,7 @@ module Sequel
     #   # {[1, 3]=>['Jim', 'bo'], [2, 4]=>['Bob', 'be'], ...}
     #
     #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
-    #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob'=>{:id=>2, :name=>'Bob'}, ...}
+    #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob']=>{:id=>2, :name=>'Bob'}, ...}
     #
     # Options:
     # :all :: Use all instead of each to retrieve the objects

data/lib/sequel/dataset/query.rb

@@ -281,7 +281,11 @@ module Sequel
       fs = {}
       non_sql = non_sql_options
       @opts.keys.each{|k| fs[k] = nil unless non_sql.include?(k)}
-      clone(fs).from(opts[:alias] ? as(opts[:alias], opts[:column_aliases]) : self)
+      c = clone(fs).from(opts[:alias] ? as(opts[:alias], opts[:column_aliases]) : self)
+      if cols = _columns
+        c.send(:columns=, cols)
+      end
+      c
     end
 
     # Match any of the columns to any of the patterns. The terms can be

data/lib/sequel/extensions/eval_inspect.rb

@@ -26,8 +26,10 @@ module Sequel
     # for eval.
     def eval_inspect(obj)
       case obj
-      when Sequel::SQL::Blob, Sequel::LiteralString, Sequel::SQL::ValueList
-        "#{obj.class}.new(#{obj.inspect})"
+      when Sequel::SQL::Blob, Sequel::LiteralString, BigDecimal
+        "#{obj.class}.new(#{obj.to_s.inspect})"
+      when Sequel::SQL::ValueList
+        "#{obj.class}.new(#{obj.to_a.inspect})"
       when Array
         "[#{obj.map{|o| eval_inspect(o)}.join(', ')}]"
       when Hash
@@ -50,8 +52,6 @@ module Sequel
       when Date
         # Ignore offset and date of calendar reform
         "Date.new(#{obj.year}, #{obj.month}, #{obj.day})"
-      when BigDecimal
-        "BigDecimal.new(#{obj.to_s.inspect})"
       else
         obj.inspect
       end

data/lib/sequel/extensions/implicit_subquery.rb

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+#
+# The implicit_subquery extension changes most dataset methods that
+# return modified datasets to implicitly call from_self if the database
+# currently uses raw SQL.  Sequel's by default does not do this:
+#
+#   DB["SELECT * FROM table"].select(:column).sql
+#   # => "SELECT * FROM table"
+#
+# With this extension, datasets that use raw SQL are implicitly wrapped
+# in a subquery:
+#
+#   DB["SELECT * FROM table"].select(:column).sql
+#   # => "SELECT column FROM (SELECT * FROM table) AS t1"
+#
+# To add this extension to an existing dataset:
+#
+#   ds = ds.extension(:implicit_subquery)
+#
+# To set this as the default behavior for all datasets on a single database:
+#
+#   DB.extension(:implicit_subquery)
+#
+# Related module: Sequel::Dataset::ImplicitSubquery
+
+#
+module Sequel
+  class Dataset
+    module ImplicitSubquery
+      exceptions = [:and, :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]
+      additions = [:join_table]
+      (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)
+          else
+            super(*a, &b)
+          end
+        end
+      end
+    end
+
+    register_extension(:implicit_subquery, ImplicitSubquery)
+  end
+end

data/lib/sequel/extensions/to_dot.rb

@@ -65,7 +65,7 @@ module Sequel
       @stack.push(@i)
       case e
       when LiteralString
-        dot "#{e.inspect}.lit" # core_sql use
+        dot "Sequel.lit(#{e.to_s.inspect})"
       when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
         dot e.inspect
       when Array

data/lib/sequel/model.rb

@@ -37,8 +37,8 @@ module Sequel
     ANONYMOUS_MODEL_CLASSES_MUTEX = @Model_mutex = Mutex.new
 
     # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS +
-      [:each_server]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]
+    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server, :where_all, :where_each, :where_single_value]) -
+      [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]
     
     # Boolean settings that can be modified at the global, class, or instance level.
     BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
@@ -71,8 +71,7 @@ module Sequel
     # If the value is +nil+, the superclass's instance variable is used directly in the subclass.
     INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup,
       :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
-      :@raise_on_save_failure=>nil, :@require_modification=>nil, 
-      :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
+      :@raise_on_save_failure=>nil, :@require_modification=>nil, :@restrict_primary_key=>nil,
       :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
       :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
@@ -110,7 +109,6 @@ module Sequel
     @require_modification = nil
     @require_valid_table = false
     @restrict_primary_key = true
-    @restricted_columns = nil
     @setter_methods = nil
     @simple_pk = nil
     @simple_table = nil

data/lib/sequel/model/associations.rb

@@ -7,7 +7,7 @@ module Sequel
     module Associations
       # Map of association type symbols to association reflection classes.
       ASSOCIATION_TYPES = {}
-    
+
       # Set an empty association reflection hash in the model
       def self.apply(model)
         model.instance_eval do
@@ -23,7 +23,7 @@ module Sequel
       # be instantiated by the user.
       class AssociationReflection < Hash
         include Sequel::Inflections
-    
+
         # Name symbol for the _add internal association method
         def _add_method
           :"_add_#{singularize(self[:name])}"
@@ -56,7 +56,13 @@ module Sequel
       
         # The class associated to the current model class via this association
         def associated_class
-          cached_fetch(:class){constantize(self[:class_name])}
+          cached_fetch(:class) do
+            begin
+              constantize(self[:class_name])
+            rescue NameError => e
+              raise NameError, "#{e.message} (this happened when attempting to find the associated class for #{inspect})", e.backtrace
+            end
+          end
         end
 
         # The dataset associated via this association, with the non-instance specific
@@ -339,6 +345,38 @@ module Sequel
           {filter_by_associations_conditions_key=>ds}
         end
 
+        # Finalize the association by first attempting to populate the thread-safe cache,
+        # and then transfering the thread-safe cache value to the association itself,
+        # so that a mutex is not needed to get the value.
+        def finalize
+          return unless cache = self[:cache]
+
+          finalize_settings.each do |meth, key|
+            next if has_key?(key)
+
+            send(meth)
+            self[key] = cache.delete(key) if cache.has_key?(key)
+          end
+
+          nil
+        end
+
+        # Map of methods to cache keys used for finalizing associations.
+        FINALIZE_SETTINGS = {
+          :associated_class=>:class,
+          :associated_dataset=>:_dataset,
+          :associated_eager_dataset=>:associated_eager_dataset,
+          :eager_limit_strategy=>:_eager_limit_strategy,
+          :filter_by_associations_conditions_dataset=>:filter_by_associations_conditions_dataset,
+          :placeholder_loader=>:placeholder_loader,
+          :predicate_key=>:predicate_key,
+          :predicate_keys=>:predicate_keys,
+          :reciprocal=>:reciprocal,
+        }.freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+    
         # Whether to handle silent modification failure when adding/removing
         # associated records, false by default.
         def handle_silent_modification_failure?
@@ -355,6 +393,18 @@ module Sequel
           end
         end
 
+        # Show which type of reflection this is, and a guess at what line was used to create the
+        # association.
+        def inspect
+          o = self[:orig_opts].dup
+          o.delete(:class)
+          o.delete(:class_name)
+          o.delete(:block) unless o[:block]
+          o[:class] = self[:orig_class] if self[:orig_class]
+
+          "#<#{self.class} #{self[:model]}.#{self[:type]} #{self[:name].inspect}#{", #{o.inspect[1...-1]}" unless o.empty?}>"
+        end
+
         # The limit and offset for this association (returned as a two element array).
         def limit_and_offset
           if (v = self[:limit]).is_a?(Array)
@@ -782,6 +832,18 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :primary_key=>:primary_key,
+          :primary_keys=>:primary_keys,
+          :primary_key_method=>:primary_key_method,
+          :primary_key_methods=>:primary_key_methods,
+          :qualified_primary_key=>:qualified_primary_key,
+          :reciprocal_type=>:reciprocal_type
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # The expression to use on the left hand side of the IN lookup when eager loading
         def predicate_key
           cached_fetch(:predicate_key){qualified_primary_key}
@@ -926,6 +988,13 @@ module Sequel
           :"#{underscore(demodulize(self[:model].name))}_id"
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :qualified_primary_key=>:qualified_primary_key
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false.
         def handle_silent_modification_failure?
           self[:raise_on_save_failure] == false
@@ -1196,6 +1265,22 @@ module Sequel
           :"#{singularize(self[:name])}_id"
         end
       
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :associated_key_array=>:associated_key_array,
+          :qualified_right_key=>:qualified_right_key,
+          :join_table_source=>:join_table_source,
+          :join_table_alias=>:join_table_alias,
+          :qualified_right_primary_key=>:qualified_right_primary_key,
+          :right_primary_key=>:right_primary_key,
+          :right_primary_keys=>:right_primary_keys,
+          :right_primary_key_method=>:right_primary_key_method,
+          :right_primary_key_methods=>:right_primary_key_methods,
+          :select=>:select
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3)).
         # The left key qualified by the join table.
         def predicate_key
@@ -1668,7 +1753,7 @@ module Sequel
         #                              Defaults to :right_primary_key option.
         # :uniq :: Adds a after_load callback that makes the array of objects unique.
         def associate(type, name, opts = OPTS, &block)
-          raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
+          raise(Error, 'invalid association type') unless assoc_class = Sequel.synchronize{ASSOCIATION_TYPES[type]}
           raise(Error, 'Model.associate name argument must be a symbol') unless name.is_a?(Symbol)
 
           # dup early so we don't modify opts
@@ -1716,6 +1801,7 @@ module Sequel
           def_association_instance_methods(opts)
       
           orig_opts.delete(:clone)
+          opts[:orig_class] = orig_opts[:class] || orig_opts[:class_name]
           orig_opts.merge!(:class_name=>opts[:class_name], :class=>opts[:class], :block=>opts[:block])
           opts[:orig_opts] = orig_opts
           # don't add to association_reflections until we are sure there are no errors
@@ -1737,6 +1823,23 @@ module Sequel
           opts.eager_load_results(eo, &block)
         end
 
+        # Freeze association related metadata when freezing model class.
+        def freeze
+          @association_reflections.freeze.each_value(&:freeze)
+          @autoreloading_associations.freeze.each_value(&:freeze)
+          @default_association_options.freeze
+
+          super
+        end
+
+        # Finalize all associations such that values that are looked up
+        # dynamically in associated classes are set statically.
+        # As this modifies the associations, it must be done before
+        # calling freeze.
+        def finalize_associations
+          @association_reflections.each_value(&:finalize)
+        end
+
         # Shortcut for adding a many_to_many association, see #associate
         def many_to_many(name, opts=OPTS, &block)
           associate(:many_to_many, name, opts, &block)

data/lib/sequel/model/base.rb

@@ -238,7 +238,7 @@ module Sequel
       
       # Clear the setter_methods cache
       def clear_setter_methods_cache
-        @setter_methods = nil
+        @setter_methods = nil unless frozen?
       end
   
       # Returns the columns in the result set in their original order.
@@ -249,7 +249,9 @@ module Sequel
       #   Artist.columns
       #   # => [:id, :name]
       def columns
-        @columns || set_columns(dataset.naked.columns)
+        return @columns if @columns
+        return nil if frozen?
+        set_columns(dataset.naked.columns)
       end
     
       # Creates instance using new with the given values and block, and saves it.
@@ -323,7 +325,7 @@ module Sequel
       #   Album.released.by_release_date.for_select_options.sql
       #   # => "SELECT id, name, release_date FROM artists WHERE (release_date <= CURRENT_DATE) ORDER BY release_date"
       #
-      # The following methods are supported: distinct, exclude, exclude_having, grep, group, group_and_count,
+      # The following methods are supported: distinct, eager, exclude, exclude_having, grep, group, group_and_count,
       # group_append, having, limit, offset, order, order_append, order_prepend, select, select_all,
       # select_append, select_group, where, and server.
       #
@@ -388,7 +390,9 @@ module Sequel
       #   # {:id=>{:type=>:integer, :primary_key=>true, ...},
       #   #  :name=>{:type=>:string, :primary_key=>false, ...}} 
       def db_schema
-        @db_schema ||= get_db_schema
+        return @db_schema if @db_schema
+        return nil if frozen?
+        @db_schema = get_db_schema
       end
   
       # Create a column alias, where the column methods have one name, but the underlying storage uses a
@@ -579,7 +583,7 @@ module Sequel
           end
         end
 
-        Sequel.synchronize{@finder_loaders[meth_name] = loader_proc}
+        @finder_loaders[meth_name] = loader_proc
         mod = opts[:mod] || (class << self; self; end)
         if prepare
           def_prepare_method(mod, meth_name)
@@ -605,6 +609,33 @@ module Sequel
         first(*args, &block) || raise(Sequel::NoMatchingRow.new(dataset))
       end
 
+      # Freeze a model class, disallowing any further changes to it.
+      def freeze
+        dataset_module.freeze
+        overridable_methods_module.freeze
+
+        @finder_loaders.freeze
+
+        if @dataset
+          @dataset.freeze
+          @instance_dataset.freeze
+          db_schema.freeze.each_value(&:freeze)
+          columns.freeze
+          setter_methods.freeze
+          @finder_loaders.each_key{|k| finder_for(k)}
+        else
+          @setter_methods = [].freeze
+        end
+
+        @dataset_method_modules.freeze
+        @default_set_fields_options.freeze
+        @finders.freeze
+        @plugins.freeze
+        @allowed_columns.freeze if @allowed_columns
+
+        super
+      end
+
       # Clear the setter_methods cache when a module is included, as it
       # may contain setter methods.
       def include(*mods)
@@ -856,14 +887,16 @@ module Sequel
           end
         end
         self.simple_pk = if key && !key.is_a?(Array)
-          (@dataset || db).literal(key)
+          (@dataset || db).literal(key).freeze
         end
         @primary_key = key
       end
   
       # Cache of setter methods to allow by default, in order to speed up new/set/update instance methods.
       def setter_methods
-        @setter_methods ||= get_setter_methods
+        return @setter_methods if @setter_methods
+        raise if frozen?
+        @setter_methods = get_setter_methods
       end
 
       # Sets up a dataset method that returns a filtered dataset.
@@ -951,11 +984,11 @@ module Sequel
       def convert_input_dataset(ds)
         case ds
         when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
-          self.simple_table = db.literal(ds)
+          self.simple_table = db.literal(ds).freeze
           ds = db.from(ds)
         when Dataset
           self.simple_table = if ds.send(:simple_select_all?)
-            ds.literal(ds.first_source_table)
+            ds.literal(ds.first_source_table).freeze
           end
           @db = ds.db
         else
@@ -1028,7 +1061,7 @@ module Sequel
       # for the method, load the finder and set correctly in the finders hash, then
       # return the finder.
       def finder_for(meth)
-        unless finder = Sequel.synchronize{@finders[meth]}
+        unless finder = (frozen? ? @finders[meth] : Sequel.synchronize{@finders[meth]})
           finder_loader = @finder_loaders.fetch(meth)
           finder = finder_loader.call(self)
           Sequel.synchronize{@finders[meth] = finder}
@@ -1219,7 +1252,7 @@ module Sequel
       # Reset the instance dataset to a modified copy of the current dataset,
       # should be used whenever the model's dataset is modified.
       def reset_instance_dataset
-        @finders.clear if @finders
+        Sequel.synchronize{@finders.clear if @finders}
         @instance_dataset = @dataset.limit(1).naked if @dataset
       end
   
@@ -2042,7 +2075,7 @@ module Sequel
 
       # Get the row of column data from the database.
       def _refresh_get(dataset)
-        if (sql = (m = model).fast_pk_lookup_sql) && !dataset.opts[:lock]
+        if (sql = model.fast_pk_lookup_sql) && !dataset.opts[:lock]
           sql = sql.dup
           ds = use_server(dataset)
           ds.literal_append(sql, pk)
@@ -2528,6 +2561,52 @@ module Sequel
         end
       end
 
+      # Return an array of all rows matching the given filter condition, also
+      # yielding each row to the given block.  Basically the same as where(cond).all(&block),
+      # except it can be optimized to not create an intermediate dataset.
+      #
+      #   Artist.where_all(:id=>[1,2,3])
+      #   # SELECT * FROM artists WHERE (id IN (1, 2, 3))
+      def where_all(cond, &block)
+        if loader = _model_where_loader
+          loader.all(filter_expr(cond), &block)
+        else
+          where(cond).all(&block)
+        end
+      end
+
+      # Iterate over all rows matching the given filter condition, 
+      # yielding each row to the given block.  Basically the same as where(cond).each(&block),
+      # except it can be optimized to not create an intermediate dataset.
+      #
+      #   Artist.where_each(:id=>[1,2,3]){|row| p row}
+      #   # SELECT * FROM artists WHERE (id IN (1, 2, 3))
+      def where_each(cond, &block)
+        if loader = _model_where_loader
+          loader.each(filter_expr(cond), &block)
+        else
+          where(cond).each(&block)
+        end
+      end
+
+      # Filter the datasets using the given filter condition, then return a single value.
+      # This assumes that the dataset has already been setup to limit the selection to
+      # a single column.  Basically the same as where(cond).single_value,
+      # except it can be optimized to not create an intermediate dataset.
+      #
+      #   Artist.select(:name).where_single_value(:id=>1)
+      #   # SELECT name FROM artists WHERE (id = 1) LIMIT 1
+      def where_single_value(cond)
+        if loader = cached_placeholder_literalizer(:_model_where_single_value_loader) do |pl|
+            single_value_ds.where(pl.arg)
+          end
+
+          loader.get(filter_expr(cond))
+        else
+          where(cond).single_value
+        end
+      end
+
       # Given a primary key value, return the first record in the dataset with that primary key
       # value.  If no records matches, returns nil.
       #
@@ -2554,6 +2633,13 @@ module Sequel
 
       private
 
+      # Loader used for where_all and where_each.
+      def _model_where_loader
+        cached_placeholder_literalizer(:_model_where_loader) do |pl|
+          where(pl.arg)
+        end
+      end
+
       # If the dataset is not already ordered, and the model has a primary key,
       # return a clone ordered by the primary key.
       def _primary_key_order