sequel 3.41.0 → 3.42.0

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

@@ -140,6 +140,11 @@ module Sequel
         sqlite_version >= 30300
       end
       
+      # SQLite 3.6.19+ supports deferrable foreign key constraints.
+      def supports_deferrable_foreign_key_constraints?
+        sqlite_version >= 30619
+      end
+
       # SQLite 3.6.8+ supports savepoints. 
       def supports_savepoints?
         sqlite_version >= 30608

data/lib/sequel/database/misc.rb

@@ -10,6 +10,10 @@ module Sequel
     # in the extension).
     EXTENSIONS = {}
 
+    # The general default size for string columns for all Sequel::Database
+    # instances.
+    DEFAULT_STRING_COLUMN_SIZE = 255
+
     # Register an extension callback for Database objects.  ext should be the
     # extension name symbol, and mod should either be a Module that the
     # database is extended with, or a callable object called with the database
@@ -44,11 +48,15 @@ module Sequel
     # Set the timezone to use for this database, overridding <tt>Sequel.database_timezone</tt>.
     attr_writer :timezone
     
+    # The specific default size of string columns for this Sequel::Database, usually 255 by default.
+    attr_accessor :default_string_column_size
+
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Accepts the following options:
     # :default_schema :: The default schema to use, see #default_schema.
+    # :default_string_column_size :: The default size of string columns, 255 by default.
     # :identifier_input_method :: A string method symbol to call on identifiers going into the database
     # :identifier_output_method :: A string method symbol to call on identifiers coming from the database
     # :logger :: A specific logger to use
@@ -71,6 +79,7 @@ module Sequel
       @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, @@single_threaded))
       @schemas = {}
       @default_schema = @opts.fetch(:default_schema, default_schema_default)
+      @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
       @prepared_statements = {}
       @transactions = {}
       @identifier_input_method = nil
@@ -205,6 +214,18 @@ module Sequel
       false
     end
 
+    # Whether the database supports deferrable constraints, false
+    # by default as few databases do.
+    def supports_deferrable_constraints?
+      false
+    end
+
+    # Whether the database supports deferrable foreign key constraints,
+    # false by default as few databases do.
+    def supports_deferrable_foreign_key_constraints?
+      supports_deferrable_constraints?
+    end
+
     # Whether the database supports DROP TABLE IF EXISTS syntax,
     # default is the same as #supports_create_table_if_not_exists?.
     def supports_drop_table_if_exists?

data/lib/sequel/database/query.rb

@@ -232,7 +232,7 @@ module Sequel
     
     # Starts a database transaction.  When a database transaction is used,
     # either all statements are successful or none of the statements are
-    # successful.  Note that MySQL MyISAM tabels do not support transactions.
+    # successful.  Note that MySQL MyISAM tables do not support transactions.
     #
     # The following general options are respected:
     #
@@ -333,7 +333,15 @@ module Sequel
         begin
           committed = commit_or_rollback_transaction(e, conn, opts)
         rescue Exception => e2
-          raise_error(e2, :classes=>database_error_classes, :conn=>conn)
+          begin
+            raise_error(e2, :classes=>database_error_classes, :conn=>conn)
+          rescue Sequel::DatabaseError => e4
+            begin
+              rollback_transaction(conn, opts)
+            ensure
+              raise e4
+            end
+          end
         ensure
           remove_transaction(conn, committed)
         end

data/lib/sequel/database/schema_generator.rb

@@ -79,10 +79,11 @@ module Sequel
       # The following options are supported:
       #
       # :default :: The default value for the column.
-      # :deferrable :: This ensure Referential Integrity will work even if
-      #                reference table will use for its foreign key a value that does not
-      #                exists(yet) on referenced table. Basically it adds
-      #                DEFERRABLE INITIALLY DEFERRED on key creation.
+      # :deferrable :: For foreign key columns, this ensures referential integrity will work even if
+      #                referencing table uses a foreign key value that does not
+      #                yet exist on referenced table (but will exist before the transaction commits).
+      #                Basically it adds DEFERRABLE INITIALLY DEFERRED on key creation.
+      #                If you use :immediate as the value, uses DEFERRABLE INITIALLY IMMEDIATE.
       # :index :: Create an index on this column.  If given a hash, use the hash as the
       #           options for the index.
       # :key :: For foreign key columns, the column in the associated table
@@ -239,6 +240,8 @@ module Sequel
       # Add a unique constraint on the given columns to the DDL.
       #
       #   unique(:name) # UNIQUE (name)
+      #
+      # Supports the same :deferrable option as #column.
       def unique(columns, opts = {})
         constraints << {:type => :unique, :columns => Array(columns)}.merge(opts)
       end
@@ -304,6 +307,8 @@ module Sequel
       #
       #   add_unique_constraint(:name) # ADD UNIQUE (name)
       #   add_unique_constraint(:name, :name=>:unique_name) # ADD CONSTRAINT unique_name UNIQUE (name)
+      #
+      # Supports the same :deferrable option as CreateTableGenerator#column.
       def add_unique_constraint(columns, opts = {})
         @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge(opts)
       end

data/lib/sequel/database/schema_methods.rb

@@ -493,7 +493,7 @@ module Sequel
       sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
       sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
       sql << " ON UPDATE #{on_update_clause(column[:on_update])}" if column[:on_update]
-      sql << " DEFERRABLE INITIALLY DEFERRED" if column[:deferrable]
+      constraint_deferrable_sql_append(sql, column[:deferrable])
       sql
     end
   
@@ -524,9 +524,23 @@ module Sequel
       else
         raise Error, "Invalid constriant type #{constraint[:type]}, should be :check, :primary_key, :foreign_key, or :unique"
       end
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
       sql
     end
 
+    # SQL DDL fragment specifying the deferrable constraint attributes.
+    def constraint_deferrable_sql_append(sql, defer)
+      case defer
+      when nil
+      when false
+        sql << ' NOT DEFERRABLE'
+      when :immediate
+        sql << ' DEFERRABLE INITIALLY IMMEDIATE'
+      else
+        sql << ' DEFERRABLE INITIALLY DEFERRED'
+      end
+    end
+
     # Execute the create table statements using the generator.
     def create_table_from_generator(name, generator, options)
       execute_ddl(create_table_sql(name, generator, options))
@@ -788,9 +802,9 @@ module Sequel
       if column[:text]
         uses_clob_for_text? ? :clob : :text
       elsif column[:fixed]
-        "char(#{column[:size]||255})"
+        "char(#{column[:size]||default_string_column_size})"
       else
-        "varchar(#{column[:size]||255})"
+        "varchar(#{column[:size]||default_string_column_size})"
       end
     end
     
@@ -810,7 +824,7 @@ module Sequel
     def type_literal_specific(column)
       type = column[:type]
       type = "double precision" if type.to_s == 'double'
-      column[:size] ||= 255 if type.to_s == 'varchar'
+      column[:size] ||= default_string_column_size if type.to_s == 'varchar'
       elements = column[:size] || column[:elements]
       "#{type}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
     end

data/lib/sequel/dataset/actions.rb

@@ -58,11 +58,14 @@ module Sequel
       a
     end
     
-    # Returns the average value for the given column.
+    # Returns the average value for the given column/expression.
+    # Uses a virtual row block if no argument is given.
     #
     #   DB[:table].avg(:number) # SELECT avg(number) FROM table LIMIT 1
     #   # => 3
-    def avg(column)
+    #   DB[:table].avg{function(column)} # SELECT avg(function(column)) FROM table LIMIT 1
+    #   # => 1
+    def avg(column=Sequel.virtual_row(&Proc.new))
       aggregate_dataset.get{avg(column)}
     end
   
@@ -342,11 +345,13 @@ module Sequel
     end
     
     # Returns the interval between minimum and maximum values for the given 
-    # column.
+    # column/expression. Uses a virtual row block if no argument is given.
     #
     #   DB[:table].interval(:id) # SELECT (max(id) - min(id)) FROM table LIMIT 1
     #   # => 6
-    def interval(column)
+    #   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))
       aggregate_dataset.get{max(column) - min(column)}
     end
 
@@ -393,19 +398,25 @@ module Sequel
       end
     end
 
-    # Returns the maximum value for the given column.
+    # Returns the maximum value for the given column/expression.
+    # Uses a virtual row block if no argument is given.
     #
     #   DB[:table].max(:id) # SELECT max(id) FROM table LIMIT 1
     #   # => 10
-    def max(column)
+    #   DB[:table].max{function(column)} # SELECT max(function(column)) FROM table LIMIT 1
+    #   # => 7
+    def max(column=Sequel.virtual_row(&Proc.new))
       aggregate_dataset.get{max(column)}
     end
 
-    # Returns the minimum value for the given column.
+    # Returns the minimum value for the given column/expression.
+    # Uses a virtual row block if no argument is given.
     #
     #   DB[:table].min(:id) # SELECT min(id) FROM table LIMIT 1
     #   # => 1
-    def min(column)
+    #   DB[:table].min{function(column)} # SELECT min(function(column)) FROM table LIMIT 1
+    #   # => 0
+    def min(column=Sequel.virtual_row(&Proc.new))
       aggregate_dataset.get{min(column)}
     end
 
@@ -428,11 +439,13 @@ module Sequel
     end
 
     # Returns a +Range+ instance made from the minimum and maximum values for the
-    # given column.
+    # given column/expression.  Uses a virtual row block if no argument is given.
     #
     #   DB[:table].range(:id) # SELECT max(id) AS v1, min(id) AS v2 FROM table LIMIT 1
     #   # => 1..10
-    def range(column)
+    #   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))
       if r = aggregate_dataset.select{[min(column).as(v1), max(column).as(v2)]}.first
         (r[:v1]..r[:v2])
       end
@@ -543,11 +556,14 @@ module Sequel
       end
     end
     
-    # Returns the sum for the given column.
+    # Returns the sum for the given column/expression.
+    # Uses a virtual row block if no column is given.
     #
     #   DB[:table].sum(:id) # SELECT sum(id) FROM table LIMIT 1
     #   # => 55
-    def sum(column)
+    #   DB[:table].sum{function(column)} # SELECT sum(function(column)) FROM table LIMIT 1
+    #   # => 10
+    def sum(column=Sequel.virtual_row(&Proc.new))
       aggregate_dataset.get{sum(column)}
     end
 

data/lib/sequel/dataset/query.rb

@@ -1101,7 +1101,7 @@ module Sequel
       when String
         LiteralString.new("(#{expr})")
       else
-        raise(Error, 'Invalid filter argument')
+        raise(Error, "Invalid filter argument: #{expr.inspect}")
       end
     end
     

data/lib/sequel/dataset/sql.rb

@@ -206,7 +206,7 @@ module Sequel
     COMMA_SEPARATOR = COMMA
     CONDITION_FALSE = '(1 = 0)'.freeze
     CONDITION_TRUE = '(1 = 1)'.freeze
-    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :compounds]
+    COUNT_FROM_SELF_OPTS = [:distinct, :group, :sql, :limit, :offset, :compounds]
     COUNT_OF_ALL_AS_COUNT = SQL::Function.new(:count, WILDCARD).as(:count)
     DATASET_ALIAS_BASE_NAME = 't'.freeze
     DEFAULT = LiteralString.new('DEFAULT').freeze

data/lib/sequel/extensions/schema_dumper.rb

@@ -304,6 +304,7 @@ END_MIG
         end
       end
       h[:unique] = true if index_opts[:unique]
+      h[:deferrable] = true if index_opts[:deferrable]
       h
     end
 

data/lib/sequel/model.rb

@@ -106,7 +106,7 @@ module Sequel
     # Class instance variables that are inherited in subclasses.  If the value is <tt>:dup</tt>, dup is called
     # on the superclass's instance variable when creating the instance variable in the subclass.
     # If the value is +nil+, the superclass's instance variable is used directly in the subclass.
-    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup, :@dataset_methods=>:dup, 
+    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup,
       :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
       :@raise_on_save_failure=>nil, :@require_modification=>nil, 
       :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
@@ -129,7 +129,6 @@ module Sequel
     @db = nil
     @db_schema = nil
     @dataset_method_modules = []
-    @dataset_methods = {}
     @overridable_methods_module = nil
     @plugins = []
     @primary_key = :id
@@ -147,7 +146,7 @@ module Sequel
     @use_after_commit_rollback = true
     @use_transactions = true
 
-    Sequel.require %w"default_inflections inflections plugins base exceptions errors", "model"
+    Sequel.require %w"default_inflections inflections plugins dataset_module base exceptions errors", "model"
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
       Sequel.require 'associations', 'model'
       plugin Model::Associations

data/lib/sequel/model/base.rb

@@ -24,11 +24,6 @@ module Sequel
       # with all of these modules.
       attr_reader :dataset_method_modules
 
-      # Hash of dataset methods with method name keys and proc values that are
-      # stored so when the dataset changes, methods defined with def_dataset_method
-      # will be applied to the new dataset.
-      attr_reader :dataset_methods
-
       # SQL string fragment used for faster DELETE statement creation when deleting/destroying
       # model instances, or nil if the optimization should not be used. For internal use only.
       attr_reader :fast_instance_delete_sql
@@ -179,13 +174,19 @@ module Sequel
       end
 
       # Extend the dataset with a module, similar to adding
-      # a plugin with the methods defined in DatasetMethods.  If a block
-      # is given, an anonymous module is created and the module_evaled, otherwise
-      # the argument should be a module.  Returns the module given or the anonymous
-      # module created.
+      # a plugin with the methods defined in DatasetMethods.
+      # This is the recommended way to add methods to model datasets.
+      #
+      # If an argument, it should be a module, and is used to extend
+      # the underlying dataset.  Otherwise an anonymous module is created, and
+      # if a block is given, it is module_evaled, allowing you do define
+      # dataset methods directly using the standard ruby def syntax.
+      # Returns the module given or the anonymous module created.
       #
+      #   # Usage with existing module
       #   Artist.dataset_module Sequel::ColumnsIntrospection
       #
+      #   # Usage with anonymous module
       #   Artist.dataset_module do
       #     def foo
       #       :bar
@@ -195,13 +196,24 @@ module Sequel
       #   # => :bar
       #   Artist.foo
       #   # => :bar
+      #
+      # Any anonymous modules created are actually instances of Sequel::Model::DatasetModule
+      # (a Module subclass), which allows you to call the subset method on them:
+      #
+      #   Artist.dataset_module do
+      #     subset :released, Sequel.identifier(release_date) > Sequel::CURRENT_DATE
+      #   end
+      #
+      # 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)
         if mod
           raise Error, "can't provide both argument and block to Model.dataset_module" if block_given?
           dataset_extend(mod)
           mod
         else
-          @dataset_module ||= Module.new
+          @dataset_module ||= DatasetModule.new(self)
           @dataset_module.module_eval(&Proc.new) if block_given?
           dataset_extend(@dataset_module)
           @dataset_module
@@ -270,6 +282,10 @@ module Sequel
       # If a block is not given, just define a class method on the model for each argument
       # that calls the dataset method of the same argument name.
       #
+      # It is recommended that you define methods inside a block passed to #dataset_module
+      # instead of using this method, as #dataset_module allows you to use normal
+      # ruby def syntax.
+      #
       #   # Add new dataset method and class method that calls it
       #   Artist.def_dataset_method(:by_name){order(:name)}
       #   Artist.filter(:name.like('A%')).by_name
@@ -280,18 +296,12 @@ module Sequel
       #   Artist.server!(:server1)
       def def_dataset_method(*args, &block)
         raise(Error, "No arguments given") if args.empty?
+
         if block
           raise(Error, "Defining a dataset method using a block requires only one argument") if args.length > 1
-          meth = args.first
-          @dataset_methods[meth] = block
-          dataset.meta_def(meth, &block) if @dataset
-        end
-        args.each do |arg|
-          if arg.to_s =~ NORMAL_METHOD_NAME_REGEXP
-            instance_eval("def #{arg}(*args, &block); dataset.#{arg}(*args, &block) end", __FILE__, __LINE__) unless respond_to?(arg, true)
-          else
-            def_model_dataset_method_block(arg)
-          end
+          dataset_module{define_method(args.first, &block)}
+        else
+          args.each{|arg| def_model_dataset_method(arg)}
         end
       end
 
@@ -483,8 +493,7 @@ module Sequel
       # Returns self.
       #
       # This changes the row_proc of the dataset to return
-      # model objects, extends the dataset with the dataset_method_modules,
-      # and defines methods on the dataset using the dataset_methods.
+      # model objects and extends the dataset with the dataset_method_modules.
       # It also attempts to determine the database schema for the model,
       # based on the given dataset.
       #
@@ -514,11 +523,10 @@ module Sequel
           @columns = @dataset.columns rescue nil
         else
           @dataset_method_modules.each{|m| @dataset.extend(m)} if @dataset_method_modules
-          @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
         end
         @dataset.model = self if @dataset.respond_to?(:model=)
         check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)}
-        @instance_dataset = @dataset.limit(1).naked
+        reset_instance_dataset
         self
       end
 
@@ -577,8 +585,8 @@ module Sequel
         end
       end
   
-      # Shortcut for +def_dataset_method+ that is restricted to modifying the
-      # dataset's filter. Sometimes thought of as a scope, and like most dataset methods,
+      # Sets up a dataset method that returns a filtered dataset.
+      # Sometimes thought of as a scope, and like most dataset methods,
       # they can be chained.
       # For example:
       #
@@ -597,9 +605,10 @@ module Sequel
       # Both the args given and the block are passed to <tt>Dataset#filter</tt>.
       #
       # This method creates dataset methods that do not accept arguments.  To create
-      # dataset methods that accept arguments, you have to use def_dataset_method.
+      # dataset methods that accept arguments, you should use define a
+      # method directly inside a #dataset_module block.
       def subset(name, *args, &block)
-        def_dataset_method(name){filter(*args, &block)}
+        dataset_module.subset(name, *args, &block)
       end
       
       # Returns name of primary table for the dataset. If the table for the dataset
@@ -640,10 +649,10 @@ module Sequel
       # module if the model has a dataset.  Add dataset methods to the class for all
       # public dataset methods.
       def dataset_extend(mod)
-        dataset.extend(mod) if @dataset
+        @dataset.extend(mod) if @dataset
+        reset_instance_dataset
         dataset_method_modules << mod
-        meths = mod.public_instance_methods.reject{|x| NORMAL_METHOD_NAME_REGEXP !~ x.to_s}
-        def_dataset_method(*meths) unless meths.empty?
+        mod.public_instance_methods.each{|meth| def_model_dataset_method(meth)}
       end
 
       # Create a column accessor for a column with a method name that is hard to use in ruby code.
@@ -671,8 +680,14 @@ module Sequel
       # Define a model method that calls the dataset method with the same name,
       # only used for methods with names that can't be presented directly in
       # ruby code.
-      def def_model_dataset_method_block(arg)
-        meta_def(arg){|*args, &block| dataset.send(arg, *args, &block)}
+      def def_model_dataset_method(meth)
+        return if respond_to?(meth, true)
+
+        if meth.to_s =~ NORMAL_METHOD_NAME_REGEXP
+          instance_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        else
+          meta_def(meth){|*args, &block| dataset.send(meth, *args, &block)}
+        end
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -799,6 +814,12 @@ module Sequel
           "DELETE FROM #@simple_table WHERE #@simple_pk = ".freeze
         end
       end
+
+      # Reset the instance dataset to a modified copy of the current dataset,
+      # should be used whenever the model's dataset is modified.
+      def reset_instance_dataset
+        @instance_dataset = @dataset.limit(1).naked if @dataset
+      end
   
       # Set the columns for this model and create accessor methods for each column.
       def set_columns(new_columns)