sequel 3.7.0 → 3.8.0

data/lib/sequel/database/schema_generator.rb

@@ -1,6 +1,5 @@
 module Sequel
-  # The Schema module holds the schema generators and the SQL code relating
-  # to SQL DDL (Data Definition Language).
+  # The Schema module holds the schema generators.
   module Schema
     # Schema::Generator is an internal class that the user is not expected
     # to instantiate directly.  Instances are created by Database#create_table.

data/lib/sequel/dataset.rb

@@ -41,7 +41,7 @@ module Sequel
 
     # Which options don't affect the SQL generation.  Used by simple_select_all?
     # to determine if this is a simple SELECT * FROM table.
-    NON_SQL_OPTIONS = [:server, :defaults, :overrides]
+    NON_SQL_OPTIONS = [:server, :defaults, :overrides, :graph, :eager_graph, :graph_aliases]
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
     WITH_SUPPORTED=:select_with_sql
@@ -120,6 +120,15 @@ module Sequel
       end
     end
 
+    # Yield a dataset for each server in the connection pool that is tied to that server.
+    # Intended for use in sharded environments where all servers need to be modified
+    # with the same data:
+    #
+    #   DB[:configs].where(:key=>'setting').each_server{|ds| ds.update(:value=>'new_value')}
+    def each_server
+      db.servers.each{|s| yield server(s)}
+    end
+
     # Returns a string representation of the dataset including the class name 
     # and the corresponding SQL select statement.
     def inspect

data/lib/sequel/dataset/actions.rb

@@ -1,6 +1,5 @@
 module Sequel
   class Dataset
-
     # Alias for insert, but not aliased directly so subclasses
     # don't have to override both methods.
     def <<(*args)
@@ -56,12 +55,10 @@ module Sequel
     def each(&block)
       if @opts[:graph]
         graph_each(&block)
+      elsif row_proc = @row_proc
+        fetch_rows(select_sql){|r| yield row_proc.call(r)}
       else
-        if row_proc = @row_proc
-          fetch_rows(select_sql){|r| yield row_proc.call(r)}
-        else
-          fetch_rows(select_sql, &block)
-        end
+        fetch_rows(select_sql, &block)
       end
       self
     end
@@ -79,7 +76,7 @@ module Sequel
       execute_insert(insert_sql(*values))
     end
   
-    # Alias for set, but not aliased directly so subclasses
+    # Alias for update, but not aliased directly so subclasses
     # don't have to override both methods.
     def set(*args)
       update(*args)
@@ -118,6 +115,5 @@ module Sequel
     def execute_insert(sql, opts={}, &block)
       @db.execute_insert(sql, default_server_opts(opts), &block)
     end
-  
   end
 end

data/lib/sequel/dataset/convenience.rb

@@ -194,10 +194,16 @@ module Sequel
       end
     end
     
+    # Returns a hash with key_column values as keys and value_column values as
+    # values.  Similar to to_hash, but only selects the two columns.
     def select_hash(key_column, value_column)
       select(key_column, value_column).to_hash(hash_key_symbol(key_column), hash_key_symbol(value_column))
     end
-
+    
+    # Selects the column given (either as an argument or as a block), and
+    # returns an array of all values of that column in the dataset.  If you
+    # give a block argument that returns an array with multiple entries,
+    # the contents of the resulting array are undefined.
     def select_map(column=nil, &block)
       ds = naked.ungraphed
       ds = if column
@@ -208,7 +214,8 @@ module Sequel
       end
       ds.map{|r| r.values.first}
     end
-
+    
+    # The same as select_map, but in addition orders the array by the column.
     def select_order_map(column=nil, &block)
       ds = naked.ungraphed
       ds = if column

data/lib/sequel/dataset/query.rb

@@ -1,8 +1,5 @@
 module Sequel
   class Dataset
-
-    FROM_SELF_KEEP_OPTS = [:graph, :eager_graph, :graph_aliases]
-
     # Adds an further filter to an existing filter using AND. If no filter 
     # exists an error is raised. This method is identical to #filter except
     # it expects an existing filter.
@@ -148,7 +145,7 @@ module Sequel
     #   ds.from_self(:alias=>:foo).sql #=> "SELECT * FROM (SELECT id, name FROM items ORDER BY name) AS foo"
     def from_self(opts={})
       fs = {}
-      @opts.keys.each{|k| fs[k] = nil unless FROM_SELF_KEEP_OPTS.include?(k)}
+      @opts.keys.each{|k| fs[k] = nil unless NON_SQL_OPTIONS.include?(k)}
       clone(fs).from(opts[:alias] ? as(opts[:alias]) : self)
     end
 
@@ -263,7 +260,7 @@ module Sequel
       columns += Array(Sequel.virtual_row(&block)) if block
       clone(:order => (columns.compact.empty?) ? nil : columns)
     end
-    alias_method :order_by, :order
+    alias order_by order
     
     # Returns a copy of the dataset with the order columns added
     # to the existing order.

data/lib/sequel/dataset/sql.rb

@@ -1,6 +1,5 @@
 module Sequel
   class Dataset
-
     # Given a type (e.g. select) and an array of clauses,
     # return an array of methods to call to build the SQL string.
     def self.clause_methods(type, clauses)

data/lib/sequel/exceptions.rb

@@ -28,14 +28,14 @@ module Sequel
   # Raised on an invalid operation, such as trying to update or delete
   # a joined or grouped dataset.
   class InvalidOperation < Error; end
-                                     
+
   # Raised when attempting an invalid type conversion.
   class InvalidValue < Error ; end
-                                     
+
   # Raised when the connection pool cannot acquire a database connection
   # before the timeout.
   class PoolTimeout < Error ; end
-                                     
+
   # Exception that you should raise to signal a rollback of the current transaction.
   # The transaction block will catch this exception, rollback the current transaction,
   # and won't reraise it.

data/lib/sequel/metaprogramming.rb

@@ -1,23 +1,9 @@
 module Sequel
-  # Contains methods that ease metaprogramming, used by some of Sequel's classes.
+  # Contains meta_def method for adding methods to objects via blocks, used by some of Sequel's classes and objects.
   module Metaprogramming
-    # Add methods to the object's metaclass
+    # Define a method with the given name and block body on the receiver.
     def meta_def(name, &block)
-      meta_eval{define_method(name, &block)}
-    end 
-  
-    private
-  
-    # Evaluate the block in the context of the object's metaclass
-    def meta_eval(&block)
-      metaclass.instance_eval(&block)
-    end 
-  
-    # The hidden singleton lurks behind everyone
-    def metaclass
-      class << self
-        self
-      end 
-    end 
+      (class << self; self end).send(:define_method, name, &block)
+    end
   end
 end

data/lib/sequel/model/associations.rb

@@ -461,7 +461,7 @@ module Sequel
         #     before a new item is added to the association.
         #   - :before_remove - Symbol, Proc, or array of both/either specifying a callback to call
         #     before an item is removed from the association.
-        #   - :cartesian_product_number - he number of joins completed by this association that could cause more
+        #   - :cartesian_product_number - the number of joins completed by this association that could cause more
         #     than one row for each row in the current table (default: 0 for many_to_one associations,
         #     1 for *_to_many associations).
         #   - :class - The associated class or its name. If not
@@ -1377,7 +1377,7 @@ module Sequel
       
         # Make sure the association is valid for this model, and return the related AssociationReflection.
         def check_association(model, association)
-          raise(Sequel::Error, 'Invalid association') unless reflection = model.association_reflection(association)
+          raise(Sequel::Error, "Invalid association #{association} for #{model.name}") unless reflection = model.association_reflection(association)
           raise(Sequel::Error, "Eager loading is not allowed for #{model.name} association #{association}") if reflection[:allow_eager] == false
           reflection
         end

data/lib/sequel/model/base.rb

@@ -290,13 +290,7 @@ module Sequel
           @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
         end
         @dataset.model = self if @dataset.respond_to?(:model=)
-        begin
-          @db_schema = (inherited ? superclass.db_schema : get_db_schema)
-        rescue Sequel::DatabaseConnectionError
-          raise
-        rescue
-          nil
-        end
+        check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)}
         self
       end
       alias dataset= set_dataset
@@ -368,6 +362,17 @@ module Sequel
   
       private
       
+      # Yield to the passed block and swallow all errors other than DatabaseConnectionErrors.
+      def check_non_connection_error
+        begin
+          yield
+        rescue Sequel::DatabaseConnectionError
+          raise
+        rescue
+          nil
+        end
+      end
+
       # Create a column accessor for a column with a method name that is hard to use in ruby code.
       def def_bad_column_accessor(column)
         overridable_methods_module.module_eval do
@@ -399,15 +404,7 @@ module Sequel
         ds_opts = dataset.opts
         single_table = ds_opts[:from] && (ds_opts[:from].length == 1) \
           && !ds_opts.include?(:join) && !ds_opts.include?(:sql)
-        get_columns = proc do
-          begin
-            columns
-          rescue Sequel::DatabaseConnectionError
-            raise
-          rescue
-            []
-          end
-        end
+        get_columns = proc{check_non_connection_error{columns} || []}
         if single_table && (schema_array = (db.schema(table_name, :reload=>reload) rescue nil))
           schema_array.each{|k,v| schema_hash[k] = v}
           if ds_opts.include?(:select)
@@ -576,7 +573,7 @@ module Sequel
       # self.class.
       alias_method :model, :class
   
-      # The current cached associations.  A hash with the keys being the
+      # The currently cached associations.  A hash with the keys being the
       # association name symbols and the values being the associated object
       # or nil (many_to_one), or the array of associated objects (*_to_many).
       def associations
@@ -904,7 +901,7 @@ module Sequel
       
       # If transactions should be used, wrap the yield in a transaction block.
       def checked_transaction(opts)
-        use_transaction?(opts)? db.transaction(opts){yield} : yield
+        use_transaction?(opts) ? db.transaction(opts){yield} : yield
       end
 
       # Default inspection output for the values hash, overwrite to change what #inspect displays.

data/lib/sequel/model/default_inflections.rb

@@ -37,7 +37,6 @@ module Sequel
     irregular('child', 'children')
     irregular('sex', 'sexes')
     irregular('move', 'moves')
-    irregular('ox', 'oxen')
     irregular('quiz', 'quizzes')
     irregular('testis', 'testes')
 

data/lib/sequel/model/plugins.rb

@@ -5,8 +5,9 @@ module Sequel
   # Plugins should be modules with one of the following conditions:
   # * A singleton method named apply, which takes a model, 
   #   additional arguments, and an optional block.  This is called
-  #   once, the first time the plugin is loaded, with the arguments
-  #   and block provide to the call to Model.plugin.
+  #   the first time the plugin is loaded for this model (unless it was
+  #   already loaded by an ancestor class), with the arguments
+  #   and block provided to the call to Model.plugin.
   # * A module inside the plugin module named InstanceMethods,
   #   which will be included in the model class.
   # * A module inside the plugin module named ClassMethods,

data/lib/sequel/plugins/boolean_readers.rb

@@ -15,7 +15,7 @@ module Sequel
     module BooleanReaders
       # Default proc for determining if given column is a boolean, which
       # just checks that the :type is boolean.
-      DEFAULT_BOOLEAN_ATTRIBUTE_PROC = lambda{|c| db_schema[c][:type] == :boolean}
+      DEFAULT_BOOLEAN_ATTRIBUTE_PROC = lambda{|c| s = db_schema[c] and s[:type] == :boolean}
 
       # Add the boolean_attribute? class method to the model, and create
       # attribute? boolean reader methods for the class's columns if the class has a dataset.
@@ -44,7 +44,8 @@ module Sequel
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
           im = instance_methods.collect{|x| x.to_s}
-          columns.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
+          cs = columns rescue return
+          cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
         end
       end
     end

data/lib/sequel/plugins/identity_map.rb

@@ -80,6 +80,15 @@ module Sequel
       end
 
       module InstanceMethods
+        # Remove instances from the identity map cache if they are deleted.
+        def delete
+          super
+          if idm = model.identity_map
+            idm.delete(model.identity_map_key(pk))
+          end
+          self
+        end
+
         # Merge the current values into the values provided in the row, ensuring
         # that current values are not overridden by new values.
         def merge_db_update(row)

data/lib/sequel/plugins/validation_helpers.rb

@@ -54,6 +54,7 @@ module Sequel
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
         :not_string=>{:message=>lambda{|type| type ? "is not a valid #{type}" : "is a string"}},
         :numeric=>{:message=>lambda{"is not a number"}},
+        :type=>{:message=>lambda{|klass| "is not a #{klass}"}},
         :presence=>{:message=>lambda{"is not present"}},
         :unique=>{:message=>lambda{'is already taken'}}
       }
@@ -110,7 +111,7 @@ module Sequel
         def validates_not_string(atts, opts={})
           validatable_attributes_for_type(:not_string, atts, opts){|a,v,m| validation_error_message(m, (db_schema[a]||{})[:type]) if v.is_a?(String)}
         end
-    
+
         # Check attribute value(s) string representation is a valid float.
         def validates_numeric(atts, opts={})
           validatable_attributes_for_type(:numeric, atts, opts) do |a,v,m|
@@ -122,6 +123,12 @@ module Sequel
             end
           end
         end
+
+        # Check if value is an instance of a class
+        def validates_type(klass, atts, opts={})
+          klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
+          validatable_attributes_for_type(:type, atts, opts){|a,v,m| validation_error_message(m, klass) if v && !v.is_a?(klass)}
+        end
     
         # Check attribute value(s) is not considered blank by the database, but allow false values.
         def validates_presence(atts, opts={})

data/lib/sequel/sql.rb

@@ -36,6 +36,16 @@ module Sequel
 
     # Base class for all SQL fragments
     class Expression
+      # all instance variables declared to be readers are to be used for comparison.
+      def self.attr_reader(*args)
+        super
+        comparison_attrs.concat args
+      end
+
+      def self.comparison_attrs
+        @comparison_attrs ||= self == Expression ? [] : superclass.comparison_attrs.clone
+      end
+
       # Create a to_s instance method that takes a dataset, and calls
       # the method provided on the dataset with args as the argument (self by default).
       # Used to DRY up some code.
@@ -54,6 +64,13 @@ module Sequel
       def sql_literal(ds)
         to_s(ds)
       end
+
+      # Returns true if the receiver is the same expression as the
+      # the +other+ expression.
+      def eql?(other)
+        other.is_a?(self.class) && !self.class.comparison_attrs.find {|a| send(a) != other.send(a)}
+      end
+      alias == eql?
     end
 
     # Represents a complex SQL expression, with a given operator and one
@@ -74,10 +91,10 @@ module Sequel
         :'!~*' => :'~*', :NOT => :NOOP, :NOOP => :NOT, :ILIKE => :'NOT ILIKE',
         :'NOT ILIKE'=>:ILIKE}
 
-      # Mathematical Operators used in NumericMethods
+      # Standard Mathematical Operators used in NumericMethods
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
 
-      # Mathematical Operators used in NumericMethods
+      # Bitwise Mathematical Operators used in NumericMethods
       BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>]
 
       # Inequality Operators used in InequalityMethods
@@ -125,13 +142,6 @@ module Sequel
         @op = op
         @args = args
       end
-
-      # Returns true if the receiver is the same expression as the
-      # the +other+ expression.
-      def eql?(other)
-        other.is_a?(self.class) && @op.eql?(other.op) && @args.eql?(other.args)
-      end
-      alias == eql?
       
       to_s_method :complex_expression_sql, '@op, @args'
     end
@@ -548,7 +558,7 @@ module Sequel
       include SubscriptMethods
     end
 
-    # Represents constants or psuedo-constants (e.g. CURRENT_DATE) in SQL
+    # Represents constants or psuedo-constants (e.g. CURRENT_DATE) in SQL.
     class Constant < GenericExpression
       # Create an object with the given table
       def initialize(constant)
@@ -567,7 +577,7 @@ module Sequel
     end
     
     # Represents inverse boolean constants (currently only NOTNULL). A
-    # special class to allow for special behavior
+    # special class to allow for special behavior.
     class NegativeBooleanConstant < BooleanConstant
       to_s_method :negative_boolean_constant_sql, '@constant'
     end

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 7
+  MINOR = 8
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mssql_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
+require ENV['SEQUEL_MSSQL_SPEC_REQUIRE'] if ENV['SEQUEL_MSSQL_SPEC_REQUIRE']
+
 unless defined?(MSSQL_DB)
   MSSQL_URL = 'jdbc:sqlserver://localhost;integratedSecurity=true;database=sandbox' unless defined? MSSQL_URL
   MSSQL_DB = Sequel.connect(ENV['SEQUEL_MSSQL_SPEC_DB']||MSSQL_URL)
@@ -332,9 +334,13 @@ context "MSSSQL::Dataset#insert" do
   specify "should have insert_select return nil if disable_insert_output is used" do
     @ds.disable_insert_output.insert_select(:value=>10).should == nil
   end
+  
+  specify "should have insert_select return nil if the server version is not 2005+" do
+    @ds.meta_def(:server_version){8000760}
+    @ds.insert_select(:value=>10).should == nil
+  end
 
   specify "should have insert_select insert the record and return the inserted record" do
-    @ds.meta_def(:server_version){80201}
     h = @ds.insert_select(:value=>10)
     h[:value].should == 10
     @ds.first(:xid=>h[:xid])[:value].should == 10