sequel 5.16.0 → 5.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50240675066a0bd3e480a52ba3ff556b962ae3d8403fb22ee210272f2fffb023
-  data.tar.gz: d1c86ff37811732211b00b251c49bf7c4929ca7b18bf7c6ffeda1b8d0335482f
+  metadata.gz: 6ba219a366f7927beb723a4440c7d497d62b9a2d3b066c44ea5368253a668698
+  data.tar.gz: 570fde96f4cce21da26853210b29eef64e1c6adbf911d085faf5ebf907b0f013
 SHA512:
-  metadata.gz: 6a5a5b35a91ff83c6a0dab3e5cb88e26d79dced018f46fa78ad8be2b4da37c602adba56f849c0591c12f976006ea6e511bb3153478e70f3824ac940772f14de6
-  data.tar.gz: 50f5217691ec39036999623ce8d791fc93c270876d857e30b53892def7d36e0f3c99a3c69b13f97162f45b49dd066f1a5fcbf8b9660f96a1cd5c0c5a23c9ee72
+  metadata.gz: dd6070cf9080a359fd506a5ea8a9d1aaedb2a293c0ed4a123795a55a76e3e9b6ae9720da2f03ec5d1f904258a6fb12c462a2bd661a8ff79c5d0fbd27488664cd
+  data.tar.gz: 402bade89fccfe94c5f29a9a7767fe7cca1bd0549e37fe8591268507b8025365b2ff7af7ef36dfa6a281607d44f4d6fb683dbff801d55003c546981bca1b932d

data/CHANGELOG

@@ -1,3 +1,13 @@
+=== 5.17.0 (2019-02-01)
+
+* Support skip_auto_validations instance method in auto_validations plugin (oldgreen, jeremyevans) (#1592)
+
+* Support :preconnect_extensions Database option for loading extensions before :preconnect option (jeremyevans)
+
+* Avoid usage of Proc.new with implicit block as ruby 2.7+ deprecates this behavior (jeremyevans)
+
+* Allow Sequel[].as to be used for constructing aliases with eager_graph (e.g. Model.eager_graph(Sequel[:a].as(:b))) (jeremyevans) (#1588)
+
 === 5.16.0 (2019-01-02)
 
 * Convert integer columns to bigint columns when copying SQLite databases to other databases using bin/sequel -C (jeremyevans) (#1584)

data/doc/opening_databases.rdoc

@@ -75,14 +75,23 @@ These options are shared by all adapters unless otherwise noted.
 
 :adapter :: The adapter to use
 :database :: The name of the database to which to connect
+:extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
+               or string with extensions separated by columns.  These extensions are loaded after
+               connections are made by the :preconnect option.
 :cache_schema :: Whether schema should be cached for this database (true by default)
 :default_string_column_size :: The default size for string columns (255 by default)
 :host :: The hostname of the database server to which to connect
 :keep_reference :: Whether to keep a reference to the database in Sequel::DATABASES (true by default)
+:logger :: A specific SQL logger to log to
 :loggers :: An array of SQL loggers to log to
 :log_connection_info :: Whether to include connection information in log messages (false by default)
 :log_warn_duration :: The amount of seconds after which the queries are logged at :warn level
 :password :: The password for the user account
+:preconnect :: Whether to automatically make the maximum number of connections when setting up the pool.
+               Can be set to "concurrently" to connect in parallel.
+:preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
+                          connections are made by the :preconnect option.
+:quote_identifiers :: Whether to quote identifiers.
 :servers :: A hash with symbol keys and hash or proc values, used with primary/replica and sharded database configurations
 :sql_log_level :: The level at which to issue queries to the loggers (:info by default)
 :test :: Whether to test that a valid database connection can be made (true by default)
@@ -95,8 +104,6 @@ The following options can be specified and are passed to the database's internal
                   useful for customizations that you want to apply to all connections (nil by default).
 :max_connections :: The maximum size of the connection pool (4 connections by default on most databases)
 :pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (5 seconds by default)
-:preconnect :: Whether to automatically make the maximum number of connections when setting up the pool.
-               Can be set to "concurrently" to connect in parallel.
 :single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
 
 == Adapter specific connection options

data/doc/release_notes/5.17.0.txt

@@ -0,0 +1,31 @@
+= New Features
+
+* An instance-level skip_auto_validations method has been added to
+  the auto_validations plugin, allowing you to skip all or specific
+  types of auto validations inside the block:
+
+    model_instance.skip_auto_validations(:unique) do
+      puts model_instance.valid?
+    end
+
+* A Database :preconnect_extensions option has been added.  This
+  option is similar to :extensions, but the extensions are loaded
+  before the :preconnect option is processed.  This allows you to
+  use the server_logging extension with the :preconnect option.
+
+* For specifying custom table aliases when using eager_graph and
+  association_join, you can now use:
+
+    Sequel[:association].as(:table_alias)
+
+  in addition to:
+
+    Sequel.as(:association, :table_alias)
+
+= Other Improvements
+
+* The ado/mssql adapter now retrieves the number of deleted or
+  updated rows for a query without issuing a separate query.
+
+* Sequel now avoids the use of Proc.new with an implicit block, as
+  that feature will be deprecated starting in Ruby 2.7.

data/lib/sequel/adapters/ado/access.rb

@@ -111,7 +111,7 @@ module Sequel
               log_connection_yield(sql, conn){conn.Execute(sql)}
               last_insert_sql = "SELECT @@IDENTITY"
               res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)}
-              res.getRows.transpose.each{|r| return r.shift}
+              res.GetRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end
@@ -296,7 +296,7 @@ module Sequel
           execute_open_ado_schema(type, criteria) do |s|
             cols = []
             s.Fields.each{|f| cols << f.Name}
-            s.getRows.transpose.each do |r|
+            s.GetRows.transpose.each do |r|
               row = {}
               cols.each{|c| row[c] = r.shift}
               yield row

data/lib/sequel/adapters/ado/mssql.rb

@@ -7,17 +7,14 @@ module Sequel
     module MSSQL
       module DatabaseMethods
         include Sequel::MSSQL::DatabaseMethods
-        # Issue a separate query to get the rows modified.  ADO appears to
-        # use pass by reference with an integer variable, which is
-        # not supported directly in ruby, and I'm not aware of a workaround.
+
         def execute_dui(sql, opts=OPTS)
           return super unless @opts[:provider]
           synchronize(opts[:server]) do |conn|
             begin
-              log_connection_yield(sql, conn){conn.Execute(sql)}
-              rows_affected_sql = "SELECT @@ROWCOUNT AS AffectedRows"
-              res = log_connection_yield(rows_affected_sql, conn){conn.Execute(rows_affected_sql)}
-              res.getRows.transpose.each{|r| return r.shift}
+              sql = "SET NOCOUNT ON; #{sql}; SELECT @@ROWCOUNT"
+              rst = log_connection_yield(sql, conn){conn.Execute(sql)}
+              rst.GetRows[0][0]
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
             end

data/lib/sequel/adapters/shared/postgres.rb

@@ -195,8 +195,8 @@ module Sequel
 
       # Set a conversion proc for the given oid.  The callable can
       # be passed either as a argument or a block.
-      def add_conversion_proc(oid, callable=Proc.new)
-        conversion_procs[oid] = callable
+      def add_conversion_proc(oid, callable=nil, &block)
+        conversion_procs[oid] = callable || block
       end
 
       # Add a conversion proc for a named type, using the given block.

data/lib/sequel/database/misc.rb

@@ -27,7 +27,7 @@ module Sequel
       :blob=>Sequel::SQL::Blob}.freeze
 
     # Nested hook Proc; each new hook Proc just wraps the previous one.
-    @initialize_hook = Proc.new {|db| }
+    @initialize_hook = proc{|db| }
 
     # Register a hook that will be run when a new Database is instantiated. It is
     # called with the new database handle.
@@ -35,7 +35,7 @@ module Sequel
       raise Error, "must provide block to after_initialize" unless block
       Sequel.synchronize do
         previous = @initialize_hook
-        @initialize_hook = Proc.new do |db|
+        @initialize_hook = proc do |db|
           previous.call(db)
           block.call(db)
         end
@@ -97,14 +97,19 @@ module Sequel
     # Accepts the following options:
     # :cache_schema :: Whether schema should be cached for this Database instance
     # :default_string_column_size :: The default size of string columns, 255 by default.
+    # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
+    #                or string with extensions separated by columns.  These extensions are loaded after
+    #                connections are made by the :preconnect option.
     # :keep_reference :: Whether to keep a reference to this instance in Sequel::DATABASES, true by default.
     # :logger :: A specific logger to use.
     # :loggers :: An array of loggers to use.
     # :log_connection_info :: Whether connection information should be logged when logging queries.
     # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
-    # :name :: A name to use for the Database object.
-    # :preconnect :: Whether to automatically connect to the maximum number of servers.  Can use a valid
-    #                of 'concurrently' to preconnect in separate threads.
+    # :name :: A name to use for the Database object, displayed in PoolTimeout .
+    # :preconnect :: Whether to setup the maximum number of connections during initialization.
+    #                Can use a value of 'concurrently' to preconnect in separate threads.
+    # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
+    #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
     # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
     # :single_threaded :: Whether to use a single-threaded connection pool.
@@ -147,23 +152,15 @@ module Sequel
         Sequel.synchronize{::Sequel::DATABASES.push(self)}
       end
       Sequel::Database.run_after_initialize(self)
+
+      initialize_load_extensions(:preconnect_extensions)
+
       if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
         concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
         @pool.send(:preconnect, concurrent)
       end
 
-      case exts = @opts[:extensions]
-      when String
-        extension(*exts.split(',').map(&:to_sym))
-      when Array
-        extension(*exts)
-      when Symbol
-        extension(exts)
-      when nil
-        # nothing
-      else
-        raise Error, "unsupported Database :extensions option: #{@opts[:extensions].inspect}"
-      end
+      initialize_load_extensions(:extensions)
     end
 
     # Freeze internal data structures for the Database instance.
@@ -412,6 +409,22 @@ module Sequel
       opts[:disconnect]
     end
     
+    # Load extensions during initialization from the given key in opts.
+    def initialize_load_extensions(key)
+      case exts = @opts[key]
+      when String
+        extension(*exts.split(',').map(&:to_sym))
+      when Array
+        extension(*exts)
+      when Symbol
+        extension(exts)
+      when nil
+        # nothing
+      else
+        raise Error, "unsupported Database #{key.inspect} option: #{@opts[key].inspect}"
+      end
+    end
+
     # Convert the given exception to an appropriate Sequel::DatabaseError
     # subclass, keeping message and backtrace.
     def raise_error(exception, opts=OPTS)

data/lib/sequel/database/schema_generator.rb

@@ -357,7 +357,8 @@ module Sequel
       end
       
       # Add a column with the given name, type, and opts.
-      # See CreateTableGenerator#column for the available options.
+      # See CreateTableGenerator#column for the available options (except for +:index+, use a
+      # separate +add_index+ call to add an index for the column).
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       #
@@ -399,7 +400,8 @@ module Sequel
       end
 
       # Add a foreign key with the given name and referencing the given table.
-      # See CreateTableGenerator#column for the available options.
+      # See CreateTableGenerator#column for the available options (except for +:index+, use a
+      # separate +add_index+ call to add an index for the column).
       #
       # You can also pass an array of column names for creating composite foreign
       # keys. In this case, it will assume the columns exist and will only add

data/lib/sequel/dataset/actions.rb

@@ -58,7 +58,8 @@ module Sequel
     #   # => 3
     #   DB[:table].avg{function(column)} # SELECT avg(function(column)) FROM table LIMIT 1
     #   # => 1
-    def avg(arg=Sequel.virtual_row(&Proc.new))
+    def avg(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:avg, arg)
     end
   
@@ -450,7 +451,8 @@ module Sequel
     #   # => 10
     #   DB[:table].max{function(column)} # SELECT max(function(column)) FROM table LIMIT 1
     #   # => 7
-    def max(arg=Sequel.virtual_row(&Proc.new))
+    def max(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:max, arg)
     end
 
@@ -461,7 +463,8 @@ module Sequel
     #   # => 1
     #   DB[:table].min{function(column)} # SELECT min(function(column)) FROM table LIMIT 1
     #   # => 0
-    def min(arg=Sequel.virtual_row(&Proc.new))
+    def min(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:min, arg)
     end
 
@@ -733,7 +736,8 @@ module Sequel
     #   # => 55
     #   DB[:table].sum{function(column)} # SELECT sum(function(column)) FROM table LIMIT 1
     #   # => 10
-    def sum(arg=Sequel.virtual_row(&Proc.new))
+    def sum(arg=(no_arg = true), &block)
+      arg = Sequel.virtual_row(&block) if no_arg
       _aggregate(:sum, arg)
     end
 

data/lib/sequel/extensions/sequel_4_dataset_methods.rb

@@ -41,7 +41,8 @@ module Sequel
     #   # => 6
     #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
     #   # => 7
-    def interval(column=Sequel.virtual_row(&Proc.new))
+    def interval(column=(no_arg = true), &block)
+      column = Sequel.virtual_row(&block) if no_arg
       if loader = cached_placeholder_literalizer(:_interval_loader) do |pl|
           arg = pl.arg
           aggregate_dataset.limit(1).select((SQL::Function.new(:max, arg) - SQL::Function.new(:min, arg)).as(:interval))
@@ -60,7 +61,8 @@ module Sequel
     #   # => 1..10
     #   DB[:table].interval{function(column)} # SELECT max(function(column)) AS v1, min(function(column)) AS v2 FROM table LIMIT 1
     #   # => 0..7
-    def range(column=Sequel.virtual_row(&Proc.new))
+    def range(column=(no_arg = true), &block)
+      column = Sequel.virtual_row(&block) if no_arg
       r = if loader = cached_placeholder_literalizer(:_range_loader) do |pl|
             arg = pl.arg
             aggregate_dataset.limit(1).select(SQL::Function.new(:min, arg).as(:v1), SQL::Function.new(:max, arg).as(:v2))

data/lib/sequel/model/associations.rb

@@ -752,8 +752,8 @@ module Sequel
 
         # If +s+ is an array, map +s+ over the block.  Otherwise, just call the
         # block with +s+.
-        def transform(s)
-          s.is_a?(Array) ? s.map(&Proc.new) : (yield s)
+        def transform(s, &block)
+          s.is_a?(Array) ? s.map(&block) : (yield s)
         end
 
         # What eager limit strategy should be used when true is given as the value,
@@ -3273,7 +3273,15 @@ module Sequel
         # per-call determining of the alias base.
         def eager_graph_check_association(model, association)
           if association.is_a?(SQL::AliasedExpression)
-            SQL::AliasedExpression.new(check_association(model, association.expression), association.alias)
+            expr = association.expression
+            if expr.is_a?(SQL::Identifier)
+              expr = expr.value
+              if expr.is_a?(String)
+                expr = expr.to_sym
+              end
+            end
+
+            SQL::AliasedExpression.new(check_association(model, expr), association.alias)
           else
             check_association(model, association)
           end

data/lib/sequel/model/base.rb

@@ -324,14 +324,14 @@ module Sequel
       # Any public methods in the dataset module will have class methods created that
       # call the method on the dataset, assuming that the class method is not already
       # defined.
-      def dataset_module(mod = nil)
+      def dataset_module(mod = nil, &block)
         if mod
-          raise Error, "can't provide both argument and block to Model.dataset_module" if block_given?
+          raise Error, "can't provide both argument and block to Model.dataset_module" if block
           dataset_extend(mod)
           mod
         else
           @dataset_module ||= dataset_module_class.new(self)
-          @dataset_module.module_eval(&Proc.new) if block_given?
+          @dataset_module.module_eval(&block) if block
           dataset_extend(@dataset_module)
           @dataset_module
         end

data/lib/sequel/plugins/auto_validations.rb

@@ -30,6 +30,12 @@ module Sequel
     #
     #   Model.skip_auto_validations(:all)
     #
+    # It is possible to skip auto validations on a per-model-instance basis via:
+    #
+    #   instance.skip_auto_validations(:unique, :not_null) do
+    #     puts instance.valid?
+    #   end
+    #
     # By default, the plugin uses a not_null validation for NOT NULL columns, but that
     # can be changed to a presence validation using an option:
     #
@@ -58,6 +64,7 @@ module Sequel
       MAX_LENGTH_OPTIONS = {:from=>:values, :allow_nil=>true}.freeze
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
+      EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
         model.instance_exec do
@@ -172,38 +179,50 @@ module Sequel
       end
 
       module InstanceMethods
+        # Skip the given types of auto validations on this instance inside the block.
+        def skip_auto_validations(*types)
+          types << :all if types.empty?
+          @_skip_auto_validations = types
+          yield
+        ensure
+          @_skip_auto_validations = nil
+        end
+
         # Validate the model's auto validations columns
         def validate
           super
+          skip = @_skip_auto_validations || EMPTY_ARRAY
+          return if skip.include?(:all)
           opts = model.auto_validate_options
 
-          unless (not_null_columns = model.auto_validate_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:not_null])
-            else
-              validates_not_null(not_null_columns, opts[:not_null])
+
+          unless skip.include?(:not_null)
+            not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null
+            unless (not_null_columns = model.auto_validate_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:not_null])
             end
-          end
-          unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:explicit_not_null])
-            else
-              validates_not_null(not_null_columns, opts[:explicit_not_null])
+            unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:explicit_not_null])
             end
           end
-          unless (max_length_columns = model.auto_validate_max_length_columns).empty?
+
+          unless skip.include?(:max_length) || (max_length_columns = model.auto_validate_max_length_columns).empty?
             max_length_columns.each do |col, len|
               validates_max_length(len, col, opts[:max_length])
             end
           end
 
-          validates_schema_types(keys, opts[:schema_types]) if model.auto_validate_types?
+          unless skip.include?(:types) || !model.auto_validate_types?
+            validates_schema_types(keys, opts[:schema_types])
+          end
 
-          unique_opts = Hash[opts[:unique]]
-          if model.respond_to?(:sti_dataset)
-            unique_opts[:dataset] = model.sti_dataset
+          unless skip.include?(:unique)
+            unique_opts = Hash[opts[:unique]]
+            if model.respond_to?(:sti_dataset)
+              unique_opts[:dataset] = model.sti_dataset
+            end
+            model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
           end
-          model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
         end
       end
     end

data/lib/sequel/sql.rb

@@ -18,7 +18,8 @@ module Sequel
   end
 
   # Time subclass that gets literalized with only the time value, so it operates
-  # like a standard SQL time type.
+  # like a standard SQL time type.  This type does not support timezones, by design,
+  # so it will not work correctly with <tt>time with time zone</tt> types.
   class SQLTime < ::Time
     @date = nil
 

data/lib/sequel/version.rb

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

data/spec/core/database_spec.rb

@@ -2607,7 +2607,7 @@ describe "Database extensions" do
     @db = Sequel.mock
   end
   after do
-    Sequel::Database.instance_variable_set(:@initialize_hook, Proc.new {|db| })
+    Sequel::Database.instance_variable_set(:@initialize_hook, proc{|db| })
   end
 
   it "should be able to register an extension with a module have Database#extension extend the module" do
@@ -2676,6 +2676,29 @@ describe "Database extensions" do
     proc{Sequel.mock(:extensions=>nil).a}.must_raise NoMethodError
     proc{Sequel.mock(:extensions=>Object.new)}.must_raise Sequel::Error
   end
+
+  it "should support :preconnect_extensions Database option to load extensions before :preconnect" do
+    x = []
+    Sequel::Database.register_extension(:a, Module.new{define_singleton_method(:extended){|_| x << :a}})
+    Sequel::Database.register_extension(:b, Module.new{define_singleton_method(:extended){|_| x << :b}})
+    c = Class.new(Sequel::Database) do
+      def dataset_class_default; Sequel::Dataset end
+      define_method(:connect) do |_|
+        x << :c
+        :connect
+      end
+    end
+
+    db = c.new(:max_connections=>2, :preconnect=>true, :preconnect_extensions=>:a, :extensions=>:b)
+    db.pool.size.must_equal db.pool.max_size
+    x.must_equal [:a, :c, :c, :b]
+
+    x.clear
+    db = c.new(:max_connections=>3, :preconnect=>:concurrently, :preconnect_extensions=>:b, :extensions=>:a)
+    x.must_equal [:b, :c, :c, :c, :a]
+    db.pool.size.must_equal db.pool.max_size
+  end
+  
 end
 
 describe "Database specific exception classes" do
@@ -2707,7 +2730,7 @@ end
 
 describe "Database.after_initialize" do
   after do
-    Sequel::Database.instance_variable_set(:@initialize_hook, Proc.new {|db| })
+    Sequel::Database.instance_variable_set(:@initialize_hook, proc{|db| })
   end
 
   it "should allow a block to be run after each new instance is created" do

data/spec/core/dataset_spec.rb

@@ -48,7 +48,7 @@ describe "Dataset#clone" do
   end
   
   it "should create an exact copy of the dataset" do
-    @dataset = @dataset.with_row_proc(Proc.new{|r| r})
+    @dataset = @dataset.with_row_proc(proc{|r| r})
     clone = @dataset.clone
     @dataset.dup.must_be_same_as @dataset
 
@@ -63,7 +63,7 @@ describe "Dataset#clone" do
   end
   
   it "should create an exact copy of the dataset when given an empty hash" do
-    @dataset = @dataset.with_row_proc(Proc.new{|r| r})
+    @dataset = @dataset.with_row_proc(proc{|r| r})
     clone = @dataset.clone({})
 
     clone.object_id.wont_equal @dataset.object_id
@@ -1877,7 +1877,7 @@ end
 
 describe "Dataset#naked" do
   it "should returned clone dataset without row_proc" do
-    d = Sequel.mock.dataset.with_row_proc(Proc.new{|r| r})
+    d = Sequel.mock.dataset.with_row_proc(proc{|r| r})
     d.naked.row_proc.must_be_nil
     d.row_proc.wont_be_nil
   end

data/spec/extensions/auto_validations_spec.rb

@@ -96,6 +96,12 @@ describe "Sequel::Plugins::AutoValidations" do
   it "should allow skipping validations by type" do
     @c = Class.new(@c)
     @m = @c.new
+    @m.skip_auto_validations(:not_null) do
+      @m.valid?.must_equal true
+      @m.nnd = nil
+      @m.valid?.must_equal true
+    end
+    @m.set(:nnd => 'nnd')
     @c.skip_auto_validations(:not_null)
     @m.valid?.must_equal true
     @m.nnd = nil
@@ -105,10 +111,20 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.valid?.must_equal false
     @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
 
+    @m.skip_auto_validations(:types, :unique) do
+      @m.valid?.must_equal true
+    end
+    @m.skip_auto_validations(:types) do
+      @m.valid?.must_equal false
+      @m.errors.must_equal([:name, :num]=>["is already taken"])
+    end
     @c.skip_auto_validations(:types)
     @m.valid?.must_equal false
     @m.errors.must_equal([:name, :num]=>["is already taken"])
 
+    @m.skip_auto_validations(:unique) do
+      @m.valid?.must_equal true
+    end
     @c.skip_auto_validations(:unique)
     @m.valid?.must_equal true
 
@@ -116,6 +132,9 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.valid?.must_equal false
     @m.errors.must_equal(:name=>["is longer than 50 characters"])
 
+    @m.skip_auto_validations(:max_length) do
+      @m.valid?.must_equal true
+    end
     @c.skip_auto_validations(:max_length)
     @m.valid?.must_equal true
   end
@@ -123,6 +142,14 @@ describe "Sequel::Plugins::AutoValidations" do
   it "should allow skipping all auto validations" do
     @c = Class.new(@c)
     @m = @c.new
+    @m.skip_auto_validations(:all) do
+      @m.valid?.must_equal true
+      @m.set(:d=>'/', :num=>'a', :name=>'1')
+      @m.valid?.must_equal true
+      @m.set(:name=>'a'*51)
+      @m.valid?.must_equal true
+    end
+    @m = @c.new
     @c.skip_auto_validations(:all)
     @m.valid?.must_equal true
     @m.set(:d=>'/', :num=>'a', :name=>'1')

data/spec/extensions/migration_spec.rb

@@ -120,7 +120,7 @@ describe "Reversible Migrations with Sequel.migration{change{}}" do
       end
     end
     @db = @c.new
-    @p = Proc.new do
+    @p = proc do
       create_table(:a, :foo=>:bar){Integer :a}
       add_column :a, :b, String
       add_index :a, :b

data/spec/model/associations_spec.rb

@@ -4247,6 +4247,12 @@ describe "Sequel::Model Associations with clashing column names" do
     @Bar.exclude(Sequel::SQL::BooleanExpression.new(:IN, :foo, Sequel.function(:srf))).sql.must_equal 'SELECT * FROM bars WHERE (foo NOT IN srf())'
   end
 
+  it "should have working eager graphing methods when using SQL::Identifier inside SQL::AliasedExpression" do
+    @db.fetch = {:id=>1, :object_id=>2, :f_id=>1, :f_object_id=>2}
+    @Bar.eager_graph(Sequel[:foo].as(:f)).all.map{|o| [o, o.foo]}.must_equal [[@bar, @foo]]
+    @db.sqls.must_equal ["SELECT bars.id, bars.object_id, f.id AS f_id, f.object_id AS f_object_id FROM bars LEFT OUTER JOIN foos AS f ON (f.object_id = bars.object_id)"]
+  end
+
   it "should have working filter by associations with model instances" do
     @Bar.first(:foo=>@foo).must_equal @bar
     @db.sqls.must_equal ["SELECT * FROM bars WHERE (bars.object_id = 2) LIMIT 1"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.16.0
+  version: 5.17.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-02 00:00:00.000000000 Z
+date: 2019-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -200,6 +200,7 @@ extra_rdoc_files:
 - doc/release_notes/5.14.0.txt
 - doc/release_notes/5.15.0.txt
 - doc/release_notes/5.16.0.txt
+- doc/release_notes/5.17.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -286,6 +287,7 @@ files:
 - doc/release_notes/5.14.0.txt
 - doc/release_notes/5.15.0.txt
 - doc/release_notes/5.16.0.txt
+- doc/release_notes/5.17.0.txt
 - doc/release_notes/5.2.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.4.0.txt