sequel 4.33.0 → 4.34.0

data/lib/sequel/database/misc.rb

@@ -108,6 +108,7 @@ module Sequel
     # :identifier_output_method :: A string method symbol to call on identifiers coming from the database.
     # :logger :: A specific logger to use.
     # :loggers :: An array of loggers to use.
+    # :name :: A name to use for the Database object.
     # :preconnect :: Whether to automatically connect to the maximum number of servers.
     # :quote_identifiers :: Whether to quote identifiers.
     # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
@@ -149,7 +150,10 @@ module Sequel
         Sequel.synchronize{::Sequel::DATABASES.push(self)}
       end
       Sequel::Database.run_after_initialize(self)
-      @pool.send(:preconnect) if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
+      if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
+        concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
+        @pool.send(:preconnect, concurrent)
+      end
     end
 
     # If a transaction is not currently in process, yield to the block immediately.

data/lib/sequel/dataset.rb

@@ -36,6 +36,10 @@ module Sequel
     include SQL::NumericMethods
     include SQL::OrderMethods
     include SQL::StringMethods
+
+    private
+
+    attr_writer :columns
   end
   
   require(%w"query actions features graph prepared_statements misc mutation sql placeholder_literalizer", 'dataset')

data/lib/sequel/dataset/actions.rb

@@ -81,7 +81,7 @@ module Sequel
     #   DB[:table].columns!
     #   # => [:id, :name]
     def columns!
-      @columns = nil
+      self.columns = nil
       columns
     end
     
@@ -558,7 +558,9 @@ module Sequel
     end
     
     # Returns a hash with key_column values as keys and value_column values as
-    # values.  Similar to to_hash, but only selects the columns given.
+    # values.  Similar to to_hash, but only selects the columns given.  Like
+    # to_hash, it accepts an optional :hash parameter, into which entries will
+    # be merged. 
     #
     #   DB[:table].select_hash(:id, :name) # SELECT id, name FROM table
     #   # => {1=>'a', 2=>'b', ...}
@@ -572,12 +574,13 @@ module Sequel
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.  Usually you can do this by calling the #as method
     # on the expression and providing an alias.
-    def select_hash(key_column, value_column)
-      _select_hash(:to_hash, key_column, value_column)
+    def select_hash(key_column, value_column, opts = OPTS)
+      _select_hash(:to_hash, key_column, value_column, opts)
     end
     
     # Returns a hash with key_column values as keys and an array of value_column values.
-    # Similar to to_hash_groups, but only selects the columns given.
+    # Similar to to_hash_groups, but only selects the columns given.  Like to_hash_groups,
+    # it accepts an optional :hash parameter, into which entries will be merged. 
     #
     #   DB[:table].select_hash_groups(:name, :id) # SELECT id, name FROM table
     #   # => {'a'=>[1, 4, ...], 'b'=>[2, ...], ...}
@@ -591,8 +594,8 @@ module Sequel
     # When using this method, you must be sure that each expression has an alias
     # that Sequel can determine.  Usually you can do this by calling the #as method
     # on the expression and providing an alias.
-    def select_hash_groups(key_column, value_column)
-      _select_hash(:to_hash_groups, key_column, value_column)
+    def select_hash_groups(key_column, value_column, opts = OPTS)
+      _select_hash(:to_hash_groups, key_column, value_column, opts)
     end
 
     # Selects the column given (either as an argument or as a block), and
@@ -715,10 +718,15 @@ module Sequel
     #
     #   DB[:table].to_hash([:id, :name]) # SELECT * FROM table
     #   # {[1, 'Jim']=>{:id=>1, :name=>'Jim'}, [2, 'Bob'=>{:id=>2, :name=>'Bob'}, ...}
-    def to_hash(key_column, value_column = nil)
-      h = {}
+    #
+    # This method accepts an optional :hash parameter (which can be a hash with
+    # a default value, a hash with a default proc, or any object that supports
+    # #[] and #[]=) into which entries will be merged. The default behavior is
+    # to start with a new, empty hash.
+    def to_hash(key_column, value_column = nil, opts = OPTS)
+      h = opts[:hash] || {}
       if value_column
-        return naked.to_hash(key_column, value_column) if row_proc
+        return naked.to_hash(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
             each{|r| h[r.values_at(*key_column)] = r.values_at(*value_column)}
@@ -758,10 +766,15 @@ module Sequel
     #
     #   DB[:table].to_hash_groups([:first, :middle]) # SELECT * FROM table
     #   # {['Jim', 'Bob']=>[{:id=>1, :first=>'Jim', :middle=>'Bob', :last=>'Smith'}, ...], ...}
-    def to_hash_groups(key_column, value_column = nil)
-      h = {}
+    #
+    # This method accepts an optional :hash parameter (which can be a hash with
+    # a default value, a hash with a default proc, or any object that supports
+    # #[] and #[]=) into which entries will be merged. The default behavior is
+    # to start with a new, empty hash.
+    def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+      h = opts[:hash] || {}
       if value_column
-        return naked.to_hash_groups(key_column, value_column) if row_proc
+        return naked.to_hash_groups(key_column, value_column, opts) if row_proc
         if value_column.is_a?(Array)
           if key_column.is_a?(Array)
             each{|r| (h[r.values_at(*key_column)] ||= []) << r.values_at(*value_column)}
@@ -896,9 +909,9 @@ module Sequel
     end
     
     # Internals of +select_hash+ and +select_hash_groups+
-    def _select_hash(meth, key_column, value_column)
+    def _select_hash(meth, key_column, value_column, opts=OPTS)
       select(*(key_column.is_a?(Array) ? key_column : [key_column]) + (value_column.is_a?(Array) ? value_column : [value_column])).
-        send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column))
+        send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column), opts)
     end
     
     # Internals of +select_map+ and +select_order_map+

data/lib/sequel/extensions/columns_introspection.rb

@@ -30,7 +30,7 @@ module Sequel
     def columns
       return @columns if @columns
       if (pcs = probable_columns) && pcs.all?
-        @columns = pcs
+        self.columns = pcs
       else
         super
       end

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -0,0 +1,87 @@
+# frozen-string-literal: true
+#
+# The duplicate_columns_handler extension allows you to customize handling of
+# duplicate column names in your queries on a per-database or per-dataset level.
+#
+# For example, you may want to raise an exception if you join 2 tables together
+# which contains a column that will override another columns.
+#
+# To use the extension, you need to load the extension into the database:
+#
+#   DB.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 }
+#
+# 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 })
+#
+# If :raise is specified, a Sequel::DuplicateColumnError is raised.
+# 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.
+#
+# Related module: Sequel::DuplicateColumnsHandler
+
+module Sequel
+  module DuplicateColumnsHandler
+    # 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
+      clone(:on_duplicate_columns=>handler||block)
+    end
+
+    # Override the attr_writer to check for duplicate columns, and call
+    # handle_duplicate_columns if necessary.
+    def columns=(cols)
+      if cols && cols.uniq.size != cols.size
+        handle_duplicate_columns(cols)
+      end
+      @columns = cols
+    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}"
+
+      case duplicate_columns_handler_type(cols)
+      when :raise
+        raise DuplicateColumnError, message
+      when :warn
+        warn message
+      end
+    end
+
+    # Try to find dataset option for on_duplicate_columns. If not present on the dataset,
+    # use the on_duplicate_columns option on the database. If not present on the database,
+    # default to :warn.
+    def duplicate_columns_handler_type(cols)
+      handler = opts.fetch(:on_duplicate_columns){db.opts.fetch(:on_duplicate_columns, :warn)}
+
+      if handler.respond_to?(:call)
+        handler.call(cols)
+      else
+        handler
+      end
+    end
+  end
+
+  # Error which is raised when duplicate columns are present in a dataset which is configured
+  # to :raise on_duplicate_columns.
+  class DuplicateColumnError < Error
+  end
+
+  Dataset.register_extension(:duplicate_columns_handler, Sequel::DuplicateColumnsHandler)
+end

data/lib/sequel/extensions/migration.rb

@@ -618,13 +618,15 @@ module Sequel
     # so that each number in the array is the migration version
     # that will be in affect after the migration is run.
     def version_numbers
-      versions = files.
-        compact.
-        map{|f| migration_version_from_file(File.basename(f))}.
-        select{|v| up? ? (v > current && v <= target) : (v <= current && v > target)}.
-        sort
-      versions.reverse! unless up?
-      versions
+      @version_numbers ||= begin
+        versions = files.
+          compact.
+          map{|f| migration_version_from_file(File.basename(f))}.
+          select{|v| up? ? (v > current && v <= target) : (v <= current && v > target)}.
+          sort
+        versions.reverse! unless up?
+        versions
+      end
     end
   end
 

data/lib/sequel/extensions/pg_range.rb

@@ -50,6 +50,34 @@
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using range type columns in CREATE/ALTER TABLE statements.
 #
+# This extension makes it easy to add support for other range types.  In
+# general, you just need to make sure that the subtype is handled and has the
+# appropriate converter installed in Sequel::Postgres::PG_TYPES or the Database
+# instance's conversion_procs usingthe appropriate type OID.  For user defined
+# types, you can do this via:
+#
+#   DB.conversion_procs[subtype_oid] = lambda{|string| }
+#
+# Then you can call
+# Sequel::Postgres::PGRange::DatabaseMethods#register_range_type
+# to automatically set up a handler for the range type.  So if you
+# want to support the timerange type (assuming the time type is already
+# supported):
+#
+#   DB.register_range_type('timerange')
+#
+# You can also register range types on a global basis using
+# Sequel::Postgres::PGRange.register.  In this case, you'll have
+# to specify the type oids:
+#
+#   Sequel::Postgres::PG_TYPES[1234] = lambda{|string| }
+#   Sequel::Postgres::PGRange.register('foo', :oid=>4321, :subtype_oid=>1234)
+#
+# Both Sequel::Postgres::PGRange::DatabaseMethods#register_range_type
+# and Sequel::Postgres::PGRange.register support many options to
+# customize the range type handling.  See the Sequel::Postgres::PGRange.register
+# method documentation.
+#
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of range types, load the pg_array extension before the
 # pg_range extension:
@@ -94,11 +122,21 @@ module Sequel
       # :subtype_oid :: Should be the PostgreSQL OID for the range's subtype. If given,
       #                 automatically sets the :converter option by looking for scalar conversion
       #                 proc.
+      # :type_procs :: A hash mapping oids to conversion procs, used for setting the default :converter
+      #                for :subtype_oid.  Defaults to the global Sequel::Postgres::PG_TYPES.
+      # :typecast_method_map :: The map in which to place the database type string to type symbol mapping.
+      #                         Defaults to RANGE_TYPES.
+      # :typecast_methods_module :: If given, a module object to add the typecasting method to.  Defaults
+      #                             to DatabaseMethods.
       #
       # If a block is given, it is treated as the :converter option.
       def self.register(db_type, opts=OPTS, &block)
         db_type = db_type.to_s.dup.freeze
 
+        type_procs = opts[:type_procs] || PG_TYPES
+        mod = opts[:typecast_methods_module] || DatabaseMethods
+        typecast_method_map = opts[:typecast_method_map] || RANGE_TYPES
+
         if converter = opts[:converter]
           raise Error, "can't provide both a block and :converter option to register" if block
         else
@@ -106,23 +144,34 @@ module Sequel
         end
 
         if soid = opts[:subtype_oid]
-          raise Error, "can't provide both a converter and :scalar_oid option to register" if converter 
-          raise Error, "no conversion proc for :scalar_oid=>#{soid.inspect} in PG_TYPES" unless converter = PG_TYPES[soid]
+          raise Error, "can't provide both a converter and :subtype_oid option to register" if converter 
+          raise Error, "no conversion proc for :subtype_oid=>#{soid.inspect} in PG_TYPES" unless converter = type_procs[soid]
         end
 
         parser = Parser.new(db_type, converter)
 
-        RANGE_TYPES[db_type] = db_type.to_sym
+        typecast_method_map[db_type] = db_type.to_sym
 
-        DatabaseMethods.define_range_typecast_method(db_type, parser)
+        define_range_typecast_method(mod, db_type, parser)
 
         if oid = opts[:oid]
-          Sequel::Postgres::PG_TYPES[oid] = parser
+          type_procs[oid] = parser
         end
 
         nil
       end
 
+      # Define a private range typecasting method for the given type that uses
+      # the parser argument to do the type conversion.
+      def self.define_range_typecast_method(mod, type, parser)
+        mod.class_eval do
+          meth = :"typecast_value_#{type}"
+          define_method(meth){|v| typecast_value_pg_range(v, parser)}
+          private meth
+        end
+      end
+      private_class_method :define_range_typecast_method
+
       # Creates callable objects that convert strings into PGRange instances.
       class Parser
         # Regexp that parses the full range of PostgreSQL range type output,
@@ -190,6 +239,7 @@ module Sequel
         # and extend the datasets to correctly literalize ruby Range values.
         def self.extended(db)
           db.instance_eval do
+            @pg_range_schema_types ||= {}
             extend_datasets(DatasetMethods)
             copy_conversion_procs([3904, 3906, 3912, 3926, 3905, 3907, 3913, 3927])
             [:int4range, :numrange, :tsrange, :tstzrange, :daterange, :int8range].each do |v|
@@ -207,14 +257,6 @@ module Sequel
 
         end
 
-        # Define a private range typecasting method for the given type that uses
-        # the parser argument to do the type conversion.
-        def self.define_range_typecast_method(type, parser)
-          meth = :"typecast_value_#{type}"
-          define_method(meth){|v| typecast_value_pg_range(v, parser)}
-          private meth
-        end
-
         # Handle Range and PGRange values in bound variables
         def bound_variable_arg(arg, conn)
           case arg
@@ -227,6 +269,23 @@ module Sequel
           end
         end
 
+        # Register a database specific range type.  This can be used to support
+        # different range types per Database.  Use of this method does not
+        # affect global state, unlike PGRange.register.  See PGRange.register for
+        # possible options.
+        def register_range_type(db_type, opts=OPTS, &block)
+          opts = {:type_procs=>conversion_procs, :typecast_method_map=>@pg_range_schema_types, :typecast_methods_module=>(class << self; self; end)}.merge!(opts)
+          unless (opts.has_key?(:subtype_oid) || block) && opts.has_key?(:oid)
+            range_oid, subtype_oid = from(:pg_range).join(:pg_type, :oid=>:rngtypid).where(:typname=>db_type.to_s).get([:rngtypid, :rngsubtype])
+            opts[:subtype_oid] = subtype_oid unless opts.has_key?(:subtype_oid) || block
+            opts[:oid] = range_oid unless opts.has_key?(:oid)
+          end
+
+          PGRange.register(db_type, opts, &block)
+          @schema_type_classes[:"#{opts[:type_symbol] || db_type}"] = PGRange
+          conversion_procs_updated
+        end
+
         private
 
         # Handle arrays of range types in bound variables.
@@ -257,7 +316,7 @@ module Sequel
 
         # Recognize the registered database range types.
         def schema_column_type(db_type)
-          if type = RANGE_TYPES[db_type]
+          if type = @pg_range_schema_types[db_type] || RANGE_TYPES[db_type]
             type
           else
             super

data/lib/sequel/model/base.rb

@@ -2367,12 +2367,12 @@ module Sequel
       #   # => {1=>#<Artist {:id=>1, ...}>,
       #   #     2=>#<Artist {:id=>2, ...}>,
       #   #     ...}
-      def to_hash(key_column=nil, value_column=nil)
+      def to_hash(key_column=nil, value_column=nil, opts=OPTS)
         if key_column
           super
         else
           raise(Sequel::Error, "No primary key for model") unless model && (pk = model.primary_key)
-          super(pk, value_column) 
+          super(pk, value_column, opts) 
         end
       end
 

data/lib/sequel/plugins/dataset_associations.rb

@@ -39,6 +39,14 @@ module Sequel
     #   #       WHERE ((id >= 1) AND (id <= 100)))
     #   #     AND
     #   #     (name < 'M')))))
+    #
+    # For associations that do JOINs, such as many_to_many, note that the datasets returned
+    # by a dataset association method do not do a JOIN by default (they use a subquery that
+    # JOINs).  This can cause problems when you are doing a select, order, or filter on a
+    # column in the joined table.  In that case, you should use the +:dataset_associations_join+
+    # option in the association, which will make sure the datasets returned by the dataset
+    # association methods also use JOINs, allowing such dataset association methods to work
+    # correctly.
     # 
     # Usage:
     #
@@ -101,7 +109,19 @@ module Sequel
           else
             raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
           end
-          r.apply_eager_dataset_changes(ds).unlimited
+
+          ds = r.apply_eager_dataset_changes(ds).unlimited
+
+          if r[:dataset_associations_join]
+            case r[:type]
+            when :many_to_many, :one_through_one
+              ds = ds.join(r[:join_table], r[:right_keys].zip(r.right_primary_keys))
+            when :many_through_many, :one_through_many
+              (r.reverse_edges + [r.final_reverse_edge]).each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:left]).zip(Array(e[:right])) + Array(e[:conditions]))), :table_alias=>ds.unused_table_alias(e[:table]), :qualify=>:deep, &e[:block])}
+            end
+          end
+
+          ds
         end
       end
     end