sequel 3.34.1 → 3.35.0

data/lib/sequel/database/schema_generator.rb

@@ -83,7 +83,8 @@ module Sequel
       #                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.
-      # :index :: Create an index on this column.
+      # :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
       #         that this column references.  Unnecessary if this column
       #         references the primary key of the associated table, except if you are
@@ -107,7 +108,9 @@ module Sequel
       #              columns.
       def column(name, type, opts = {})
         columns << {:name => name, :type => type}.merge(opts)
-        index(name) if opts[:index]
+        if index_opts = opts[:index]
+          index(name, index_opts.is_a?(Hash) ? index_opts : {})
+        end
       end
       
       # Adds a named constraint (or unnamed if name is nil) to the DDL,

data/lib/sequel/database/schema_methods.rb

@@ -132,19 +132,27 @@ module Sequel
     #   end
     #
     # Options:
-    # :temp :: Create the table as a temporary table.
+    # :as :: Create the table using the value, which should be either a
+    #        dataset or a literal SQL string.  If this option is used,
+    #        a block should not be given to the method.
     # :ignore_index_errors :: Ignore any errors when creating indexes.
+    # :temp :: Create the table as a temporary table.
     #
-    # See <tt>Schema::Generator</tt> and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
+    # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
     def create_table(name, options={}, &block)
       remove_cached_schema(name)
       options = {:generator=>options} if options.is_a?(Schema::Generator)
-      generator = options[:generator] || Schema::Generator.new(self, &block)
-      create_table_from_generator(name, generator, options)
-      create_table_indexes_from_generator(name, generator, options)
-      nil
+      if sql = options[:as]
+        raise(Error, "can't provide both :as option and block to create_table") if block
+        create_table_as(name, sql, options)
+      else
+        generator = options[:generator] || Schema::Generator.new(self, &block)
+        create_table_from_generator(name, generator, options)
+        create_table_indexes_from_generator(name, generator, options)
+        nil
+      end
     end
-    
+
     # Forcibly create a table, attempting to drop it if it already exists, then creating it.
     # 
     #   DB.create_table!(:a){Integer :a} 
@@ -466,7 +474,25 @@ module Sequel
 
     # DDL statement for creating a table with the given name, columns, and options
     def create_table_sql(name, generator, options)
-      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)} (#{column_list_sql(generator)})"
+      "#{create_table_prefix_sql(name, options)} (#{column_list_sql(generator)})"
+    end
+
+    # Run a command to create the table with the given name from the given
+    # SELECT sql statement.
+    def create_table_as(name, sql, options)
+      sql = sql.sql if sql.is_a?(Sequel::Dataset)
+      run(create_table_as_sql(name, sql, options))
+    end
+    
+    # DDL statement for creating a table from the result of a SELECT statement.
+    # +sql+ should be a string representing a SELECT query.
+    def create_table_as_sql(name, sql, options)
+      "#{create_table_prefix_sql(name, options)} AS #{sql}"
+    end
+
+    # DDL statement for creating a table with the given name, columns, and options
+    def create_table_prefix_sql(name, options)
+      "CREATE #{temporary_table_sql if options[:temp]}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
     end
 
     # Default index name for the table and columns, may be too long

data/lib/sequel/dataset/prepared_statements.rb

@@ -247,7 +247,7 @@ module Sequel
     #   DB.call(:select_by_name, :name=>'Blah') # Same thing
     def prepare(type, name=nil, *values)
       ps = to_prepared_statement(type, values)
-      db.prepared_statements[name] = ps if name
+      db.set_prepared_statement(name, ps) if name
       ps
     end
     

data/lib/sequel/dataset/sql.rb

@@ -152,8 +152,8 @@ module Sequel
       if opts[:sql]
         static_sql(opts[:sql])
       else
-        check_modification_allowed!
-        raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where]
+        check_truncation_allowed!
+        raise(InvalidOperation, "Can't truncate filtered datasets") if opts[:where] || opts[:having]
         _truncate_sql(source_list(opts[:from]))
       end
     end
@@ -190,7 +190,6 @@ module Sequel
     ARRAY_EMPTY = '(NULL)'.freeze
     AS = ' AS '.freeze
     ASC = ' ASC'.freeze
-    BACKSLASH_RE = /\\/.freeze
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
     BRACKET_CLOSE =  ']'.freeze
@@ -257,7 +256,6 @@ module Sequel
     PAREN_OPEN = '('.freeze
     PAREN_SPACE_OPEN = ' ('.freeze
     PARTITION_BY = "PARTITION BY ".freeze
-    QUAD_BACKSLASH = "\\\\\\\\".freeze
     QUALIFY_KEYS = [:select, :where, :having, :order, :group]
     QUESTION_MARK = '?'.freeze
     QUESTION_MARK_RE = /\?/.freeze
@@ -279,7 +277,6 @@ module Sequel
     UPDATE_CLAUSE_METHODS = clause_methods(:update, %w'update table set where')
     USING = ' USING ('.freeze
     VALUES = " VALUES ".freeze
-    V187 = '1.8.7'.freeze
     V190 = '1.9.0'.freeze
     WHERE = " WHERE ".freeze
 
@@ -558,15 +555,11 @@ module Sequel
       sql << PAREN_OPEN if pls.parens
       if args.is_a?(Hash)
         re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
-        if RUBY_VERSION >= V187
-          loop do
-            previous, q, str = str.partition(re)
-            sql << previous
-            literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
-            break if str.empty?
-          end
-        else
-          sql << str.gsub(re){literal(args[$1.to_sym])}
+        loop do
+          previous, q, str = str.partition(re)
+          sql << previous
+          literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
+          break if str.empty?
         end
       elsif str.is_a?(Array)
         len = args.length
@@ -576,15 +569,11 @@ module Sequel
         end
       else
         i = -1
-        if RUBY_VERSION >= V187
-          loop do
-            previous, q, str = str.partition(QUESTION_MARK)
-            sql << previous
-            literal_append(sql, args.at(i+=1)) unless q.empty?
-            break if str.empty?
-          end
-        else
-          sql << str.gsub(QUESTION_MARK_RE){literal(args.at(i+=1))}
+        loop do
+          previous, q, str = str.partition(QUESTION_MARK)
+          sql << previous
+           literal_append(sql, args.at(i+=1)) unless q.empty?
+          break if str.empty?
         end
       end
       sql << PAREN_CLOSE if pls.parens
@@ -801,6 +790,11 @@ module Sequel
       raise(InvalidOperation, "Joined datasets cannot be modified") if !supports_modifying_joins? && joined_dataset?
     end
 
+    # Alias of check_modification_allowed!
+    def check_truncation_allowed!
+      check_modification_allowed!
+    end
+
     # Prepare an SQL statement by calling all clause methods for the given statement type.
     def clause_sql(type)
       sql = @opts[:append_sql] || sql_string_origin
@@ -1102,7 +1096,7 @@ module Sequel
 
     # SQL fragment for String.  Doubles \ and ' by default.
     def literal_string_append(sql, v)
-      sql << APOS << v.gsub(BACKSLASH_RE, QUAD_BACKSLASH).gsub(APOS_RE, DOUBLE_APOS) << APOS
+      sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
     end
 
     # Converts a symbol into a column name. This method supports underscore

data/lib/sequel/extensions/core_extensions.rb

@@ -21,20 +21,6 @@ class Array
     Sequel.~(self)
   end
 
-  # +true+ if the array is not empty and all of its elements are
-  # arrays of size 2, +false+ otherwise.  This is used to determine if the array
-  # could be a specifier of conditions, used similarly to a hash
-  # but allowing for duplicate keys and a specific order.
-  #
-  #    [].to_a.all_two_pairs? # => false
-  #    [:a].to_a.all_two_pairs? # => false
-  #    [[:b]].to_a.all_two_pairs? # => false
-  #    [[:a, 1]].to_a.all_two_pairs? # => true
-  def all_two_pairs?
-    warn('Array#all_two_pairs? is deprecated and will be removed in Sequel 3.35.0')
-    !empty? && all?{|i| (Array === i) && (i.length == 2)}
-  end
-
   # Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
   # default value and expression.
   #
@@ -103,15 +89,6 @@ class Array
   def sql_string_join(joiner=nil)
     Sequel.join(self, joiner)
   end
-
-  private
-
-  # Raise an error if this array is not made up all two element arrays, otherwise create a <tt>Sequel::SQL::BooleanExpression</tt> from this array.
-  def sql_expr_if_all_two_pairs(*args)
-    warn('Array#sql_expr_if_all_two_pairs? is deprecated and will be removed in Sequel 3.35.0')
-    raise(Sequel::Error, 'Not all elements of the array are arrays of size 2, so it cannot be converted to an SQL expression') unless all_two_pairs?
-    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, *args)
-  end
 end
 
 # Sequel extends +Hash+ to add methods to implement the SQL DSL.

data/lib/sequel/extensions/migration.rb

@@ -44,9 +44,9 @@ module Sequel
       descendants << base
     end
 
-    # Always use transactions for old-style migrations.
+    # Don't allow transaction overriding in old migrations.
     def self.use_transactions
-      true
+      nil
     end
     
     # The default down action does nothing
@@ -74,12 +74,13 @@ module Sequel
     # Proc used for the up action
     attr_accessor :up
 
-    # Whether to use transactions for this migration, true by default.
+    # Whether to use transactions for this migration, default depends on the
+    # database.
     attr_accessor :use_transactions
 
-    # Use transactions by default
+    # Don't set transaction use by default.
     def initialize
-      @use_transactions = true
+      @use_transactions = nil
     end
 
     # Apply the appropriate block on the +Database+
@@ -118,6 +119,11 @@ module Sequel
       migration.use_transactions = false
     end
 
+    # Enable the use of transactions for the related migration
+    def transaction
+      migration.use_transactions = true
+    end
+
     # Defines the migration's up action.
     def up(&block)
       migration.up = block
@@ -414,9 +420,17 @@ module Sequel
     # If transactions should be used for the migration, yield to the block
     # inside a transaction.  Otherwise, just yield to the block.
     def checked_transaction(migration, &block)
-      if @use_transactions == false
-        yield
-      elsif migration.use_transactions || @use_transactions
+      use_trans = if @use_transactions.nil?
+        if migration.use_transactions.nil?
+          @db.supports_transactional_ddl?
+        else
+          migration.use_transactions
+        end
+      else
+        @use_transactions
+      end
+
+      if use_trans
         db.transaction(&block)
       else
         yield

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -153,6 +153,10 @@ module Sequel
           end
         end
 
+        def use_cursor(*)
+          super.no_auto_parameterize
+        end
+
         protected
 
         # Disable automatic parameterization for prepared statements,

data/lib/sequel/extensions/schema_dumper.rb

@@ -175,7 +175,7 @@ END_MIG
         {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
       when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/o
         {:type=>File, :size=>($1.to_i if $1)}
-      when 'year'
+      when /\A(?:year|(?:int )?identity)\z/o
         {:type=>Integer}
       else
         {:type=>String}

data/lib/sequel/model.rb

@@ -35,7 +35,7 @@ module Sequel
   #     dataset # => DB1[:comments]
   #   end
   def self.Model(source)
-    if Sequel::Model.cache_anonymous_models && (klass = Model::ANONYMOUS_MODEL_CLASSES[source])
+    if Sequel::Model.cache_anonymous_models && (klass = Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
       return klass
     end
     klass = if source.is_a?(Database)
@@ -45,7 +45,7 @@ module Sequel
     else
       Class.new(Model).set_dataset(source)
     end
-    Model::ANONYMOUS_MODEL_CLASSES[source] = klass if Sequel::Model.cache_anonymous_models
+    Sequel.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if Sequel::Model.cache_anonymous_models
     klass
   end
 

data/lib/sequel/model/associations.rb

@@ -54,7 +54,7 @@ module Sequel
       
         # The class associated to the current model class via this association
         def associated_class
-          self[:class] ||= constantize(self[:class_name])
+          cached_fetch(:class){constantize(self[:class_name])}
         end
         
         # Whether this association can have associated objects, given the current
@@ -81,9 +81,9 @@ module Sequel
     
         # The eager limit strategy to use for this dataset.
         def eager_limit_strategy
-          fetch(:_eager_limit_strategy) do
-            self[:_eager_limit_strategy] = if self[:limit]
-              case s = self.fetch(:eager_limit_strategy){self[:model].default_eager_limit_strategy || :ruby}
+          cached_fetch(:_eager_limit_strategy) do
+            if self[:limit]
+              case s = cached_fetch(:eager_limit_strategy){self[:model].default_eager_limit_strategy || :ruby}
               when true
                 ds = associated_class.dataset
                 if ds.supports_window_functions?
@@ -151,16 +151,19 @@ module Sequel
         # to populate reciprocal associations.  For example, when you do this_artist.add_album(album)
         # it sets album.artist to this_artist.
         def reciprocal
-          return self[:reciprocal] if include?(:reciprocal)
-          r_types = Array(reciprocal_type)
-          keys = self[:keys]
-          associated_class.all_association_reflections.each do |assoc_reflect|
-            if r_types.include?(assoc_reflect[:type]) && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
-              self[:reciprocal_type] = assoc_reflect[:type]
-              return self[:reciprocal] = assoc_reflect[:name]
+          cached_fetch(:reciprocal) do
+            r_types = Array(reciprocal_type)
+            keys = self[:keys]
+            recip = nil
+            associated_class.all_association_reflections.each do |assoc_reflect|
+              if r_types.include?(assoc_reflect[:type]) && assoc_reflect[:keys] == keys && assoc_reflect.associated_class == self[:model]
+                cached_set(:reciprocal_type, assoc_reflect[:type])
+                recip = assoc_reflect[:name]
+                break
+              end
             end
+            recip
           end
-          self[:reciprocal] = nil
         end
     
         # Whether the reciprocal of this association returns an array of objects instead of a single object,
@@ -214,6 +217,39 @@ module Sequel
         
         private
 
+        if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
+          # On non-GVL rubies, assume the need to synchronize access.  Store the key
+          # in a special sub-hash that always uses this method to synchronize access.
+          def cached_fetch(key)
+            fetch(key) do
+              h = self[:cache]
+              Sequel.synchronize{return h[key] if h.has_key?(key)}
+              value = yield
+              Sequel.synchronize{h[key] = value}
+            end
+          end
+
+          # Cache the value at the given key, synchronizing access.
+          def cached_set(key, value)
+            h = self[:cache]
+            Sequel.synchronize{h[key] = value}
+          end
+        else
+          # On MRI, use a plain fetch, since the GVL will synchronize access.
+          def cached_fetch(key)
+            fetch(key) do 
+              h = self[:cache]
+              h.fetch(key){h[key] = yield}
+            end
+          end
+
+          # On MRI, just set the value at the key in the cache, since the GVL
+          # will synchronize access.
+          def cached_set(key, value)
+            self[:cache][key] = value
+          end
+        end
+
         # If +s+ is an array, map +s+ over the block.  Otherwise, just call the
         # block with +s+.
         def transform(s)
@@ -254,35 +290,35 @@ module Sequel
 
         # The key to use for the key hash when eager loading
         def eager_loader_key
-          self[:eager_loader_key] ||= self[:key]
+          cached_fetch(:eager_loader_key){self[:key]}
         end
     
         # The column(s) in the associated table that the key in the current table references (either a symbol or an array).
         def primary_key
-         self[:primary_key] ||= associated_class.primary_key
+         cached_fetch(:primary_key){associated_class.primary_key}
         end
        
         # The columns in the associated table that the key in the current table references (always an array).
         def primary_keys
-         self[:primary_keys] ||= Array(primary_key)
+         cached_fetch(:primary_keys){Array(primary_key)}
         end
         alias associated_object_keys primary_keys
 
         # The method symbol or array of method symbols to call on the associated object
         # to get the value to use for the foreign keys.
         def primary_key_method
-         self[:primary_key_method] ||= primary_key
+         cached_fetch(:primary_key_method){primary_key}
         end
        
         # The array of method symbols to call on the associated object
         # to get the value to use for the foreign keys.
         def primary_key_methods
-         self[:primary_key_methods] ||= Array(primary_key_method)
+         cached_fetch(:primary_key_methods){Array(primary_key_method)}
         end
        
         # #primary_key qualified by the associated table
         def qualified_primary_key
-          self[:qualified_primary_key] ||= self[:qualify] == false ? primary_key : qualify_assoc(primary_key)
+          cached_fetch(:qualified_primary_key){self[:qualify] == false ? primary_key : qualify_assoc(primary_key)}
         end
         
         # True only if the reciprocal is a one_to_many association.
@@ -299,7 +335,7 @@ module Sequel
         # True only if the reciprocal is a one_to_one association.
         def set_reciprocal_to_self?
           reciprocal
-          self[:reciprocal_type] == :one_to_one
+          reciprocal_type == :one_to_one
         end
     
         private
@@ -307,7 +343,7 @@ module Sequel
         # The reciprocal type of a many_to_one association is either
         # a one_to_many or a one_to_one association.
         def reciprocal_type
-          self[:reciprocal_type] ||= [:one_to_many, :one_to_one]
+          cached_fetch(:reciprocal_type){[:one_to_many, :one_to_one]}
         end
       end
     
@@ -333,12 +369,12 @@ module Sequel
         
         # The key to use for the key hash when eager loading
         def eager_loader_key
-          self[:eager_loader_key] ||= primary_key
+          cached_fetch(:eager_loader_key){primary_key}
         end
 
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
         def eager_loading_predicate_key
-          self[:eager_loading_predicate_key] ||= qualify_assoc(self[:key])
+          cached_fetch(:eager_loading_predicate_key){qualify_assoc(self[:key])}
         end
         alias qualified_key eager_loading_predicate_key
     
@@ -349,7 +385,7 @@ module Sequel
 
         # #primary_key qualified by the current table
         def qualified_primary_key
-          self[:qualified_primary_key] ||= qualify_cur(primary_key)
+          cached_fetch(:qualified_primary_key){qualify_cur(primary_key)}
         end
       
         # Whether the reciprocal of this association returns an array of objects instead of a single object,
@@ -387,8 +423,8 @@ module Sequel
         # one_to_one associations don't use an eager limit strategy by default, but
         # support both DISTINCT ON and window functions as strategies.
         def eager_limit_strategy
-          fetch(:_eager_limit_strategy) do
-            self[:_eager_limit_strategy] = case s = self[:eager_limit_strategy]
+          cached_fetch(:_eager_limit_strategy) do
+            case s = self[:eager_limit_strategy]
             when Symbol
               s
             when true
@@ -464,19 +500,19 @@ module Sequel
       
         # The key to use for the key hash when eager loading
         def eager_loader_key
-          self[:eager_loader_key] ||= self[:left_primary_key]
+          cached_fetch(:eager_loader_key){self[:left_primary_key]}
         end
     
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3)).
         # The left key qualified by the join table.
         def eager_loading_predicate_key
-          self[:eager_loading_predicate_key] ||= qualify(join_table_alias, self[:left_key])
+          cached_fetch(:eager_loading_predicate_key){qualify(join_table_alias, self[:left_key])}
         end
         alias qualified_left_key eager_loading_predicate_key
 
         # The right key qualified by the join table.
         def qualified_right_key
-          self[:qualified_right_key] ||= qualify(join_table_alias, self[:right_key])
+          cached_fetch(:qualified_right_key){qualify(join_table_alias, self[:right_key])}
         end
     
         # many_to_many associations need to select a key in an associated table to eagerly load
@@ -487,18 +523,15 @@ module Sequel
         # The source of the join table.  This is the join table itself, unless it
         # is aliased, in which case it is the unaliased part.
         def join_table_source
-          fetch(:join_table_source) do
-            split_join_table_alias
-            self[:join_table_source]
-          end
+          cached_fetch(:join_table_source){split_join_table_alias[0]}
         end
 
         # The join table itself, unless it is aliased, in which case this
         # is the alias.
         def join_table_alias
-          fetch(:join_table_alias) do
-            split_join_table_alias
-            self[:join_table_alias]
+          cached_fetch(:join_table_alias) do
+            s, a = split_join_table_alias
+            a || s
           end
         end
         alias associated_key_table join_table_alias
@@ -511,60 +544,60 @@ module Sequel
     
         # Returns the reciprocal association symbol, if one exists.
         def reciprocal
-          return self[:reciprocal] if include?(:reciprocal)
-          left_keys = self[:left_keys]
-          right_keys = self[:right_keys]
-          join_table = self[:join_table]
-          associated_class.all_association_reflections.each do |assoc_reflect|
-            if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_keys] == right_keys &&
-               assoc_reflect[:right_keys] == left_keys && assoc_reflect[:join_table] == join_table &&
-               assoc_reflect.associated_class == self[:model]
-              return self[:reciprocal] = assoc_reflect[:name]
+          cached_fetch(:reciprocal) do
+            left_keys = self[:left_keys]
+            right_keys = self[:right_keys]
+            join_table = self[:join_table]
+            recip = nil
+            associated_class.all_association_reflections.each do |assoc_reflect|
+              if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_keys] == right_keys &&
+                 assoc_reflect[:right_keys] == left_keys && assoc_reflect[:join_table] == join_table &&
+                 assoc_reflect.associated_class == self[:model]
+                recip = assoc_reflect[:name]
+                break
+              end
             end
+            recip
           end
-          self[:reciprocal] = nil
         end
 
         # #right_primary_key qualified by the associated table
         def qualified_right_primary_key
-          self[:qualified_right_primary_key] ||= qualify_assoc(right_primary_key)
+          cached_fetch(:qualified_right_primary_key){qualify_assoc(right_primary_key)}
         end
     
         # The primary key column(s) to use in the associated table (can be symbol or array).
         def right_primary_key
-          self[:right_primary_key] ||= associated_class.primary_key
+          cached_fetch(:right_primary_key){associated_class.primary_key}
         end
         
         # The primary key columns to use in the associated table (always array).
         def right_primary_keys
-          self[:right_primary_keys] ||= Array(right_primary_key)
+          cached_fetch(:right_primary_keys){Array(right_primary_key)}
         end
     
         # The method symbol or array of method symbols to call on the associated objects
         # to get the foreign key values for the join table. 
         def right_primary_key_method
-          self[:right_primary_key_method] ||= right_primary_key
+          cached_fetch(:right_primary_key_method){right_primary_key}
         end
 
         # The array of method symbols to call on the associated objects
         # to get the foreign key values for the join table. 
         def right_primary_key_methods
-          self[:right_primary_key_methods] ||= Array(right_primary_key_method)
+          cached_fetch(:right_primary_key_methods){Array(right_primary_key_method)}
         end
         
         # The columns to select when loading the association, associated_class.table_name.* by default.
         def select
-         return self[:select] if include?(:select)
-         self[:select] ||= Sequel::SQL::ColumnAll.new(associated_class.table_name)
+         cached_fetch(:select){Sequel::SQL::ColumnAll.new(associated_class.table_name)}
         end
 
         private
 
         # Split the join table into source and alias parts.
         def split_join_table_alias
-          s, a = associated_class.dataset.split_alias(self[:join_table])
-          self[:join_table_source] = s
-          self[:join_table_alias] = a || s
+          associated_class.dataset.split_alias(self[:join_table])
         end
       end
   
@@ -862,7 +895,7 @@ module Sequel
           # dup early so we don't modify opts
           orig_opts = opts.dup
           orig_opts = association_reflection(opts[:clone])[:orig_opts].merge(orig_opts) if opts[:clone]
-          opts = orig_opts.merge(:type => type, :name => name, :cache => true, :model => self)
+          opts = orig_opts.merge(:type => type, :name => name, :cache=>{}, :model => self)
           opts[:block] = block if block
           opts = assoc_class.new.merge!(opts)
           opts[:eager_block] = block unless opts.include?(:eager_block)
@@ -878,6 +911,9 @@ module Sequel
           end
           late_binding_class_option(opts, opts.returns_array? ? singularize(name) : name)
           
+          # Remove :class entry if it exists and is nil, to work with cached_fetch
+          opts.delete(:class) unless opts[:class]
+          
           send(:"def_#{type}", opts)
       
           orig_opts.delete(:clone)
@@ -1047,20 +1083,9 @@ module Sequel
           def_association_method(opts)
         end
 
-        # Adds the association method to the association methods module. Be backwards
-        # compatible with ruby 1.8.6, which doesn't support blocks taking block arguments.
-        if RUBY_VERSION >= '1.8.7'
-          class_eval <<-END, __FILE__, __LINE__+1
-            def def_association_method(opts)
-              association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
-            end
-          END
-        else
-          class_eval <<-END, __FILE__, __LINE__+1
-            def def_association_method(opts)
-              association_module_def(opts.association_method, opts){|*dynamic_opts| load_associated_objects(opts, dynamic_opts[0])}
-            end
-          END
+        # Adds the association method to the association methods module.
+        def def_association_method(opts)
+          association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
         end
       
         # Configures many_to_many association reflection and adds the related association methods