sequel 3.21.0 → 3.41.0

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

data/lib/sequel/plugins/dataset_associations.rb

@@ -0,0 +1,100 @@
+module Sequel
+  module Plugins
+    # DatasetAssociations allows you to easily use your model associations
+    # via datasets.  For each association you define, it creates a dataset
+    # method for that association that returns a dataset of all objects
+    # that are associated to objects in the current dataset.  Here's a simple
+    # example:
+    #
+    #   class Artist < Sequel::Model
+    #     plugin :dataset_associations
+    #     one_to_many :albums
+    #   end
+    #   Artist.filter(id=>1..100).albums
+    #   # SELECT * FROM albums
+    #   # WHERE (albums.artist_id IN (
+    #   #   SELECT id FROM artists
+    #   #   WHERE ((id >= 1) AND (id <= 100))))
+    # 
+    # This works for all of the association types that ship with Sequel,
+    # including the many_through_many type.  Most association options that
+    # are supported when eager loading are supported when using a
+    # dataset association.  However, associations that use :limit or
+    # one_to_one associations that are really one_to_many relationships
+    # in the database will not work correctly, returning all associated
+    # objects.
+    #
+    # As the dataset methods return datasets, you can easily chain the
+    # methods to get associated datasets of associated datasets:
+    #
+    #   Artist.filter(id=>1..100).albums.filter{name < 'M'}.tags
+    #   # SELECT tags.* FROM tags
+    #   # WHERE (tags.id IN (
+    #   #   SELECT albums_tags.tag_id FROM albums
+    #   #   INNER JOIN albums_tags
+    #   #     ON (albums_tags.album_id = albums.id)
+    #   #   WHERE
+    #   #     ((albums.artist_id IN (
+    #   #       SELECT id FROM artists
+    #   #       WHERE ((id >= 1) AND (id <= 100)))
+    #   #     AND
+    #   #     (name < 'M')))))
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses create association methods for datasets
+    #   Sequel::Model.plugin :dataset_associations
+    #
+    #   # Make the Album class create association methods for datasets
+    #   Album.plugin :dataset_associations
+    module DatasetAssociations
+      module ClassMethods
+        # Set up a dataset method for each association to return an associated dataset
+        def associate(type, name, *)
+          ret = super
+          r = association_reflection(name)
+          meth = r.returns_array? ? name : pluralize(name).to_sym
+          def_dataset_method(meth){associated(name)}
+          ret
+        end
+      end
+
+      module DatasetMethods
+        # For the association given by +name+, return a dataset of associated objects
+        # such that it would return the union of calling the association method on
+        # all objects returned by the current dataset.
+        #
+        # This supports most options that are supported when eager loading.  It doesn't
+        # support limits on the associations, or one_to_one associations that are really
+        # one_to_many and use an order to select the first matching object.  In both of
+        # those cases, this will return an array of all matching objects.
+        def associated(name)
+          raise Error, "unrecognized association name: #{name.inspect}" unless r = model.association_reflection(name)
+          ds = r.associated_class.dataset
+          sds = opts[:limit] ? self : unordered
+          ds = case r[:type]
+          when :many_to_one
+            ds.filter(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
+          when :one_to_one, :one_to_many
+            ds.filter(r.qualified_key=>sds.select(*Array(r.qualified_primary_key)))
+          when :many_to_many
+            ds.filter(r.qualified_right_primary_key=>sds.select(*Array(r.qualified_right_key)).
+              join(r[:join_table], r[:left_keys].zip(r[:left_primary_keys]), :implicit_qualifier=>model.table_name))
+          when :many_through_many
+            fre = r.reverse_edges.first
+            fe, *edges = r.edges
+            sds = sds.select(*Array(r.qualify(fre[:table], fre[:left]))).
+              join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name)
+            edges.each{|e| sds = sds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
+            ds.filter(r.qualified_right_primary_key=>sds)
+          else
+            raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
+          end
+          ds = model.apply_association_dataset_opts(r, ds)
+          r[:extend].each{|m| ds.extend(m)}
+          ds
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/defaults_setter.rb

@@ -0,0 +1,72 @@
+module Sequel
+  module Plugins
+    # DefaultsSetter is a simple plugin that sets non-nil/NULL default values upon
+    # initialize:
+    #
+    #   # column a default NULL
+    #   # column b default 2
+    #   album = Album.new.values # {:b => 2}
+    #   album = Album.new(:a=>1, :b=>3).values # {:a => 1, :b => 3}
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances set defaults (called before loading subclasses)
+    #   Sequel::Model.plugin :defaults_setter
+    #
+    #   # Make the Album class set defaults 
+    #   Album.plugin :defaults_setter
+    module DefaultsSetter
+      # Set the default values based on the model schema
+      def self.configure(model)
+        model.send(:set_default_values)
+      end
+
+      module ClassMethods
+        # The default values to set in initialize for this model.  A hash with column symbol
+        # keys and default values.  If the default values respond to +call+, it will be called
+        # to get the value, otherwise the value will be used directly.  You can manually modify
+        # this hash to set specific default values, by default the ones will be parsed from the database.
+        attr_reader :default_values
+        
+        # Set the default values when loading the dataset.
+        def set_dataset(*)
+          x = super
+          set_default_values
+          x
+        end
+
+        private
+
+        # Parse the cached database schema for this model and set the default values appropriately.
+        def set_default_values
+          h = {}
+          @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
+          @default_values = h
+        end
+
+        # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or
+        # Time/DateTime value.
+        def convert_default_value(v)
+          case v
+          when Sequel::CURRENT_DATE
+            lambda{Date.today}
+          when Sequel::CURRENT_TIMESTAMP
+            lambda{Sequel.datetime_class.now}
+          else
+            v
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Set default values if they are not already set by the hash provided to initialize.
+        def initialize_set(h)
+          super
+          model.default_values.each{|k,v| self[k] = (v.respond_to?(:call) ? v.call : v) unless values.has_key?(k)}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/dirty.rb

@@ -0,0 +1,214 @@
+module Sequel
+  module Plugins
+    # The dirty plugin makes Sequel save the initial value of
+    # a column when setting a new value for the column.  This
+    # makes it easier to see what changes were made to the object:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.initial_value(:name)   # 'Foo'
+    #   artist.column_change(:name)   # ['Foo', 'Bar']
+    #   artist.column_changes         # {:name => ['Foo', 'Bar']}
+    #   artist.column_changed?(:name) # true
+    #   artist.reset_column(:name)
+    #   artist.name                   # => 'Foo'
+    #   artist.column_changed?(:name) # false
+    #
+    # It also makes changed_columns more accurate in that it
+    # can detect when a the column value is changed and then
+    # changed back:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.changed_columns        # => [:name]
+    #   artist.name = 'Foo'
+    #   artist.changed_columns        # => []
+    #
+    # It can handle situations where a column value is
+    # modified in place:
+    #
+    #   artist.will_change_column(:name)
+    #   artist.name.gsub!(/o/, 'u')
+    #   artist.changed_columns       # => [:name]
+    #   artist.initial_value(:name)  # => 'Foo'
+    #   artist.column_change(:name)  # => ['Foo', 'Fuu']
+    #
+    # It also saves the previously changed values after an update:
+    #
+    #   artist.update(:name=>'Bar')
+    #   artist.column_changes        # => {}
+    #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances record previous values (called before loading subclasses)
+    #   Sequel::Model.plugin :dirty
+    #
+    #   # Make the Album class record previous values
+    #   Album.plugin :dirty
+    module Dirty
+      module InstanceMethods
+        # A hash of previous changes before the object was
+        # saved, in the same format as #column_changes.
+        # Note that this is not necessarily the same as the columns
+        # that were used in the update statement.
+        attr_reader :previous_changes
+
+        # An array with the initial value and the current value
+        # of the column, if the column has been changed.  If the
+        # column has not been changed, returns nil.
+        #
+        #   column_change(:name) # => ['Initial', 'Current']
+        def column_change(column)
+          [initial_value(column), send(column)] if column_changed?(column)
+        end
+
+        # A hash with column symbol keys and pairs of initial and
+        # current values for all changed columns.
+        #
+        #   column_changes # => {:name => ['Initial', 'Current']}
+        def column_changes
+          h = {}
+          initial_values.each do |column, value|
+            h[column] = [value, send(column)]
+          end
+          h
+        end
+
+        # Either true or false depending on whether the column has
+        # changed.  Note that this is not exactly the same as checking if
+        # the column is in changed_columns, if the column was not set
+        # initially.
+        #
+        #   column_changed?(:name) # => true
+        def column_changed?(column)
+          initial_values.has_key?(column)
+        end
+
+        # The initial value of the given column.  If the column value has
+        # not changed, this will be the same as the current value of the
+        # column.
+        #
+        #   initial_value(:name) # => 'Initial'
+        def initial_value(column)
+          initial_values.fetch(column){send(column)}
+        end
+
+        # A hash with column symbol keys and initial values.
+        #
+        #   initial_values # {:name => 'Initial'}
+        def initial_values
+          @initial_values ||= {}
+        end
+
+        # Reset the column to its initial value.  If the column was not set
+        # initial, removes it from the values.
+        #
+        #   reset_column(:name)
+        #   name # => 'Initial'
+        def reset_column(column)
+          if initial_values.has_key?(column)
+            send(:"#{column}=", initial_values[column])
+          end
+          if missing_initial_values.include?(column)
+            values.delete(column)
+          end
+        end
+
+        # Manually specify that a column will change.  This should only be used
+        # if you plan to modify a column value in place, which is not recommended.
+        #
+        #   will_change_column(:name)
+        #   name.gsub(/i/i, 'o')
+        #   column_change(:name) # => ['Initial', 'onotoal']
+        def will_change_column(column)
+          changed_columns << column unless changed_columns.include?(column)
+          check_missing_initial_value(column)
+
+          value = if initial_values.has_key?(column)
+            initial_values[column]
+          else
+            send(column)
+          end
+
+          initial_values[column] = if value && value != true && value.respond_to?(:clone)
+            begin
+              value.clone
+            rescue TypeError
+              value
+            end
+          else
+            value
+          end
+        end
+
+        private
+
+        # Reset the initial values after saving.
+        def after_save
+          super
+          reset_initial_values
+        end
+
+        # Save the current changes so they are available after updating.  This happens
+        # before after_save resets them.
+        def after_update
+          super
+          @previous_changes = column_changes
+        end
+
+        # Reset the initial values when refreshing.
+        def _refresh(dataset)
+          super
+          reset_initial_values
+        end
+
+        # When changing the column value, save the initial column value.  If the column
+        # value is changed back to the initial value, update changed columns to remove
+        # the column.
+        def change_column_value(column, value)
+          if (iv = initial_values).has_key?(column)
+            initial = iv[column]
+            super
+            if value == initial
+              changed_columns.delete(column) unless missing_initial_values.include?(column)
+              iv.delete(column)
+            end
+          else
+            check_missing_initial_value(column)
+            iv[column] = send(column)
+            super
+          end
+        end
+
+        # If the values hash does not contain the column, make sure missing_initial_values
+        # does so that it doesn't get deleted from changed_columns if changed back,
+        # and so that resetting the column value can be handled correctly.
+        def check_missing_initial_value(column)
+          unless values.has_key?(column) || (miv = missing_initial_values).include?(column)
+            miv << column
+          end
+        end
+
+        # Reset the initial values when initializing.
+        def initialize_set(h)
+          super
+          reset_initial_values
+        end
+
+        # Array holding column symbols that were not present initially.  This is necessary
+        # to differentiate between values that were not present and values that were
+        # present but equal to nil.
+        def missing_initial_values
+          @missing_initial_values ||= []
+        end
+
+        # Clear the data structures that store the initial values.
+        def reset_initial_values
+          @initial_values.clear if @initial_values
+          @missing_initial_values.clear if @missing_initial_values
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/eager_each.rb

@@ -0,0 +1,59 @@
+module Sequel
+  module Plugins
+    # The eager_each plugin makes calling each on an eager loaded dataset do eager loading.
+    # By default, each does not work on an eager loaded dataset, because each iterates
+    # over rows of the dataset as they come in, and to eagerly load you need to have all
+    # values up front.  With the default associations code, you must call #all on an eagerly
+    # loaded dataset, as calling #each on an #eager dataset skips the eager loading, and calling
+    # #each on an #eager_graph dataset makes it yield plain hashes with columns from all
+    # tables, instead of yielding the instances of the main model.
+    #
+    # This plugin makes #each call #all for eagerly loaded datasets.  As #all usually calls
+    # #each, this is a bit of issue, but this plugin resolves the issue by cloning the dataset
+    # and setting a new flag in the cloned dataset, so that each can check with the flag to
+    # determine whether it should call all.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances eagerly load for each (called before loading subclasses)
+    #   Sequel::Model.plugin :eager_each
+    #
+    #   # Make the Album class eagerly load for each
+    #   Album.plugin :eager_each
+    module EagerEach 
+      # Methods added to eagerly loaded datasets when the eager_each plugin is in use.
+      module EagerDatasetMethods
+        # Call #all instead of #each unless #each is being called by #all.
+        def each(&block)
+          if opts[:all_called]
+            super
+          else
+            all(&block)
+          end
+        end
+
+        # Clone the dataset and set a flag to let #each know not to call #all,
+        # to avoid the infinite loop.
+        def all(&block)
+          if opts[:all_called]
+            super
+          else
+            clone(:all_called=>true).all(&block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Make sure calling each on this dataset will eagerly load the dataset.
+        def eager(*)
+          super.extend(EagerDatasetMethods)
+        end
+        
+        # Make sure calling each on this dataset will eagerly load the dataset.
+        def eager_graph(*)
+          super.extend(EagerDatasetMethods)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/force_encoding.rb

@@ -8,7 +8,7 @@ module Sequel
     # attribute, the resulting value is forced to a given encoding if the
     # value is a string.  There are two ways to specify the encoding.  You
     # can either do so in the plugin call itself, or via the
-    # forced_encoding class accessor:
+    # forced_encoding class accessor.
     #
     # Usage:
     #
@@ -46,6 +46,11 @@ module Sequel
           super(force_hash_encoding(row))
         end
         
+        # Force the encoding of all string values when setting the instance's values.
+        def set_values(row)
+          super(force_hash_encoding(row))
+        end
+        
         private
         
         # Force the encoding for all string values in the given row hash.
@@ -55,11 +60,6 @@ module Sequel
           row
         end
         
-        # Force the encoding of all string values when setting the instance's values.
-        def set_values(row)
-          super(force_hash_encoding(row))
-        end
-        
         # Force the encoding of all returned strings to the model's forced_encoding.
         def typecast_value(column, value)
           s = super

data/lib/sequel/plugins/hook_class_methods.rb

@@ -90,9 +90,9 @@ module Sequel
 
         # Make a copy of the current class's hooks for the subclass.
         def inherited(subclass)
-          super
           hooks = subclass.instance_variable_set(:@hooks, {}) 
           instance_variable_get(:@hooks).each{|k,v| hooks[k] = v.dup}
+          super
         end
     
         private