sequel 3.21.0 → 3.24.0

data/spec/extensions/columns_introspection_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "Sequel::Dataset.introspect_all_columns" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    class Sequel::Dataset
+      # Handle case where introspect_all_columns has already been called
+      alias columns columns_without_introspection unless instance_methods(false).map{|x| x.to_s}.include?('columns')
+    end
+    Sequel::Dataset.introspect_all_columns
+    @db.reset
+  end
+  after do
+    class Sequel::Dataset
+      alias columns columns_without_introspection
+    end
+  end
+
+  specify "should turn on column introspection by default" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+end
+
+describe "columns_introspection extension" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
+    @db.reset
+  end
+
+  specify "should not issue a database query if the columns are already loaded" do
+    @ds.instance_variable_set(:@columns, [:x])
+    @ds.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+  
+  specify "should handle plain symbols without a database query" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified symbols without a database query" do
+    @ds.select(:t__x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle aliased symbols without a database query" do
+    @ds.select(:x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified and aliased symbols without a database query" do
+    @ds.select(:t__x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::Identifiers " do
+    @ds.select(:x.identifier).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers" do
+    @ds.select(:x.qualify(:t)).columns.should == [:x]
+    @ds.select(:x.identifier.qualify(:t)).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::AliasedExpressions" do
+    @ds.select(:x.as(:a)).columns.should == [:a]
+    @ds.select(:x.as(:a.identifier)).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should issue a database query if the wildcard is selected" do
+    @ds.columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should issue a database query if an unsupported type is used" do
+    @ds.select(1).columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should not have column introspection on by default" do
+    @db[:a].select(:x).columns
+    @db.sqls.length.should == 1
+  end
+end

data/spec/extensions/defaults_setter_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::DefaultsSetter" do
+  before do
+    @db = db = Sequel::Database.new
+    @c = c = Class.new(Sequel::Model(db[:foo]))
+    @c.instance_variable_set(:@db_schema, {:a=>{}})
+    @c.plugin :defaults_setter
+    @c.columns :a
+    @pr = proc{|x| db.meta_def(:schema){|*| [[:a, {:ruby_default => x}]]}; c.dataset = c.dataset; c}
+  end
+
+  it "should set default value upon initialization" do
+    @pr.call(2).new.values.should == {:a=>2}
+  end
+
+  it "should not mark the column as modified" do
+    @pr.call(2).new.changed_columns.should == []
+  end
+
+  it "should not set a default of nil" do
+    @pr.call(nil).new.values.should == {}
+  end
+
+  it "should not override a given value" do
+    @pr.call(2)
+    @c.new('a'=>3).values.should == {:a=>3}
+    @c.new('a'=>nil).values.should == {:a=>nil}
+  end
+
+  it "should work correctly when subclassing" do
+    Class.new(@pr.call(2)).new.values.should == {:a=>2}
+  end
+
+  it "should contain the default values in default_values" do
+    @pr.call(2).default_values.should == {:a=>2}
+    @pr.call(nil).default_values.should == {}
+  end
+
+  it "should allow modifications of default values" do
+    @pr.call(2)
+    @c.default_values[:a] = 3
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should allow proc default values" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{3}
+    @c.new.values.should == {:a => 3}
+  end
+
+  it "should have procs that set default values set them to nil" do
+    @pr.call(2)
+    @c.default_values[:a] = proc{nil}
+    @c.new.values.should == {:a => nil}
+  end
+
+  it "should work correctly on a model without a dataset" do
+    @pr.call(2)
+    c = Class.new(Sequel::Model(@db[:bar]))
+    c.plugin :defaults_setter
+    c.default_values.should == {:a=>2}
+  end
+end

data/spec/extensions/many_through_many_spec.rb

@@ -8,6 +8,7 @@ describe Sequel::Model, "many_through_many" do
       plugin :many_through_many
     end
     class ::Tag < Sequel::Model
+      columns :id, :h1, :h2
     end
     MODEL_DB.reset
     @c1 = Artist
@@ -111,6 +112,82 @@ describe Sequel::Model, "many_through_many" do
     n.tags.should == [@c2.load(:id=>1)]
   end
   
+  it "should allowing filtering by many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id = 1234) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many associations with a single through table" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists WHERE ((albums_artists.album_id = 1234) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many associations with aliased tables" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :id, :id], [:albums_artists, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.id = albums_artists.album_id) INNER JOIN albums_artists AS albums_artists_1 ON (albums_artists_1.album_id = albums_artists_0.id) WHERE ((albums_artists_1.tag_id = 1234) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>@c2.load(:h1=>1234, :h2=>85)).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE ((albums_tags.g1 = 1234) AND (albums_tags.g2 = 85) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL))))'
+  end
+
+  it "should allowing excluding by many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.exclude(:tags=>@c2.load(:id=>1234)).sql.should == 'SELECT * FROM artists WHERE ((id NOT IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id = 1234) AND (albums_artists.artist_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should allowing excluding by many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.exclude(:tags=>@c2.load(:h1=>1234, :h2=>85)).sql.should == 'SELECT * FROM artists WHERE (((id, yyy) NOT IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE ((albums_tags.g1 = 1234) AND (albums_tags.g2 = 85) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL)))) OR (id IS NULL) OR (yyy IS NULL))'
+  end
+
+  it "should allowing filtering by multiple many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>[@c2.load(:id=>1234), @c2.load(:id=>2345)]).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (1234, 2345)) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by multiple many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>[@c2.load(:h1=>1234, :h2=>85), @c2.load(:h1=>2345, :h2=>95)]).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN ((1234, 85), (2345, 95))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL))))'
+  end
+
+  it "should allowing excluding by multiple many_through_many associations" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.exclude(:tags=>[@c2.load(:id=>1234), @c2.load(:id=>2345)]).sql.should == 'SELECT * FROM artists WHERE ((id NOT IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (1234, 2345)) AND (albums_artists.artist_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should allowing excluding by multiple many_through_many associations with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.exclude(:tags=>[@c2.load(:h1=>1234, :h2=>85), @c2.load(:h1=>2345, :h2=>95)]).sql.should == 'SELECT * FROM artists WHERE (((id, yyy) NOT IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN ((1234, 85), (2345, 95))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL)))) OR (id IS NULL) OR (yyy IS NULL))'
+  end
+
+  it "should allowing filtering/excluding many_through_many associations with NULL values" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.new).sql.should == 'SELECT * FROM artists WHERE \'f\''
+    @c1.exclude(:tags=>@c2.new).sql.should == 'SELECT * FROM artists WHERE \'t\''
+  end
+
+  it "should allowing filtering by many_through_many association datasets" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.filter(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE (id IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (albums_artists.artist_id IS NOT NULL))))'
+  end
+
+  it "should allowing filtering by many_through_many association datasets with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.filter(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE ((id, yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN (SELECT h1, h2 FROM tags WHERE ((x = 1) AND (h1 IS NOT NULL) AND (h2 IS NOT NULL)))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL))))'
+  end
+
+  it "should allowing excluding by many_through_many association datasets" do
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+    @c1.exclude(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE ((id NOT IN (SELECT albums_artists.artist_id FROM albums_artists INNER JOIN albums ON (albums.id = albums_artists.album_id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) WHERE ((albums_tags.tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (albums_artists.artist_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should allowing excluding by many_through_many association datasets with composite keys" do
+    @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
+    @c1.exclude(:tags=>@c2.filter(:x=>1)).sql.should == 'SELECT * FROM artists WHERE (((id, yyy) NOT IN (SELECT albums_artists.b1, albums_artists.b2 FROM albums_artists INNER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) INNER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) WHERE (((albums_tags.g1, albums_tags.g2) IN (SELECT h1, h2 FROM tags WHERE ((x = 1) AND (h1 IS NOT NULL) AND (h2 IS NOT NULL)))) AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL)))) OR (id IS NULL) OR (yyy IS NULL))'
+  end
+
   it "should support a :conditions option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:a=>32}
     n = @c1.load(:id => 1234)

data/spec/extensions/migration_spec.rb

@@ -202,7 +202,7 @@ describe "Sequel::IntegerMigrator" do
         @drops = []
         @tables_created = []
         @columns_created = []
-        @versions = {}
+        @versions = Hash.new{|h,k| h[k.to_sym]}
       end
   
       def version; versions.values.first || 0; end
@@ -212,7 +212,7 @@ describe "Sequel::IntegerMigrator" do
       def create_table(name, opts={}, &block)
         super
         @columns_created << / \(?(\w+) integer.*\)?\z/.match(sqls.last)[1].to_sym
-        @tables_created << name
+        @tables_created << name.to_sym
       end
       
       def dataset(opts={})
@@ -228,7 +228,7 @@ describe "Sequel::IntegerMigrator" do
       end
 
       def table_exists?(name)
-        @tables_created.include?(name)
+        @tables_created.include?(name.to_sym)
       end
     end
     @db = dbc.new
@@ -250,7 +250,7 @@ describe "Sequel::IntegerMigrator" do
 
   specify "should add a column name if it doesn't already exist in the schema_info table" do
     @db.create_table(:schema_info){Integer :v}
-    @db.should_receive(:alter_table).with(:schema_info)
+    @db.should_receive(:alter_table).with('schema_info')
     Sequel::Migrator.apply(@db, @dirname)
   end
 
@@ -320,45 +320,45 @@ describe "Sequel::TimestampMigrator" do
     @dsc = dsc = Class.new(MockDataset) do
       def columns
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           [:version]
-        when :schema_migrations
+        when :schema_migrations, 'schema_migrations'
           [:filename]
-        when :sm
+        when :sm, 'sm'
           [:fn]
         end
       end
 
       def fetch_rows(sql)
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           yield({:version=>$sequel_migration_version})
-        when :schema_migrations
+        when :schema_migrations, 'schema_migrations'
           $sequel_migration_files.sort.each{|f| yield(:filename=>f)}
-        when :sm
+        when :sm, 'sm'
           $sequel_migration_files.sort.each{|f| yield(:fn=>f)}
         end
       end
 
       def insert(h={})
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           $sequel_migration_version = h.values.first
-        when :schema_migrations, :sm
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
           $sequel_migration_files << h.values.first
         end
       end
 
       def update(h={})
         case opts[:from].first
-        when :schema_info
+        when :schema_info, 'schema_info'
           $sequel_migration_version = h.values.first
         end
       end
 
       def delete
         case opts[:from].first
-        when :schema_migrations, :sm
+        when :schema_migrations, :sm, 'schema_migrations', 'sm'
           $sequel_migration_files.delete(opts[:where].args.last)
         end
       end
@@ -366,9 +366,9 @@ describe "Sequel::TimestampMigrator" do
     dbc = Class.new(MockDatabase) do
       tables = {}
       define_method(:dataset){|*a| dsc.new(self, *a)}
-      define_method(:create_table){|name, *args| tables[name] = true}
-      define_method(:drop_table){|*names| names.each{|n| tables.delete(n)}}
-      define_method(:table_exists?){|name| tables.has_key?(name)}
+      define_method(:create_table){|name, *args| tables[name.to_sym] = true}
+      define_method(:drop_table){|*names| names.each{|n| tables.delete(n.to_sym)}}
+      define_method(:table_exists?){|name| tables.has_key?(name.to_sym)}
     end
     @db = dbc.new
     @m = Sequel::Migrator

data/spec/extensions/nested_attributes_spec.rb

@@ -13,6 +13,7 @@ describe "NestedAttributes plugin" do
         mods << [:i, first_source, h, x]
         x
       end
+      define_method(:supports_insert_select?){true}
       define_method(:insert_select) do |h|
         x = ii.call
         mods << [:is, first_source, h, x]

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -0,0 +1,126 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::AssociationPks" do
+  before do
+    @db = MODEL_DB.clone
+    mod = Module.new do
+      def fetch_rows(sql)
+        db << (is_a?(Sequel::Dataset::PreparedStatementMethods) ? :prepared : :regular)
+        db << sql
+      end
+    end
+    @db.meta_def(:dataset) do |*opts|
+      ds = super(*opts)
+      ds.extend mod
+      ds
+    end
+    def @db.transaction(opts)
+      execute('BEGIN')
+      yield
+      execute('COMMIT')
+    end
+    @Artist = Class.new(Sequel::Model(@db[:artists]))
+    @Artist.columns :id, :id2
+    @Album= Class.new(Sequel::Model(@db[:albums]))
+    @Album.columns :id, :artist_id, :id2, :artist_id2
+    @Tag = Class.new(Sequel::Model(@db[:tags]))
+    @Tag.columns :id, :id2
+    @Artist.plugin :prepared_statements_associations
+    @Album.plugin :prepared_statements_associations
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @db.reset
+  end
+
+  specify "should run correct SQL for associations" do
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:prepared, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2).artist
+    @db.sqls.should == [:prepared, "SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2).tags
+    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1))"]
+    @db.reset
+
+    @Artist.load(:id=>1).tags
+    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.artist_id = 1))"]
+  end
+
+  specify "should run correct SQL for composite key associations" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>[:album_id, :album_id2], :right_key=>[:tag_id, :tag_id2], :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id, :artist_id2], [:id, :id2]], [:albums_tags, [:album_id, :album_id2], [:tag_id, :tag_id2]]], :class=>@Tag, :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+
+    @Artist.load(:id=>1, :id2=>2).albums
+    @db.sqls.should == [:prepared, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2))"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2, :artist_id2=>3).artist
+    @db.sqls.should == [:prepared, "SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1"]
+    @db.reset
+
+    @Album.load(:id=>1, :artist_id=>2, :id2=>3).tags
+    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2) AND (albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3))"]
+    @db.reset
+
+    @Artist.load(:id=>1, :id2=>2).tags
+    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2) AND (albums.artist_id = 1) AND (albums.artist_id2 = 2))"]
+  end
+
+  specify "should not run query if no objects can be associated" do
+    @Artist.new.albums.should == []
+    @Album.new.artist.should == nil
+    @db.sqls.should == []
+  end
+
+  specify "should run a regular query if there is a callback" do
+    @Artist.load(:id=>1).albums(proc{|ds| ds})
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :prepared_statement=>false option is used for the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :prepared_statement=>false
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if unrecognized association is used" do
+    a = @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    a[:type] = :foo
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if a block is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id do |ds| ds end
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :conditions option is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+
+  specify "should run a regular query if :dataset option is used when defining the association" do
+    album = @Album
+    @Artist.one_to_many :albums, :class=>@Album, :dataset=>proc{album.filter(:artist_id=>id)} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :cloning an association that doesn't used prepared statements" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.one_to_many :oalbums, :clone=>:albums
+    @Artist.load(:id=>1).oalbums
+    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements_safe plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people))
+    @c.columns :id, :name, :i
+    @ds = ds = @c.dataset
+    @c.instance_variable_set(:@db_schema, {:i=>{}, :name=>{}, :id=>{:primary_key=>true}})
+    def ds.fetch_rows(sql)
+      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
+      super{|h|}
+      yield(:id=>1, :name=>'foo', :i=>2)
+    end
+    def ds.update(*)
+      db << default_server_opts(opts)[:server]
+      super
+    end
+    def ds.insert(*)
+      db << default_server_opts(opts)[:server]
+      super
+      1
+    end
+    @c.plugin :prepared_statements_safe
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @c.db.execute 'foo'
+    @sqls = @c.db.sqls
+    @sqls.clear
+  end
+
+  specify "should load the prepared_statements plugin" do
+    @c.plugins.should include(Sequel::Plugins::PreparedStatements)
+  end
+
+  specify "should set default values correctly" do
+    @c.prepared_statements_column_defaults.should == {:name=>nil, :i=>nil}
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    Class.new(@c).prepared_statements_column_defaults.should == {:name=>'foo'}
+  end
+
+  specify "should set default values when creating" do
+    @c.create
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \(NULL, NULL\)/
+    @sqls.clear
+    @c.create(:name=>'foo')
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((NULL|'foo'), (NULL|'foo')\)/
+    @sqls.clear
+    @c.create(:name=>'foo', :i=>2)
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+  end 
+
+  specify "should use database default values" do
+    @c.instance_variable_set(:@db_schema, {:i=>{:ruby_default=>2}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    c = Class.new(@c)
+    c.create
+    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+  end
+
+  specify "should not set defaults for unparseable dataset default values" do
+    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
+    c = Class.new(@c)
+    c.create
+    @sqls[1].should == "INSERT INTO people (name) VALUES ('foo')"
+  end
+
+  specify "should save all fields when updating" do
+    @p.update(:i=>3)
+    @sqls[1].should =~ /UPDATE people SET (name = 'foo'|i = 3), (name = 'foo'|i = 3) WHERE \(id = 1\)/
+  end
+end

data/spec/extensions/prepared_statements_spec.rb

@@ -0,0 +1,72 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people))
+    @c.columns :id, :name, :i
+    @ds = ds = @c.dataset
+    def ds.fetch_rows(sql)
+      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
+      super{|h|}
+      yield(:id=>1, :name=>'foo', :i=>2)
+    end
+    def ds.update(*)
+      db << default_server_opts(opts)[:server]
+      super
+    end
+    def ds.insert(*)
+      db << default_server_opts(opts)[:server]
+      super
+      1
+    end
+    def ds.delete(*)
+      db << default_server_opts(opts)[:server]
+      super
+    end
+    @c.plugin :prepared_statements
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @c.db.execute 'foo'
+    @sqls = @c.db.sqls
+    @sqls.clear
+  end
+
+  specify "should correctly lookup by primary key" do
+    @c[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+  end 
+
+  specify "should correctly delete instance" do
+    @p.destroy.should == @p
+    @sqls.should == [:default, "DELETE FROM people WHERE (id = 1)"]
+  end
+
+  specify "should correctly update instance" do
+    @p.update(:name=>'bar').should == @c.load(:id=>1, :name=>'bar', :i => 2)
+    @sqls.should == [:default, "UPDATE people SET name = 'bar' WHERE (id = 1)"]
+  end
+
+  specify "should correctly create instance" do
+    @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)
+    @sqls.should == [:default, "INSERT INTO people (name) VALUES ('foo')", :default, "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+  end
+
+  specify "should correctly create instance if dataset supports insert_select" do
+    def @ds.supports_insert_select?
+      true
+    end
+    def @ds.insert_select(h)
+      return {:id=>1, :name=>'foo', :i => 2}
+    end
+    def @ds.insert_sql(*)
+      "#{super}#{' RETURNING *' if opts.has_key?(:returning)}"
+    end
+    @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)
+    @sqls.should == [:default, "INSERT INTO people (name) VALUES ('foo') RETURNING *"]
+  end
+
+  specify "should work correctly when subclassing" do
+    c = Class.new(@c)
+    c[1].should == c.load(:id=>1, :name=>'foo', :i=>2)
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+  end 
+end

data/spec/extensions/prepared_statements_with_pk_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements_with_pk plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people))
+    @c.columns :id, :name, :i
+    @ds = ds = @c.dataset
+    def ds.fetch_rows(sql)
+      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
+      super{|h|}
+      yield(:id=>1, :name=>'foo', :i=>2)
+    end
+    @c.plugin :prepared_statements_with_pk
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @c.db.execute 'foo'
+    @sqls = @c.db.sqls
+    @sqls.clear
+  end
+
+  specify "should load the prepared_statements plugin" do
+    @c.plugins.should include(Sequel::Plugins::PreparedStatements)
+  end
+
+  specify "should correctly lookup by primary key from dataset" do
+    @c.dataset.filter(:name=>'foo')[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((name = 'foo') AND (id = 1)) LIMIT 1"]
+  end
+
+  specify "should still work correctly if there are multiple conflicting variables" do
+    @c.dataset.filter(:name=>'foo').or(:name=>'bar')[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (id = 1)) LIMIT 1"]
+  end
+
+  specify "should still work correctly if the primary key is used elsewhere in the query" do
+    @c.dataset.filter{id > 2}[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((id > 2) AND (id = 1)) LIMIT 1"]
+  end
+end