sequel 4.35.0 → 4.36.0

data/lib/sequel/model.rb

@@ -3,61 +3,14 @@
 require 'sequel/core'
 
 module Sequel
-  # Lets you create a Model subclass with its dataset already set.
-  # +source+ should be an instance of one of the following classes:
-  #
-  # Database :: Sets the database for this model to +source+.
-  #             Generally only useful when subclassing directly
-  #             from the returned class, where the name of the
-  #             subclass sets the table name (which is combined
-  #             with the +Database+ in +source+ to create the
-  #             dataset to use) 
-  # Dataset :: Sets the dataset for this model to +source+. 
-  # other :: Sets the table name for this model to +source+. The
-  #          class will use the default database for model
-  #          classes in order to create the dataset.
-  #
-  # The purpose of this method is to set the dataset/database automatically
-  # for a model class, if the table name doesn't match the implicit
-  # name.  This is neater than using set_dataset inside the class,
-  # doesn't require a bogus query for the schema.
-  #
-  #   # Using a symbol
-  #   class Comment < Sequel::Model(:something)
-  #     table_name # => :something
-  #   end
-  #
-  #   # Using a dataset
-  #   class Comment < Sequel::Model(DB1[:something])
-  #     dataset # => DB1[:something]
-  #   end
-  #
-  #   # Using a database
-  #   class Comment < Sequel::Model(DB1)
-  #     dataset # => DB1[:comments]
-  #   end
-  def self.Model(source)
-    if cache_anonymous_models && (klass = Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
-      return klass
-    end
-    klass = if source.is_a?(Database)
-      c = Class.new(Model)
-      c.db = source
-      c
-    else
-      Class.new(Model).set_dataset(source)
-    end
-    Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if cache_anonymous_models
-    klass
+  # Delegate to Sequel::Model, only for backwards compatibility.
+  def self.cache_anonymous_models
+    Model.cache_anonymous_models
   end
 
-  @cache_anonymous_models = true
-
-  class << self
-    # Whether to cache the anonymous models created by Sequel::Model().  This is
-    # required for reloading them correctly (avoiding the superclass mismatch).  True
-    # by default for backwards compatibility.
-    attr_accessor :cache_anonymous_models
+  # Delegate to Sequel::Model, only for backwards compatibility.
+  def self.cache_anonymous_models=(v)
+    Model.cache_anonymous_models = v
   end
 
   # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
@@ -78,10 +31,10 @@ module Sequel
 
     # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
     # of classes when dealing with code reloading.
-    ANONYMOUS_MODEL_CLASSES = {}
+    ANONYMOUS_MODEL_CLASSES = @Model_cache = {}
 
     # Mutex protecting access to ANONYMOUS_MODEL_CLASSES
-    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new
+    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 +
@@ -125,7 +78,8 @@ module Sequel
       :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
       :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
       :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup,
-      :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil}
+      :@db=>nil, :@default_set_fields_options=>:dup, :@require_valid_table=>nil,
+      :@cache_anonymous_models=>nil, :@Model_mutex=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to
@@ -137,6 +91,7 @@ module Sequel
     SETTER_METHOD_REGEXP = /=\z/
 
     @allowed_columns = nil
+    @cache_anonymous_models = true
     @db = nil
     @db_schema = nil
     @dataset = nil
@@ -174,5 +129,7 @@ module Sequel
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via +set+/+update+/+new+/etc..
     RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).grep(SETTER_METHOD_REGEXP)
+
+    def_Model(::Sequel)
   end
 end

data/lib/sequel/model/associations.rb

@@ -1486,7 +1486,9 @@ module Sequel
         # :class :: The associated class or its name as a string or symbol. If not
         #           given, uses the association's name, which is camelized (and
         #           singularized unless the type is :many_to_one, :one_to_one, or one_through_one).  If this is specified
-        #           as a string or symbol, you must specify the full class name (e.g. "SomeModule::MyModel"). 
+        #           as a string or symbol, you must specify the full class name (e.g. "::SomeModule::MyModel"). 
+        # :class_namespace :: If :class is given as a string or symbol, sets the default namespace in which to look for
+        #                     the class.  <tt>:class=>'Foo', :class_namespace=>'Bar'</tt> looks for <tt>::Bar::Foo</tt>.)
         # :clearer :: Proc used to define the private _remove_all_* method for doing the database work
         #             to remove all objects associated to the current object (*_to_many assocations).
         # :clone :: Merge the current options and block into the options and block used in defining

data/lib/sequel/model/base.rb

@@ -14,6 +14,11 @@ module Sequel
       # (default: not set, so all columns not otherwise restricted are allowed).
       attr_reader :allowed_columns
 
+      # Whether to cache the anonymous models created by Sequel::Model().  This is
+      # required for reloading them correctly (avoiding the superclass mismatch).  True
+      # by default for backwards compatibility.
+      attr_accessor :cache_anonymous_models
+
       # Array of modules that extend this model's dataset.  Stored
       # so that if the model's dataset is changed, it will be extended
       # with all of these modules.
@@ -48,11 +53,8 @@ module Sequel
       attr_accessor :raise_on_save_failure
   
       # Whether to raise an error when unable to typecast data for a column
-      # (default: true).  This should be set to false if you want to use
-      # validations to display nice error messages to the user (e.g. most
-      # web applications).  You can use the validates_schema_types validation
-      # (from the validation_helpers plugin) in connection with this setting to
-      # check for typecast failures during validation.
+      # (default: false).  This should be set to true if you want to have model
+      # setter methods raise errors if the argument cannot be typecast properly.
       attr_accessor :raise_on_typecast_failure
       
       # Whether to raise an error if an UPDATE or DELETE query related to
@@ -116,6 +118,94 @@ module Sequel
       # If you are sending database queries in before_* or after_* hooks, you shouldn't change
       # the default setting without a good reason.
       attr_accessor :use_transactions
+
+      # Define a Model method on the given module that calls the Model
+      # method on the receiver.  This is how the Sequel::Model() method is
+      # defined, and allows you to define Model() methods on other modules,
+      # making it easier to have custom model settings for all models under
+      # a namespace.  Example:
+      #
+      #   module Foo
+      #     Model = Class.new(Sequel::Model)
+      #     Model.def_Model(self)
+      #     DB = Model.db = Sequel.connect(ENV['FOO_DATABASE_URL'])
+      #     Model.plugin :prepared_statements
+      #
+      #     class Bar < Model
+      #       # Uses Foo::DB[:bars]
+      #     end
+      #
+      #     class Baz < Model(:my_baz)
+      #       # Uses Foo::DB[:my_baz]
+      #     end
+      #   end
+      def def_Model(mod)
+        model = self
+        (class << mod; self; end).send(:define_method, :Model) do |source|
+          model.Model(source)
+        end
+      end
+
+      # Lets you create a Model subclass with its dataset already set.
+      # +source+ should be an instance of one of the following classes:
+      #
+      # Database :: Sets the database for this model to +source+.
+      #             Generally only useful when subclassing directly
+      #             from the returned class, where the name of the
+      #             subclass sets the table name (which is combined
+      #             with the +Database+ in +source+ to create the
+      #             dataset to use) 
+      # Dataset :: Sets the dataset for this model to +source+. 
+      # other :: Sets the table name for this model to +source+. The
+      #          class will use the default database for model
+      #          classes in order to create the dataset.
+      #
+      # The purpose of this method is to set the dataset/database automatically
+      # for a model class, if the table name doesn't match the implicit
+      # name.  This is neater than using set_dataset inside the class,
+      # doesn't require a bogus query for the schema.
+      #
+      # When creating subclasses of Sequel::Model itself, this method is usually
+      # called on Sequel itself, using <tt>Sequel::Model(:something)</tt>.
+      #
+      #   # Using a symbol
+      #   class Comment < Sequel::Model(:something)
+      #     table_name # => :something
+      #   end
+      #
+      #   # Using a dataset
+      #   class Comment < Sequel::Model(DB1[:something])
+      #     dataset # => DB1[:something]
+      #   end
+      #
+      #   # Using a database
+      #   class Comment < Sequel::Model(DB1)
+      #     dataset # => DB1[:comments]
+      #   end
+      def Model(source)
+        if cache_anonymous_models
+          mutex = @Model_mutex
+          cache = mutex.synchronize{@Model_cache ||= {}}
+
+          if klass = mutex.synchronize{cache[source]}
+            return klass
+          end
+        end
+
+        klass = Class.new(self)
+
+        if source.is_a?(::Sequel::Database)
+          klass.db = source
+        else
+          klass.set_dataset(source)
+        end
+
+        if cache_anonymous_models
+          mutex.synchronize{cache[source] = klass}
+        end
+
+        klass
+      end
   
       # Returns the first record from the database matching the conditions.
       # If a hash is given, it is used as the conditions.  If another
@@ -992,11 +1082,18 @@ module Sequel
         case opts[:class]
           when String, Symbol
             # Delete :class to allow late binding
-            opts[:class_name] ||= opts.delete(:class).to_s
+            class_name = opts.delete(:class).to_s
+
+            if (namespace = opts[:class_namespace]) && !class_name.start_with?('::')
+              class_name = "::#{namespace}::#{class_name}"
+            end
+
+            opts[:class_name] ||= class_name
           when Class
             opts[:class_name] ||= opts[:class].name
         end
-        opts[:class_name] ||= ((name || '').split("::")[0..-2] + [camelize(default)]).join('::')
+
+        opts[:class_name] ||= '::' + ((name || '').split("::")[0..-2] + [camelize(default)]).join('::')
       end
   
       # Module that the class includes that holds methods the class adds for column accessors and

data/lib/sequel/plugins/constraint_validations.rb

@@ -33,6 +33,10 @@ module Sequel
       # The default constraint validation metadata table name.
       DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
 
+      # Mapping of operator names in table to ruby operators
+      OPERATOR_MAP = {:str_lt => :<, :str_lte => :<=, :str_gt => :>, :str_gte => :>=,
+                      :int_lt => :<, :int_lte => :<=, :int_gt => :>, :int_gte => :>=}.freeze
+
       # Automatically load the validation_helpers plugin to run the actual validations.
       def self.apply(model, opts=OPTS)
         model.instance_eval do
@@ -154,6 +158,10 @@ module Sequel
           when :includes_int_range
             arg = constraint_validation_int_range(arg)
             type = :includes
+          when *OPERATOR_MAP.keys
+            arg = arg.to_i if type.to_s =~ /\Aint_/
+            operator = OPERATOR_MAP[type]
+            type = :operator
           end
 
           column = if type == :unique
@@ -163,16 +171,22 @@ module Sequel
           end
 
           if type_opts = @constraint_validation_options[type]
-            opts = opts.merge(type_opts)
+            opts.merge!(type_opts)
           end
 
-          reflection_opts = opts
+          reflection_opts = opts.dup
           a = [:"validates_#{type}"]
 
+          if operator
+            a << operator
+            reflection_opts[:operator] = operator
+          end
+
           if arg
             a << arg
-            reflection_opts = reflection_opts.merge(:argument=>arg)
+            reflection_opts[:argument] = arg
           end 
+
           a << column
           unless opts.empty?
             a << opts

data/lib/sequel/plugins/validation_helpers.rb

@@ -159,7 +159,7 @@ module Sequel
         # Check attribute value(s) against a specified value and operation, e.g.
         # validates_operator(:>, 3, :value) validates that value > 3.
         def validates_operator(operator, rhs, atts, opts=OPTS)
-          validatable_attributes_for_type(:operator, atts, opts){|a,v,m| validation_error_message(m, operator, rhs) unless v.send(operator, rhs)}
+          validatable_attributes_for_type(:operator, atts, opts){|a,v,m| validation_error_message(m, operator, rhs) if v.nil? || !v.send(operator, rhs)}
         end
 
         # Validates for all of the model columns (or just the given columns)

data/lib/sequel/sql.rb

@@ -1333,6 +1333,14 @@ module Sequel
         with_opts(:lateral=>true)
       end
 
+      # Return a new function where the function will be ordered.  Only useful for aggregate
+      # functions that are order dependent.
+      #
+      #   Sequel.function(:foo, :a).order(:a, Sequel.desc(:b)) # foo(a ORDER BY a, b DESC)
+      def order(*args)
+        with_opts(:order=>args)
+      end
+
       # Return a new function with an OVER clause (making it a window function).
       #
       #   Sequel.function(:row_number).over(:partition=>:col) # row_number() OVER (PARTITION BY col)

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 35
+  MINOR = 36
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -243,6 +243,10 @@ describe "A PostgreSQL database" do
     @db.values([[1, 2], [3, 4]]).map([:column1, :column2]).must_equal [[1, 2], [3, 4]]
   end
 
+  it "should support ordering in aggregate functions" do
+    @db.from(@db.values([['1'], ['2']]).as(:t, [:a])).get{string_agg(:a, '-').order(Sequel.desc(:a)).as(:c)}.must_equal '2-1'
+  end if DB.server_version >= 90000
+
   it "should support ordering and limiting with #values" do
     @db.values([[1, 2], [3, 4]]).reverse(:column2, :column1).limit(1).map([:column1, :column2]).must_equal [[3, 4]]
     @db.values([[1, 2], [3, 4]]).reverse(:column2, :column1).offset(1).map([:column1, :column2]).must_equal [[1, 2]]

data/spec/core/dataset_spec.rb

@@ -3884,6 +3884,10 @@ describe "Sequel::Dataset#qualify" do
     @ds.select{sum(:a).over(:partition=>:b, :order=>:c)}.qualify.sql.must_equal 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
   end
 
+  it "should handle SQL::Functions with orders" do
+    @ds.select{sum(:a).order(:a)}.qualify.sql.must_equal 'SELECT sum(t.a ORDER BY t.a) FROM t'
+  end
+
   it "should handle SQL::DelayedEvaluation" do
     t = :a
     ds = @ds.filter(Sequel.delay{t}).qualify

data/spec/core/expression_filters_spec.rb

@@ -557,6 +557,10 @@ describe Sequel::SQL::VirtualRow do
     @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.must_equal 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
+  it "should support order method on functions to specify orders for aggregate functions" do
+    @d.l{rank(:c).order(:a, :b)}.must_equal 'rank("c" ORDER BY "a", "b")'
+  end
+
   it "should support over method on functions to create window functions" do
     @d.l{rank{}.over}.must_equal 'rank() OVER ()'
     @d.l{sum(c).over(:partition=>a, :order=>b, :window=>:win, :frame=>:rows)}.must_equal 'sum("c") OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'

data/spec/extensions/connection_expiration_spec.rb

@@ -0,0 +1,121 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+connection_expiration_specs = shared_description do
+  describe "connection expiration" do
+    before do
+      @db.extend(Module.new do
+        def disconnect_connection(conn)
+          @sqls << 'disconnect'
+        end
+      end)
+      @db.extension(:connection_expiration)
+      @db.pool.connection_expiration_timeout = 2
+    end
+
+    it "should still allow new connections" do
+      @db.synchronize{|c| c}.must_be_kind_of(Sequel::Mock::Connection)
+    end
+
+    it "should not override connection_expiration_timeout when loading extension" do
+      @db.extension(:connection_expiration)
+      @db.pool.connection_expiration_timeout.must_equal 2
+    end
+
+    it "should only expire if older than timeout" do
+      c1 = @db.synchronize{|c| c}
+      @db.sqls.must_equal []
+      @db.synchronize{|c| c}.must_be_same_as(c1)
+      @db.sqls.must_equal []
+    end
+
+    it "should disconnect connection if expired" do
+      c1 = @db.synchronize{|c| c}
+      @db.sqls.must_equal []
+      simulate_sleep(c1)
+      c2 = @db.synchronize{|c| c}
+      @db.sqls.must_equal ['disconnect']
+      c2.wont_be_same_as(c1)
+    end
+
+    it "should disconnect only expired connections among multiple" do
+      c1, c2 = multiple_connections
+
+      # Expire c1 only.
+      simulate_sleep(c1)
+      simulate_sleep(c2, 1)
+      c1, c2 = multiple_connections
+
+      c3 = @db.synchronize{|c| c}
+      @db.sqls.must_equal ['disconnect']
+      c3.wont_be_same_as(c1)
+      c3.must_be_same_as(c2)
+    end
+
+    it "should disconnect connections repeatedly if they are expired" do
+      c1, c2 = multiple_connections
+
+      simulate_sleep(c1)
+      simulate_sleep(c2)
+
+      c3 = @db.synchronize{|c| c}
+      @db.sqls.must_equal ['disconnect', 'disconnect']
+      c3.wont_be_same_as(c1)
+      c3.wont_be_same_as(c2)
+    end
+
+    it "should not leak connection references to expiring connections" do
+      c1 = @db.synchronize{|c| c}
+      simulate_sleep(c1)
+      c2 = @db.synchronize{|c| c}
+      c2.wont_be_same_as(c1)
+      @db.pool.instance_variable_get(:@connection_expiration_timestamps).must_include(c2)
+      @db.pool.instance_variable_get(:@connection_expiration_timestamps).wont_include(c1)
+    end
+
+    it "should not leak connection references during disconnect" do
+      c1, c2 = multiple_connections
+      @db.pool.instance_variable_get(:@connection_expiration_timestamps).size.must_equal 2
+      @db.disconnect
+      @db.pool.instance_variable_get(:@connection_expiration_timestamps).size.must_equal 0
+    end
+
+    def multiple_connections
+      q, q1 = Queue.new, Queue.new
+      c1 = nil
+      c2 = nil
+      @db.synchronize do |c|
+        Thread.new do
+          @db.synchronize do |cc|
+            c2 = cc
+          end
+          q1.pop
+          q.push nil
+        end
+        q1.push nil
+        q.pop
+        c1 = c
+      end
+      [c1, c2]
+    end
+
+    # Set the timestamp back in time to simulate sleep / passage of time.
+    def simulate_sleep(conn, sleep_time = 3)
+      timestamps = @db.pool.instance_variable_get(:@connection_expiration_timestamps)
+      timestamps[conn] -= sleep_time
+      @db.pool.instance_variable_set(:@connection_expiration_timestamps, timestamps)
+    end
+  end
+end
+
+describe "Sequel::ConnectionExpiration with threaded pool" do
+  before do
+    @db = Sequel.mock
+  end
+  include connection_expiration_specs
+end
+describe "Sequel::ConnectionExpiration with sharded threaded pool" do
+  before do
+    @db = Sequel.mock(:servers=>{})
+  end
+  include connection_expiration_specs
+end