sequel 3.38.0 → 3.39.0

data/lib/sequel/extensions/eval_inspect.rb

@@ -28,13 +28,14 @@ module Sequel
       when Hash
         "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
       when Time
+        datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
         if RUBY_VERSION < '1.9'
           # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
           hours, mins = obj.utc_offset.divmod(3600)
           mins /= 60
-          "#{obj.class}.parse(#{obj.strftime("%Y-%m-%dT%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
+          "#{obj.class}.parse(#{obj.strftime("#{datepart}%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
         else
-          "#{obj.class}.parse(#{obj.strftime('%FT%T.%N%z').inspect})#{'.utc' if obj.utc?}"
+          "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
         end
       when DateTime
         # Ignore date of calendar reform
@@ -91,6 +92,20 @@ module Sequel
       end
     end
 
+    class Constant
+      # Constants to lookup in the Sequel module.
+      INSPECT_LOOKUPS = [:CURRENT_DATE, :CURRENT_TIMESTAMP, :CURRENT_TIME, :SQLTRUE, :SQLFALSE, :NULL, :NOTNULL]
+
+      # Reference the constant in the Sequel module if there is
+      # one that matches.
+      def inspect
+        INSPECT_LOOKUPS.each do |c|
+          return "Sequel::#{c}" if Sequel.const_get(c) == self
+        end
+        super
+      end
+    end
+
     class CaseExpression
       private
 

data/lib/sequel/extensions/pg_array_ops.rb

@@ -106,14 +106,14 @@ module Sequel
       #
       #   array_op.contains(:a) # (array @> a)
       def contains(other)
-        bool_op(CONTAINS, other)
+        bool_op(CONTAINS, wrap_array(other))
       end
 
       # Use the contained by (<@) operator:
       #
       #   array_op.contained_by(:a) # (array <@ a)
       def contained_by(other)
-        bool_op(CONTAINED_BY, other)
+        bool_op(CONTAINED_BY, wrap_array(other))
       end
 
       # Call the array_dims method:
@@ -143,7 +143,7 @@ module Sequel
       #
       #   array_op.overlaps(:a) # (array && a)
       def overlaps(other)
-        bool_op(OVERLAPS, other)
+        bool_op(OVERLAPS, wrap_array(other))
       end
 
       # Use the concatentation (||) operator:
@@ -151,7 +151,7 @@ module Sequel
       #   array_op.push(:a) # (array || a)
       #   array_op.concat(:a) # (array || a)
       def push(other)
-        array_op(CONCAT, [self, other])
+        array_op(CONCAT, [self, wrap_array(other)])
       end
       alias concat push
 
@@ -182,7 +182,7 @@ module Sequel
       #
       #   array_op.unshift(:a) # (a || array)
       def unshift(other)
-        array_op(CONCAT, [other, self])
+        array_op(CONCAT, [wrap_array(other), self])
       end
 
       private
@@ -204,6 +204,16 @@ module Sequel
       def function(name, *args)
         SQL::Function.new(name, self, *args)
       end
+
+      # Automatically wrap argument in a PGArray if it is a plain Array.
+      # Requires that the pg_array extension has been loaded to work.
+      def wrap_array(arg)
+        if arg.instance_of?(Array)
+          Sequel.pg_array(arg)
+        else
+          arg
+        end
+      end
     end
 
     module ArrayOpMethods

data/lib/sequel/extensions/pg_interval.rb

@@ -5,7 +5,7 @@
 # as instances of ActiveSupport::Duration.
 #
 # In addition to the parser, this extension adds literalizers for
-# ActiveSupport::Duration ithat use the standard Sequel literalization
+# ActiveSupport::Duration that use the standard Sequel literalization
 # callbacks, so they work on all adapters.
 #
 # If you would like to use interval columns in your model objects, you
@@ -122,7 +122,7 @@ module Sequel
         db.extend_datasets(IntervalDatasetMethods)
       end
 
-      # Handle ActiveSupport::Duration values in bound variables
+      # Handle ActiveSupport::Duration values in bound variables.
       def bound_variable_arg(arg, conn)
         case arg
         when ActiveSupport::Duration

data/lib/sequel/extensions/pg_row_ops.rb

@@ -112,6 +112,21 @@ module Sequel
         end
       end
 
+      # Use the (identifier).* syntax to reference the members
+      # of the composite type as separate columns.  Generally
+      # used when you want to expand the columns of a composite
+      # type to be separate columns in the result set.
+      #
+      #   Sequel.pg_row_op(:a).*     # (a).*
+      #   Sequel.pg_row_op(:a)[:b].* # ((a).b).*
+      def *(ce=(arg=false;nil))
+        if arg == false
+          Sequel::SQL::ColumnAll.new([self])
+        else
+          super(ce)
+        end
+      end
+
       # Use the (identifier.*) syntax to indicate that this
       # expression represents the composite type of one
       # of the tables being referenced, if it has the same
@@ -120,6 +135,9 @@ module Sequel
       # (which should be a symbol representing the composite type).
       # This is used if you want to return whole table row as a
       # composite type.
+      #
+      #   Sequel.pg_row_op(:a).splat[:b] # (a.*).b
+      #   Sequel.pg_row_op(:a).splat(:a) # (a.*)::a
       def splat(cast_to=nil)
         if args.length > 1
           raise Error, 'cannot splat a PGRowOp with multiple arguments'

data/lib/sequel/extensions/schema_dumper.rb

@@ -8,6 +8,8 @@
 #
 #   Sequel.extension :schema_dumper
 
+Sequel.extension :eval_inspect
+
 module Sequel
   class Database
     # Dump foreign key constraints for all tables as a migration. This complements
@@ -137,7 +139,6 @@ END_MIG
         else
           gen.column(name, type, col_opts)
           if [Integer, Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
-            Sequel.extension :eval_inspect
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end
@@ -473,16 +474,7 @@ END_MIG
       def opts_inspect(opts)
         if opts[:default]
           opts = opts.dup
-          de = case d = opts.delete(:default)
-          when BigDecimal, Sequel::SQL::Blob
-            "#{d.class.name}.new(#{d.to_s.inspect})"
-          when DateTime, Date
-            "#{d.class.name}.parse(#{d.to_s.inspect})"
-          when Time
-            "#{d.class.name}.parse(#{d.strftime('%H:%M:%S').inspect})"
-          else
-            d.inspect
-          end
+          de = Sequel.eval_inspect(opts.delete(:default)) 
           ", :default=>#{de}#{", #{opts.inspect[1...-1]}" if opts.length > 0}"
         else
           ", #{opts.inspect[1...-1]}" if opts.length > 0

data/lib/sequel/model/associations.rb

@@ -745,9 +745,10 @@ module Sequel
         #                              than one row for each row in the current table (default: 0 for
         #                              many_to_one and one_to_one associations, 1 for one_to_many and
         #                              many_to_many associations).
-        # :class :: The associated class or its name. If not
+        # :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 or :one_to_one)
+        #           singularized unless the type is :many_to_one or :one_to_one).  If this is specified
+        #           as a string or symbol, you must specify the full class name (e.g. "SomeModule::MyModel"). 
         # :clone :: Merge the current options and block into the options and block used in defining
         #           the given association.  Can be used to DRY up a bunch of similar associations that
         #           all share the same options such as :class and :key, while changing the order and block used.

data/lib/sequel/model/base.rb

@@ -557,7 +557,7 @@ module Sequel
       # approach such as set_allowed_columns or the instance level set_only or set_fields methods
       # is usually a better choice.  So use of this method is generally a bad idea.
       #
-      #   Artist.set_restricted_column(:records_sold)
+      #   Artist.set_restricted_columns(:records_sold)
       #   Artist.set(:name=>'Bob', :hometown=>'Sactown') # No Error
       #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
       def set_restricted_columns(*cols)
@@ -1226,7 +1226,7 @@ module Sequel
         set_server(opts[:server]) if opts[:server] 
         if opts[:validate] != false
           unless checked_save_failure(opts){_valid?(true, opts)}
-            raise(ValidationFailed.new(errors)) if raise_on_failure?(opts)
+            raise(ValidationFailed.new(self)) if raise_on_failure?(opts)
             return
           end
         end
@@ -1477,12 +1477,12 @@ module Sequel
         called = false
         around_destroy do
           called = true
-          raise_hook_failure(:destroy) if before_destroy == false
+          raise_hook_failure(:before_destroy) if before_destroy == false
           _destroy_delete
           after_destroy
           true
         end
-        raise_hook_failure(:destroy) unless called
+        raise_hook_failure(:around_destroy) unless called
         db.after_commit(sh){after_destroy_commit} if uacr
         self
       end
@@ -1551,12 +1551,12 @@ module Sequel
         called_cu = false
         around_save do
           called_save = true
-          raise_hook_failure(:save) if before_save == false
+          raise_hook_failure(:before_save) if before_save == false
           if new?
             was_new = true
             around_create do
               called_cu = true
-              raise_hook_failure(:create) if before_create == false
+              raise_hook_failure(:before_create) if before_create == false
               pk = _insert
               @this = nil
               @new = false
@@ -1564,11 +1564,11 @@ module Sequel
               after_create
               true
             end
-            raise_hook_failure(:create) unless called_cu
+            raise_hook_failure(:around_create) unless called_cu
           else
             around_update do
               called_cu = true
-              raise_hook_failure(:update) if before_update == false
+              raise_hook_failure(:before_update) if before_update == false
               if columns.empty?
                 @columns_updated = if opts[:changed]
                   @values.reject{|k,v| !changed_columns.include?(k)}
@@ -1585,12 +1585,12 @@ module Sequel
               after_update
               true
             end
-            raise_hook_failure(:update) unless called_cu
+            raise_hook_failure(:around_update) unless called_cu
           end
           after_save
           true
         end
-        raise_hook_failure(:save) unless called_save
+        raise_hook_failure(:around_save) unless called_save
         if was_new
           @was_new = nil
           pk ? _save_refresh : changed_columns.clear
@@ -1659,7 +1659,7 @@ module Sequel
           called = true
           if before_validation == false
             if raise_errors
-              raise_hook_failure(:validation)
+              raise_hook_failure(:before_validation)
             else
               error = true
             end
@@ -1673,7 +1673,7 @@ module Sequel
         error = true unless called
         if error
           if raise_errors
-            raise_hook_failure(:validation)
+            raise_hook_failure(:around_validation)
           else
             false
           end
@@ -1731,7 +1731,7 @@ module Sequel
       # Raise an error appropriate to the hook type. May be swallowed by
       # checked_save_failure depending on the raise_on_failure? setting.
       def raise_hook_failure(type)
-        raise HookFailed, "one of the before_#{type} hooks returned false"
+        raise HookFailed.new("the #{type} hook failed", self)
       end
   
       # Set the columns, filtered by the only and except arrays.
@@ -1871,6 +1871,50 @@ module Sequel
         model.use_transactions ? @db.transaction(:server=>opts[:server], &pr) : pr.call
       end
 
+      # Allow Sequel::Model classes to be used as dataset arguments when graphing:
+      #
+      #   Artist.graph(Album, :artist_id=>id)
+      #   # SELECT artists.id, artists.name, albums.id AS albums_id, albums.artist_id, albums.name AS albums_name
+      #   # FROM artists LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+      def graph(table, *args, &block)
+        if table.is_a?(Class) && table < Sequel::Model
+          super(table.dataset, *args, &block)
+        else
+          super
+        end
+      end
+
+      # Handle Sequel::Model instances when inserting, using the model instance's
+      # values for the insert, unless the model instance can be used directly in
+      # SQL.
+      #
+      #   Album.insert(Album.load(:name=>'A'))
+      #   # INSERT INTO albums (name) VALUES ('A')
+      def insert_sql(*values)
+        if values.size == 1 && (v = values.at(0)).is_a?(Sequel::Model) && !v.respond_to?(:sql_literal_append)
+          super(v.to_hash)
+        else
+          super
+        end
+      end
+
+      # Allow Sequel::Model classes to be used as table name arguments in dataset
+      # join methods:
+      #
+      #   Artist.join(Album, :artist_id=>id)
+      #   # SELECT * FROM artists INNER JOIN albums ON (albums.artist_id = artists.id)
+      def join_table(type, table, *args, &block)
+        if table.is_a?(Class) && table < Sequel::Model
+          if table.dataset.simple_select_all?
+            super(type, table.table_name, *args, &block)
+          else
+            super(type, table.dataset, *args, &block)
+          end
+        else
+          super
+        end
+      end
+
       # This allows you to call +to_hash+ without any arguments, which will
       # result in a hash with the primary key value being the key and the
       # model object being the value.

data/lib/sequel/model/exceptions.rb

@@ -1,7 +1,15 @@
 module Sequel
   # Exception class raised when +raise_on_save_failure+ is set and a before hook returns false
   # or an around hook doesn't call super or yield.
-  class HookFailed < Error; end
+  class HookFailed < Error
+    # The Sequel::Model instance related to this error.
+    attr_reader :model
+
+    def initialize(message, model=nil)
+      @model = model
+      super(message)
+    end
+  end
 
   # Deprecated alias for HookFailed, kept for backwards compatibility
   BeforeHookFailed = HookFailed
@@ -15,7 +23,18 @@ module Sequel
   
   # Exception class raised when +raise_on_save_failure+ is set and validation fails
   class ValidationFailed < Error
+    # The Sequel::Model object related to this exception.
+    attr_reader :model
+
+    # The Sequel::Model::Errors object related to this exception.
+    attr_reader :errors
+
     def initialize(errors)
+      if errors.is_a?(Sequel::Model)
+        @model = errors
+        errors = @model.errors
+      end
+
       if errors.respond_to?(:full_messages)
         @errors = errors
         super(errors.full_messages.join(', '))
@@ -23,6 +42,5 @@ module Sequel
         super
       end
     end
-    attr_reader :errors
   end
 end

data/lib/sequel/plugins/constraint_validations.rb

@@ -0,0 +1,198 @@
+module Sequel
+  module Plugins
+    # The constraint_validations plugin is designed to be used with databases
+    # that used the constraint_validations extension when creating their
+    # tables.  The extension adds validation metadata for constraints created,
+    # and this plugin reads that metadata and automatically creates validations
+    # for all of the constraints.  For example, if you used the extension
+    # and created your albums table like this:
+    #
+    #   DB.create_table(:albums) do
+    #     primary_key :id
+    #     String :name
+    #     validate do
+    #       min_length 5, :name
+    #     end
+    #   end
+    #
+    # Then when you went to save an album that uses this plugin:
+    #
+    #   Album.create(:name=>'abc')
+    #   # raises Sequel::ValidationFailed: name is shorter than 5 characters
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses use constraint validations (called before loading subclasses)
+    #   Sequel::Model.plugin :constraint_validations
+    #
+    #   # Make the Album class use constraint validations
+    #   Album.plugin :constraint_validations
+    module ConstraintValidations
+      # The default constraint validation metadata table name.
+      DEFAULT_CONSTRAINT_VALIDATIONS_TABLE = :sequel_constraint_validations
+
+      # Automatically load the validation_helpers plugin to run the actual validations.
+      def self.apply(model, opts={})
+        model.plugin :validation_helpers
+      end
+
+      # Parse the constraint validations metadata from the database. Options:
+      # :constraint_validations_table :: Override the name of the constraint validations
+      #                                  metadata table.  Should only be used if the table
+      #                                  name was overridden when creating the constraint
+      #                                  validations.
+      def self.configure(model, opts={})
+        model.instance_variable_set(:@constraint_validations_table, opts[:constraint_validations_table] || DEFAULT_CONSTRAINT_VALIDATIONS_TABLE)
+        model.send(:parse_constraint_validations)
+      end
+
+      module DatabaseMethods
+        # A hash of validation method call metadata for all tables in the database.
+        # The hash is keyed by table name string and contains arrays of validation
+        # method call arrays.
+        attr_accessor :constraint_validations
+      end
+
+      module ClassMethods
+        # An array of validation method call arrays.  Each array is an array that
+        # is splatted to send to perform a validation via validation_helpers.
+        attr_reader :constraint_validations
+
+        # The name of the table containing the constraint validations metadata.
+        attr_reader :constraint_validations_table
+
+        # Copy the name of the constraint validations metadata table into the subclass.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@constraint_validations_table, @constraint_validations_table)
+        end
+
+        # Parse the constraint validations from the database whenever the dataset
+        # changes.
+        def set_dataset(*)
+          r = super
+          parse_constraint_validations
+          r
+        end
+
+        private
+
+        # If the database has not already parsed constraint validation
+        # metadata, then run a query to get the metadata data and transform it
+        # into arrays of validation method calls.
+        #
+        # If this model has associated dataset, use the model's table name
+        # to get the validations for just this model.
+        def parse_constraint_validations
+          db.extend(DatabaseMethods)
+
+          unless hash = Sequel.synchronize{db.constraint_validations}
+            hash = {}
+            db.from(constraint_validations_table).each do |r|
+              (hash[r[:table]] ||= []) << constraint_validation_array(r)
+            end
+            Sequel.synchronize{db.constraint_validations = hash}
+          end
+
+          if @dataset
+            ds = @dataset.clone
+            ds.quote_identifiers = false
+            table_name = ds.literal(model.table_name)
+            @constraint_validations = Sequel.synchronize{hash[table_name]} || []
+          end
+        end
+
+        # Given a specific database constraint validation metadata row hash, transform
+        # it in an validation method call array suitable for splatting to send.
+        def constraint_validation_array(r)
+          opts = {}
+          opts[:message] = r[:message] if r[:message]
+          opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
+          type = r[:validation_type].to_sym
+          arg = r[:argument]
+          column = r[:column]
+
+          case type
+          when :like, :ilike
+            arg = constraint_validation_like_to_regexp(arg, type == :ilike)
+            type = :format
+          when :exact_length, :min_length, :max_length
+            arg = arg.to_i
+          when :length_range
+            arg = constraint_validation_int_range(arg)
+          when :format
+            arg = Regexp.new(arg)
+          when :iformat
+            arg = Regexp.new(arg, Regexp::IGNORECASE)
+            type = :format
+          when :includes_str_array
+            arg = arg.split(',')
+            type = :includes
+          when :includes_int_array
+            arg = arg.split(',').map{|x| x.to_i}
+            type = :includes
+          when :includes_int_range
+            arg = constraint_validation_int_range(arg)
+            type = :includes
+          end
+
+          column = if type == :unique
+            column.split(',').map{|c| c.to_sym}
+          else
+            column.to_sym
+          end
+
+          a = [:"validates_#{type}"]
+          if arg
+            a << arg
+          end 
+          a << column
+          unless opts.empty?
+            a << opts
+          end
+          a
+        end
+
+        # Return a range of integers assuming the argument is in
+        # 1..2 or 1...2 format.
+        def constraint_validation_int_range(arg)
+          arg =~ /(\d+)\.\.(\.)?(\d+)/
+          Range.new($1.to_i, $3.to_i, $2 == '.')
+        end
+
+        # Transform the LIKE pattern string argument into a
+        # Regexp argument suitable for use with validates_format.
+        def constraint_validation_like_to_regexp(arg, case_insensitive)
+          arg = Regexp.escape(arg).gsub(/%%|%|_/) do |s|
+            case s
+            when '%%'
+              '%'
+            when '%'
+              '.*'
+            when '_'
+              '.'
+            end
+          end
+          arg = "\\A#{arg}\\z"
+
+          if case_insensitive
+            Regexp.new(arg, Regexp::IGNORECASE)
+          else
+            Regexp.new(arg)
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Run all of the constraint validations parsed from the database
+        # when validating the instance.
+        def validate
+          super
+          model.constraint_validations.each do |v|
+            send(*v)
+          end
+        end
+      end
+    end
+  end
+end