sequel 4.7.0 → 4.8.0

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -59,10 +59,18 @@ module Sequel
     #
     #   # Set up class table inheritance in the parent class
     #   # (Not in the subclasses)
-    #   Employee.plugin :class_table_inheritance
+    #   class Employee < Sequel::Model
+    #     plugin :class_table_inheritance
+    #   end
     #
-    #   # Set the +kind+ column to hold the class name, and
-    #   # set the subclass table to map to for each subclass 
+    #   # Have subclasses inherit from the appropriate class
+    #   class Staff < Employee; end
+    #   class Manager < Employee; end
+    #   class Executive < Manager; end
+    #
+    #   # You can also set options when loading the plugin:
+    #   # :kind :: column to hold the class name
+    #   # :table_map :: map of class name symbols to table name symbols
     #   Employee.plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
     module ClassTableInheritance
       # The class_table_inheritance plugin requires the lazy_attributes plugin

data/lib/sequel/plugins/dataset_associations.rb

@@ -17,12 +17,10 @@ module Sequel
     #   #   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
+    # including ones implemented in other plugins.  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.
+    # dataset association. However, it will only work for limited associations or
+    # *_one associations with orders if the database supports window functions.
     #
     # As the dataset methods return datasets, you can easily chain the
     # methods to get associated datasets of associated datasets:
@@ -66,10 +64,9 @@ module Sequel
         # 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.
+        # This supports most options that are supported when eager loading.  However, it
+        # will only work for limited associations or *_one associations with orders if the
+        # database supports window functions.
         def associated(name)
           raise Error, "unrecognized association name: #{name.inspect}" unless r = model.association_reflection(name)
           ds = r.associated_class.dataset
@@ -78,17 +75,23 @@ module Sequel
           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
+            r.send(:apply_filter_by_associations_limit_strategy, ds.filter(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
+          when :many_to_many, :one_through_one
+            mds = r.associated_class.dataset.
+              join(r[:join_table], r[:right_keys].zip(r.right_primary_keys)).
+              select(*Array(r.qualified_right_key)).
+              where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
+            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+          when :many_through_many, :one_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)
+            edges << r.final_edge
+            mds = model.
+              select(*Array(r.qualify(fre[:table], fre[:left]))).
+              join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name).
+              where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
+            edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
+            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
             ds.filter(Sequel.expr(r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}))
           when :many_to_pg_array

data/lib/sequel/plugins/many_through_many.rb

@@ -1,6 +1,6 @@
 module Sequel
   module Plugins
-    # The many_through_many plugin allow you to create an association to multiple objects using multiple join tables.
+    # The many_through_many plugin allow you to create an association using multiple join tables.
     # For example, assume the following associations:
     #
     #    Artist.many_to_many :albums
@@ -65,11 +65,28 @@ module Sequel
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]],
     #    :distinct=>true
+    # 
+    # In addition to many_through_many, this plugin also adds one_through_many, for an association to a single object through multiple join tables.
+    # This is useful if there are unique constraints on the foreign keys in the join tables that reference back to the current table, or if you want
+    # to set an order on the association and just want the first record.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support many_through_many associations
+    #   Sequel::Model.plugin :many_through_many
+    #
+    #   # Make the Album class support many_through_many associations
+    #   Album.plugin :many_through_many
     module ManyThroughMany
       # The AssociationReflection subclass for many_through_many associations.
       class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
         Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
 
+        # many_through_many and one_through_many associations can be clones
+        def cloneable?(ref)
+          ref[:type] == :many_through_many || ref[:type] == :one_through_many
+        end
+
         # The default associated key alias(es) to use when eager loading
         # associations via eager.
         def default_associated_key_alias
@@ -142,9 +159,28 @@ module Sequel
         def filter_by_associations_add_conditions_dataset_filter(ds)
           reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
           ft = final_reverse_edge
+          k = qualify(ft[:alias], Array(self[:left_key]))
           ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep).
-            select(*qualify(ft[:alias], Array(self[:left_key])))
+            where(Sequel.negate(k.zip([]))).
+            select(*k)
         end
+
+        def filter_by_associations_limit_key
+          fe = edges.first
+          Array(qualify(fe[:table], fe[:right])) + Array(qualify(associated_class.table_name, associated_class.primary_key))
+        end
+
+        def filter_by_associations_limit_subquery
+          subquery = associated_eager_dataset.unlimited
+          reverse_edges.each{|t| subquery = subquery.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
+          ft = final_reverse_edge
+          subquery.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep)
+        end
+      end
+
+      class OneThroughManyAssociationReflection < ManyThroughManyAssociationReflection
+        Sequel::Model::Associations::ASSOCIATION_TYPES[:one_through_many] = self
+        include Sequel::Model::Associations::SingularAssociationReflection
       end
 
       module ClassMethods
@@ -168,15 +204,21 @@ module Sequel
           associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
         end
 
+        # Creates a one_through_many association.  See many_through_many for arguments.
+        def one_through_many(name, through, opts=OPTS, &block)
+          associate(:one_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
+        end
+
         private
 
         # Create the association methods and :eager_loader and :eager_grapher procs.
         def def_many_through_many(opts)
+          one_through_many = opts[:type] == :one_through_many
           name = opts[:name]
           model = self
           opts[:read_only] = true
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
-          opts[:cartesian_product_number] ||= 2
+          opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
           opts[:through] = opts[:through].map do |e|
             case e
             when Array
@@ -197,7 +239,7 @@ module Sequel
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           left_pks = opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
-          opts[:left_primary_key_columns] ||= Array(lpkc)
+          lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
           opts[:dataset] ||= lambda do
             ds = opts.associated_dataset
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
@@ -210,30 +252,36 @@ module Sequel
           opts[:eager_loader] ||= lambda do |eo|
             h = eo[:id_map]
             rows = eo[:rows]
-            rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
             ft = opts.final_reverse_edge
+
             ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.predicate_key, h.keys]], :table_alias=>ft[:alias], :qualify=>:deep)
             ds = model.eager_loading_dataset(opts, ds, nil, eo[:associations], eo)
-            if opts.eager_limit_strategy == :window_function
-              delete_rn = true
-              rn = ds.row_number_column
-              ds = apply_window_function_eager_limit_strategy(ds, opts)
-            end
+            ds = opts.apply_eager_limit_strategy(ds)
+            opts.initialize_association_cache(rows)
+
+            assign_singular = opts.assign_singular?
+            delete_rn = opts.delete_row_number_column(ds)
             ds.all do |assoc_record|
-              assoc_record.values.delete(rn) if delete_rn
+              assoc_record.values.delete(delete_rn) if delete_rn
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
                 assoc_record.values.delete(left_key_alias)
               end
               next unless objects = h[hash_key]
-              objects.each{|object| object.associations[name].push(assoc_record)}
-            end
-            if opts.eager_limit_strategy == :ruby
-              rows.each{|o| o.associations[name] = o.associations[name][slice_range] || []}
+              if assign_singular
+                objects.each do |object|
+                  object.associations[name] ||= assoc_record
+                end
+              else
+                objects.each do |object|
+                  object.associations[name].push(assoc_record)
+                end
+              end
             end
+            opts.apply_ruby_eager_limit_strategy(rows)
           end
 
           join_type = opts[:graph_join_type]
@@ -245,16 +293,34 @@ module Sequel
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
             iq = eo[:implicit_qualifier]
-            opts.edges.each do |t|
-              ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :qualify=>:deep, :implicit_qualifier=>iq, &t[:block])
-              iq = nil
+            egls = eo[:limit_strategy]
+            if egls && egls != :ruby
+              associated_key_array = opts.associated_key_array
+              orig_egds = egds = eager_graph_dataset(opts, eo)
+              opts.reverse_edges.each{|t| egds = egds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
+              ft = opts.final_reverse_edge
+              egds = egds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep).
+                select_all(egds.first_source).
+                select_append(*associated_key_array)
+              egds = opts.apply_eager_graph_limit_strategy(egls, egds)
+              ds.graph(egds, associated_key_array.map{|v| v.alias}.zip(Array(lpkcs)) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>iq, :join_type=>eo[:join_type]||join_type, :from_self_alias=>eo[:from_self_alias], :select=>select||orig_egds.columns, &graph_block)
+            else
+              opts.edges.each do |t|
+                ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>eo[:join_type]||t[:join_type], :qualify=>:deep, :implicit_qualifier=>iq, :from_self_alias=>eo[:from_self_alias], &t[:block])
+                iq = nil
+              end
+              fe = opts.final_edge
+              ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, &graph_block)
             end
-            fe = opts.final_edge
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>join_type, &graph_block)
           end
 
           def_association_dataset_methods(opts)
         end
+
+        # Use def_many_through_many, since they share pretty much the same code.
+        def def_one_through_many(opts)
+          def_many_through_many(opts)
+        end
       end
 
       module DatasetMethods
@@ -291,6 +357,7 @@ module Sequel
 
           association_filter_handle_inversion(op, expr, Array(lpks))
         end
+        alias one_through_many_association_filter_expression many_through_many_association_filter_expression
       end
     end
   end

data/lib/sequel/plugins/nested_attributes.rb

@@ -286,7 +286,19 @@ module Sequel
         def validate_associated_object(reflection, obj)
           return if reflection[:validate] == false
           association = reflection[:name]
+          if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !obj.values[key]
+            # There could be a presence validation on the foreign key in the associated model,
+            # which will fail if we validate before saving the current object.  If there is
+            # no value for the foreign key, set it to the current primary key value, or a dummy
+            # value of 0 if we haven't saved the current object.
+            obj.values[key] = pk || 0
+            key = nil if pk
+          end
           obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
+          if key
+            # If we used a dummy value of 0, remove it so it doesn't accidently remain.
+            obj.values.delete(key)
+          end
         end
       end
     end

data/lib/sequel/plugins/pg_array_associations.rb

@@ -95,6 +95,18 @@ module Sequel
           :"#{underscore(demodulize(self[:model].name))}_ids"
         end
         
+        # Always use the ruby eager_graph limit strategy if association is limited.
+        def eager_graph_limit_strategy(_)
+          :ruby if self[:limit]
+        end
+
+        # Always use the ruby eager limit strategy
+        def eager_limit_strategy
+          cached_fetch(:_eager_limit_strategy) do
+            :ruby if self[:limit]
+          end
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false.
         def handle_silent_modification_failure?
           self[:raise_on_save_failure] == false
@@ -166,6 +178,18 @@ module Sequel
           :"#{singularize(self[:name])}_ids"
         end
 
+        # Always use the ruby eager_graph limit strategy if association is limited.
+        def eager_graph_limit_strategy(_)
+          :ruby if self[:limit]
+        end
+
+        # Always use the ruby eager limit strategy
+        def eager_limit_strategy
+          cached_fetch(:_eager_limit_strategy) do
+            :ruby if self[:limit]
+          end
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false
         # and save_after_modify is true.
         def handle_silent_modification_failure?
@@ -247,9 +271,7 @@ module Sequel
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
             rows = eo[:rows]
-            rows.each do |object|
-              object.associations[name] = []
-            end
+            opts.initialize_association_cache(rows)
 
             klass = opts.associated_class
             ds = model.eager_loading_dataset(opts, klass.where(Sequel.pg_array_op(opts.predicate_key).overlaps(id_map.keys)), nil, eo[:associations], eo)
@@ -263,9 +285,7 @@ module Sequel
                 end
               end
             end
-            if slice_range
-              rows.each{|o| o.associations[name] = o.associations[name][slice_range] || []}
-            end
+            opts.apply_ruby_eager_limit_strategy(rows)
           end
 
           join_type = opts[:graph_join_type]
@@ -292,7 +312,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>join_type, :qualify=>:deep, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
             ds
           end
 
@@ -348,8 +368,9 @@ module Sequel
             rows = eo[:rows]
             id_map = {}
             pkm = opts.primary_key_method
+            opts.initialize_association_cache(rows)
+
             rows.each do |object|
-              object.associations[name] = []
               if associated_pks = object.send(key)
                 associated_pks.each do |apk|
                   (id_map[apk] ||= []) << object
@@ -366,9 +387,7 @@ module Sequel
                 end
               end
             end
-            if slice_range
-              rows.each{|o| o.associations[name] = o.associations[name][slice_range] || []}
-            end
+            opts.apply_ruby_eager_limit_strategy(rows)
           end
 
           join_type = opts[:graph_join_type]
@@ -395,7 +414,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>join_type, :qualify=>:deep, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
             ds
           end
 

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -24,7 +24,15 @@ module Sequel
     #
     #   # Use the default of storing the class name in the sti_key
     #   # column (:kind in this case)
-    #   Employee.plugin :single_table_inheritance, :kind
+    #   class Employee < Sequel::Model
+    #     plugin :single_table_inheritance, :kind
+    #   end
+    #
+    #   # Have subclasses inherit from the appropriate class
+    #   class Staff < Employee; end
+    #   class Manager < Employee; end
+    #
+    #   # You can also use many different options to configure the plugin:
     #
     #   # Using integers to store the class type, with a :model_map hash
     #   # and an sti_key of :type

data/lib/sequel/sql.rb

@@ -935,6 +935,7 @@ module Sequel
       # The alias to use for the expression, not +alias+ since that is
       # a keyword in ruby.
       attr_reader :aliaz
+      alias_method :alias, :aliaz
 
       # Create an object with the given expression and alias.
       def initialize(expression, aliaz)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 7
+  MINOR = 8
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -16,12 +16,12 @@ describe "A MSSQL database" do
     @db = DB
   end
 
-  cspecify "should be able to read fractional part of timestamp", :odbc do
+  specify "should be able to read fractional part of timestamp" do
     rs = @db["select getutcdate() as full_date, cast(datepart(millisecond, getutcdate()) as int) as milliseconds"].first
     rs[:milliseconds].should == rs[:full_date].usec/1000
   end
 
-  cspecify "should be able to write fractional part of timestamp", :odbc do
+  specify "should be able to write fractional part of timestamp" do
     t = Time.utc(2001, 12, 31, 23, 59, 59, 997000)
     (t.usec/1000).should == @db["select cast(datepart(millisecond, ?) as int) as milliseconds", t].get
   end

data/spec/adapters/postgres_spec.rb

@@ -850,6 +850,13 @@ describe "A PostgreSQL database" do
 
     @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
+
+    @db[:posts].insert(:title=>'jruby rubinius ruby maglev mri iron')
+    @db[:posts].insert(:title=>'ruby jruby maglev mri rubinius iron')
+    @db[:posts].full_text_search(:title, 'rubinius ruby', :phrase=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron']
+    @db[:posts].full_text_search(:title, 'jruby maglev', :phrase=>true).select_order_map(:title).should == ['ruby jruby maglev mri rubinius iron']
+    @db[:posts].full_text_search(:title, 'rubinius ruby', :plain=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
+    @db[:posts].full_text_search(:title, 'jruby maglev', :plain=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
   end
 
   specify "should support spatial indexes" do