sequel 2.5.0 → 2.6.0

data/spec/integration/schema_test.rb

@@ -1,21 +1,19 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe "Database schema parser" do
-  before do
-    INTEGRATION_DB.create_table!(:items){integer :number}
-    clear_sqls
-  end
   after do
     INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
   end
 
   specify "should be a hash with table_names as symbols" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
     schema = INTEGRATION_DB.schema(nil, :reload=>true)
     schema.should be_a_kind_of(Hash)
     schema.should include(:items)
   end
 
   specify "should not issue an sql query if the schema has been loaded unless :reload is true" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
     INTEGRATION_DB.schema(nil, :reload=>true)
     clear_sqls
     INTEGRATION_DB.schema
@@ -23,6 +21,7 @@ describe "Database schema parser" do
   end
 
   specify "should give the same result for a single table regardless of whether schema was called for a single table" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true).should == INTEGRATION_DB.schema(nil, :reload=>true)[:items]
   end
 
@@ -42,6 +41,31 @@ describe "Database schema parser" do
     INTEGRATION_DB.schema(:items)
     sqls_should_be
   end
+
+  specify "should parse primary keys from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == []
+    INTEGRATION_DB.create_table!(:items){primary_key :number}
+    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number]
+    INTEGRATION_DB.create_table!(:items){integer :number1; integer :number2; primary_key [:number1, :number2]}
+    INTEGRATION_DB.schema(:items).collect{|k,v| k if v[:primary_key]}.compact.should == [:number1, :number2]
+  end
+
+  specify "should parse NULL/NOT NULL from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){integer :number, :null=>true}
+    INTEGRATION_DB.schema(:items).first.last[:allow_null].should == true
+    INTEGRATION_DB.create_table!(:items){integer :number, :null=>false}
+    INTEGRATION_DB.schema(:items).first.last[:allow_null].should == false
+  end
+
+  specify "should parse defaults from the schema properly" do
+    INTEGRATION_DB.create_table!(:items){integer :number}
+    INTEGRATION_DB.schema(:items).first.last[:default].should == nil
+    INTEGRATION_DB.create_table!(:items){integer :number, :default=>0}
+    INTEGRATION_DB.schema(:items).first.last[:default].to_s.should == "0"
+    INTEGRATION_DB.create_table!(:items){varchar :a, :default=>"blah", :size=>4}
+    INTEGRATION_DB.schema(:items).first.last[:default].gsub(/::character varying\z/, '').gsub("'", '').should == "blah"
+  end
 end
 
 describe "Database schema modifiers" do

data/spec/sequel_core/core_sql_spec.rb

@@ -30,10 +30,13 @@ context "Array#case and Hash#case" do
 
   specify "should return SQL CASE expression" do
     @d.literal({:x=>:y}.case(:z)).should == '(CASE WHEN x THEN y ELSE z END)'
+    @d.literal({:x=>:y}.case(:z, :exp)).should == '(CASE exp WHEN x THEN y ELSE z END)'
     ['(CASE WHEN x THEN y WHEN a THEN b ELSE z END)',
      '(CASE WHEN a THEN b WHEN x THEN y ELSE z END)'].should(include(@d.literal({:x=>:y, :a=>:b}.case(:z))))
     @d.literal([[:x, :y]].case(:z)).should == '(CASE WHEN x THEN y ELSE z END)'
     @d.literal([[:x, :y], [:a, :b]].case(:z)).should == '(CASE WHEN x THEN y WHEN a THEN b ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp)).should == '(CASE exp WHEN x THEN y WHEN a THEN b ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp__w)).should == '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
   end
 
   specify "should raise an error if an array that isn't all two pairs is used" do

data/spec/sequel_core/database_spec.rb

@@ -1015,3 +1015,27 @@ context "Database#raise_error" do
     proc{MockDatabase.new.send(:raise_error, Interrupt.new(''))}.should raise_error(Sequel::DatabaseError)
   end
 end
+
+context "Database#typecast_value" do
+  setup do
+    @db = Sequel::Database.new(1 => 2, :logger => 3)
+  end
+  specify "should raise InvalidValue when setting invalid integer" do
+    proc{@db.typecast_value(:integer, "13a")}.should raise_error(Sequel::Error::InvalidValue)
+  end
+  specify "should raise InvalidValue when setting invalid float" do
+    proc{@db.typecast_value(:float, "4.e2")}.should raise_error(Sequel::Error::InvalidValue)
+  end
+  specify "should raise InvalidValue when setting invalid decimal" do
+    proc{@db.typecast_value(:decimal, :invalid_value)}.should raise_error(Sequel::Error::InvalidValue)
+  end
+  specify "should raise InvalidValue when setting invalid date" do
+    proc{@db.typecast_value(:date, Object.new)}.should raise_error(Sequel::Error::InvalidValue)
+  end
+  specify "should raise InvalidValue when setting invalid time" do
+    proc{@db.typecast_value(:time, Date.new)}.should raise_error(Sequel::Error::InvalidValue)
+  end
+  specify "should raise InvalidValue when setting invalid datetime" do
+    proc{@db.typecast_value(:datetime, 4)}.should raise_error(Sequel::Error::InvalidValue)
+  end
+end

data/spec/sequel_core/dataset_spec.rb

@@ -558,7 +558,7 @@ context "a grouped dataset" do
   specify "should format the right statement for counting (as a subquery)" do
     db = MockDatabase.new
     db[:test].select(:name).group(:name).count
-    db.sqls.should == ["SELECT COUNT(*) FROM (SELECT name FROM test GROUP BY name) t1 LIMIT 1"]
+    db.sqls.should == ["SELECT COUNT(*) FROM (SELECT name FROM test GROUP BY name) AS t1 LIMIT 1"]
   end
 end
 
@@ -684,37 +684,34 @@ context "Dataset#from" do
 
   specify "should format a Dataset as a subquery if it has had options set" do
     @dataset.from(@dataset.from(:a).where(:a=>1)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a WHERE (a = 1)) t1"
+      "SELECT * FROM (SELECT * FROM a WHERE (a = 1)) AS t1"
   end
   
   specify "should automatically alias sub-queries" do
     @dataset.from(@dataset.from(:a).group(:b)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a GROUP BY b) t1"
+      "SELECT * FROM (SELECT * FROM a GROUP BY b) AS t1"
       
     d1 = @dataset.from(:a).group(:b)
     d2 = @dataset.from(:c).group(:d)
     
     @dataset.from(d1, d2).sql.should == 
-      "SELECT * FROM (SELECT * FROM a GROUP BY b) t1, (SELECT * FROM c GROUP BY d) t2"
+      "SELECT * FROM (SELECT * FROM a GROUP BY b) AS t1, (SELECT * FROM c GROUP BY d) AS t2"
   end
   
   specify "should accept a hash for aliasing" do
     @dataset.from(:a => :b).sql.should ==
-      "SELECT * FROM a b"
+      "SELECT * FROM a AS b"
       
     @dataset.from(:a => 'b').sql.should ==
-      "SELECT * FROM a b"
-
-    @dataset.from(:a => :c[:d]).sql.should ==
-      "SELECT * FROM a c(d)"
+      "SELECT * FROM a AS b"
 
     @dataset.from(@dataset.from(:a).group(:b) => :c).sql.should ==
-      "SELECT * FROM (SELECT * FROM a GROUP BY b) c"
+      "SELECT * FROM (SELECT * FROM a GROUP BY b) AS c"
   end
 
   specify "should always use a subquery if given a dataset" do
     @dataset.from(@dataset.from(:a)).select_sql.should ==
-      "SELECT * FROM (SELECT * FROM a) t1"
+      "SELECT * FROM (SELECT * FROM a) AS t1"
   end
   
   specify "should raise if no source is given" do
@@ -985,7 +982,7 @@ context "Dataset#limit" do
   specify "should work with fixed sql datasets" do
     @dataset.opts[:sql] = 'select * from cccc'
     @dataset.limit(6, 10).sql.should ==
-      'SELECT * FROM (select * from cccc) t1 LIMIT 6 OFFSET 10'
+      'SELECT * FROM (select * from cccc) AS t1 LIMIT 6 OFFSET 10'
   end
   
   specify "should raise an error if an invalid limit or offset is used" do
@@ -1102,7 +1099,7 @@ context "Dataset#uniq" do
 
   specify "should do a subselect for count" do
     @dataset.uniq.count
-    @db.sqls.should == ['SELECT COUNT(*) FROM (SELECT DISTINCT name FROM test) t1 LIMIT 1']
+    @db.sqls.should == ['SELECT COUNT(*) FROM (SELECT DISTINCT name FROM test) AS t1 LIMIT 1']
   end
 end
 
@@ -1138,12 +1135,12 @@ context "Dataset#count" do
   specify "should count properly for datasets with fixed sql" do
     @dataset.opts[:sql] = "select abc from xyz"
     @dataset.count.should == 1
-    @c.sql.should == "SELECT COUNT(*) FROM (select abc from xyz) t1 LIMIT 1"
+    @c.sql.should == "SELECT COUNT(*) FROM (select abc from xyz) AS t1 LIMIT 1"
   end
 
   specify "should return limit if count is greater than it" do
     @dataset.limit(5).count.should == 1
-    @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test LIMIT 5) t1 LIMIT 1"
+    @c.sql.should == "SELECT COUNT(*) FROM (SELECT * FROM test LIMIT 5) AS t1 LIMIT 1"
   end
   
   it "should work on a graphed_dataset" do
@@ -1284,7 +1281,7 @@ context "Dataset#join_table" do
     ds = MockDataset.new(nil).from(:foo => :f)
     ds.quote_identifiers = true
     ds.join_table(:inner, :bar, :id => :bar_id).sql.should ==
-      'SELECT * FROM "foo" "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
+      'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
   end
   
   specify "should allow for arbitrary conditions in the JOIN clause" do
@@ -2162,7 +2159,7 @@ context "A paginated dataset" do
   specify "should work with fixed sql" do
     ds = @d.clone(:sql => 'select * from blah')
     ds.meta_def(:count) {150}
-    ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) t1 LIMIT 50 OFFSET 50'
+    ds.paginate(2, 50).sql.should == 'SELECT * FROM (select * from blah) AS t1 LIMIT 50 OFFSET 50'
   end
 end
 
@@ -2322,6 +2319,17 @@ context "Dataset#multi_insert" do
     ]
   end
   
+  specify "should accept string keys as column names" do
+    @ds.multi_insert([{'x'=>1, 'y'=>2}, {'x'=>3, 'y'=>4}])
+    @ds.multi_insert(['x', 'y'], [[1, 2], [3, 4]])
+    @db.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT'
+    ] * 2
+  end
+
   specify "should accept a columns array and a values array" do
     @ds.multi_insert([:x, :y], [[1, 2], [3, 4]])
     @db.sqls.should == [

data/spec/sequel_core/schema_spec.rb

@@ -244,7 +244,7 @@ context "DB#create_table" do
       text :name
       unique :name
     end
-    @db.sqls.should == ["CREATE TABLE cats (name text, UNIQUE (name))", "CREATE UNIQUE INDEX cats_name_index ON cats (name)"]
+    @db.sqls.should == ["CREATE TABLE cats (name text, UNIQUE (name))"]
   end
 
   specify "should raise on full-text index definitions" do
@@ -331,6 +331,13 @@ context "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (CHECK (price < 100))"]
   end
 
+  specify "should accept hash constraints" do
+    @db.create_table(:cats) do
+      check :price=>100
+    end
+    @db.sqls.should == ["CREATE TABLE cats (CHECK (price = 100))"]
+  end
+
   specify "should accept named constraint definitions" do
     @db.create_table(:cats) do
       integer :score
@@ -459,6 +466,20 @@ context "DB#alter_table" do
   setup do
     @db = SchemaDummyDatabase.new
   end
+  
+  specify "should allow adding not null constraint" do
+    @db.alter_table(:cats) do
+      set_column_allow_null :score, false
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score SET NOT NULL"]
+  end
+  
+  specify "should allow droping not null constraint" do
+    @db.alter_table(:cats) do
+      set_column_allow_null :score, true
+    end
+    @db.sqls.should == ["ALTER TABLE cats ALTER COLUMN score DROP NOT NULL"]
+  end
 
   specify "should support add_column" do
     @db.alter_table(:cats) do
@@ -598,44 +619,54 @@ end
 
 context "Schema Parser" do
   setup do
-    sqls = @sqls = []
+    @sqls = []
     @db = Sequel::Database.new
-    @db.meta_def(:dataset) do
-      ds = super()
-      ds.instance_variable_set(:@sqls, sqls)
-      def ds.fetch_rows(sql)
-        @sqls << sql
-        table = /'(.*)'/.match(sql)[1]
-        h = {:column=>"a", :db_type=>table, :max_chars=>nil, :numeric_precision=>nil, :default=>'', :allow_null=>'YES'}
-        (h[:column] = h[:table_name] = :x) if sql =~ /BASE TABLE/
-        yield h
-      end
-      ds
-    end
   end
   after do
     Sequel.convert_tinyint_to_bool = true
   end
 
   specify "should parse the schema correctly for a single table" do
-    @db.schema(:x).should == [[:a, {:type=>nil, :db_type=>"x", :max_chars=>nil, :numeric_precision=>nil, :default=>nil, :allow_null=>true}]]
-    @sqls.should == ["SELECT column_name AS column, data_type AS db_type, character_maximum_length AS max_chars, numeric_precision, column_default AS default, is_nullable AS allow_null FROM information_schema.tables AS t INNER JOIN information_schema.columns AS c USING (table_catalog, table_schema, table_name) WHERE (c.table_name = 'x')"]
-    @db.schema(:x).should == [[:a, {:type=>nil, :db_type=>"x", :max_chars=>nil, :numeric_precision=>nil, :default=>nil, :allow_null=>true}]]
-    @sqls.length.should == 1
-    @db.schema(:x, :reload=>true).should == [[:a, {:type=>nil, :db_type=>"x", :max_chars=>nil, :numeric_precision=>nil, :default=>nil, :allow_null=>true}]]
-    @sqls.length.should == 2
+    sqls = @sqls
+    proc{@db.schema(:x)}.should raise_error(Sequel::Error)
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      sqls << t
+      [[:a, {:db_type=>t.to_s}]]
+    end
+    @db.schema(:x).should == [[:a, {:db_type=>"x"}]]
+    @sqls.should == [:x]
+    @db.schema(:x).should == [[:a, {:db_type=>"x"}]]
+    @sqls.should == [:x]
+    @db.schema(:x, :reload=>true).should == [[:a, {:db_type=>"x"}]]
+    @sqls.should == [:x, :x]
   end
 
   specify "should parse the schema correctly for all tables" do
-    @db.schema.should == {:x=>[[:x, {:type=>nil, :db_type=>"BASE TABLE", :max_chars=>nil, :numeric_precision=>nil, :default=>nil, :allow_null=>true}]]}
-    @sqls.should == ["SELECT column_name AS column, data_type AS db_type, character_maximum_length AS max_chars, numeric_precision, column_default AS default, is_nullable AS allow_null, c.table_name FROM information_schema.tables AS t INNER JOIN information_schema.columns AS c USING (table_catalog, table_schema, table_name) WHERE (t.table_type = 'BASE TABLE')"]
-    @db.schema.should == {:x=>[[:x, {:type=>nil, :db_type=>"BASE TABLE", :max_chars=>nil, :numeric_precision=>nil, :default=>nil, :allow_null=>true}]]}
-    @sqls.length.should == 1
-    @db.schema(nil, :reload=>true).should == {:x=>[[:x, {:type=>nil, :db_type=>"BASE TABLE", :max_chars=>nil, :numeric_precision=>nil, :default=>nil, :allow_null=>true}]]}
-    @sqls.length.should == 2
+    sqls = @sqls
+    proc{@db.schema}.should raise_error(Sequel::Error)
+    @db.meta_def(:tables){[:x]}
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      sqls << t
+      [[:x, {:db_type=>t.to_s}]]
+    end
+    @db.schema.should == {:x=>[[:x, {:db_type=>"x"}]]}
+    @sqls.should == [:x]
+    @db.schema.should == {:x=>[[:x, {:db_type=>"x"}]]}
+    @sqls.should == [:x]
+    @db.schema(nil, :reload=>true).should == {:x=>[[:x, {:db_type=>"x"}]]}
+    @sqls.should == [:x, :x]
+    @db.meta_def(:schema_parse_tables) do |opts|
+      sqls << 1
+      {:x=>[[:a, {:db_type=>"1"}]]}
+    end
+    @db.schema(nil, :reload=>true).should == {:x=>[[:a, {:db_type=>"1"}]]}
+    @sqls.should == [:x, :x, 1]
   end
 
   specify "should correctly parse all supported data types" do
+    @db.meta_def(:schema_parse_table) do |t, opts|
+      [[:x, {:type=>schema_column_type(t.to_s)}]]
+    end
     @db.schema(:tinyint).first.last[:type].should == :boolean
     Sequel.convert_tinyint_to_bool = false
     @db.schema(:tinyint, :reload=>true).first.last[:type].should == :integer
@@ -646,6 +677,7 @@ context "Schema Parser" do
     @db.schema(:character).first.last[:type].should == :string
     @db.schema(:"character varying").first.last[:type].should == :string
     @db.schema(:varchar).first.last[:type].should == :string
+    @db.schema(:"varchar(255)").first.last[:type].should == :string
     @db.schema(:text).first.last[:type].should == :string
     @db.schema(:date).first.last[:type].should == :date
     @db.schema(:datetime).first.last[:type].should == :datetime

data/spec/sequel_model/eager_loading_spec.rb

@@ -638,6 +638,37 @@ describe Sequel::Model, "#eager_graph" do
     a.album.band.members.first.values.should == {:id => 5}
   end
   
+  it "should allow cascading of eager loading for multiple *_to_many associations, eliminating duplicates caused by cartesian products" do
+    ds = GraphBand.eager_graph({:albums=>:tracks}, :members)
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, albums.id AS albums_id, albums.band_id, tracks.id AS tracks_id, tracks.album_id, members.id AS members_id FROM bands LEFT OUTER JOIN albums ON (albums.band_id = bands.id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>4, :album_id=>3, :members_id=>5})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>4, :album_id=>3, :members_id=>6})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>5, :album_id=>3, :members_id=>5})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>5, :album_id=>3, :members_id=>6})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>4, :band_id=>1, :tracks_id=>6, :album_id=>4, :members_id=>5})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>4, :band_id=>1, :tracks_id=>6, :album_id=>4, :members_id=>6})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>4, :band_id=>1, :tracks_id=>7, :album_id=>4, :members_id=>5})
+      yield({:id=>1, :vocalist_id=>2, :albums_id=>4, :band_id=>1, :tracks_id=>7, :album_id=>4, :members_id=>6})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>5, :band_id=>2, :tracks_id=>8, :album_id=>5, :members_id=>5})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>5, :band_id=>2, :tracks_id=>8, :album_id=>5, :members_id=>6})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>5, :band_id=>2, :tracks_id=>9, :album_id=>5, :members_id=>5})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>5, :band_id=>2, :tracks_id=>9, :album_id=>5, :members_id=>6})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>1, :album_id=>6, :members_id=>5})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>1, :album_id=>6, :members_id=>6})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>2, :album_id=>6, :members_id=>5})
+      yield({:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>2, :album_id=>6, :members_id=>6})
+    end
+    a = ds.all
+    a.should == [GraphBand.load(:id=>1, :vocalist_id=>2), GraphBand.load(:id=>2, :vocalist_id=>2)]
+    members = a.map{|x| x.members}
+    members.should == [[GraphBandMember.load(:id=>5), GraphBandMember.load(:id=>6)], [GraphBandMember.load(:id=>5), GraphBandMember.load(:id=>6)]]
+    albums = a.map{|x| x.albums}
+    albums.should == [[GraphAlbum.load(:id=>3, :band_id=>1), GraphAlbum.load(:id=>4, :band_id=>1)], [GraphAlbum.load(:id=>5, :band_id=>2), GraphAlbum.load(:id=>6, :band_id=>2)]]
+    tracks = albums.map{|x| x.map{|y| y.tracks}}
+    tracks.should == [[[GraphTrack.load(:id=>4, :album_id=>3), GraphTrack.load(:id=>5, :album_id=>3)], [GraphTrack.load(:id=>6, :album_id=>4), GraphTrack.load(:id=>7, :album_id=>4)]], [[GraphTrack.load(:id=>8, :album_id=>5), GraphTrack.load(:id=>9, :album_id=>5)], [GraphTrack.load(:id=>1, :album_id=>6), GraphTrack.load(:id=>2, :album_id=>6)]]]
+  end
+  
   it "should populate the reciprocal many_to_one association when eagerly loading the one_to_many association" do
     MODEL_DB.reset
     ds = GraphAlbum.eager_graph(:tracks)
@@ -961,4 +992,38 @@ describe Sequel::Model, "#eager_graph" do
   it "should create unique table aliases for all associations" do
     GraphAlbum.eager_graph(:previous_album=>{:previous_album=>:previous_album}).sql.should == "SELECT albums.id, albums.band_id, previous_album.id AS previous_album_id, previous_album.band_id AS previous_album_band_id, previous_album_0.id AS previous_album_0_id, previous_album_0.band_id AS previous_album_0_band_id, previous_album_1.id AS previous_album_1_id, previous_album_1.band_id AS previous_album_1_band_id FROM albums LEFT OUTER JOIN albums AS previous_album ON (previous_album.id = albums.previous_album_id) LEFT OUTER JOIN albums AS previous_album_0 ON (previous_album_0.id = previous_album.previous_album_id) LEFT OUTER JOIN albums AS previous_album_1 ON (previous_album_1.id = previous_album_0.previous_album_id)"
   end
+
+  it "should respect the association's :order" do
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id]
+    GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY right_tracks.id, right_tracks.album_id'
+  end
+
+  it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:blah__id.identifier, :blah__id.identifier.desc, :blah__id.desc, :blah__id, :album_id, :album_id.desc, 1, 'RANDOM()'.lit, :a.qualify(:b)]
+    GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY right_tracks.blah__id, right_tracks.blah__id DESC, blah.id DESC, blah.id, right_tracks.album_id, right_tracks.album_id DESC, 1, RANDOM(), b.a'
+  end
+
+  it "should not respect the association's :order if :order_eager_graph is false" do
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id], :order_eager_graph=>false
+    GraphAlbum.eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id)'
+  end
+
+  it "should add the association's :order to the existing order" do
+    GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id]
+    GraphAlbum.order(:band_id).eager_graph(:right_tracks).sql.should == 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.id) ORDER BY band_id, right_tracks.id, right_tracks.album_id'
+  end
+
+  it "should add the association's :order for cascading associations" do
+    GraphBand.one_to_many :a_albums, :class=>'GraphAlbum', :key=>:band_id, :order=>:name
+    GraphAlbum.one_to_many :b_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id]
+    GraphBand.eager_graph(:a_albums=>:b_tracks).sql.should == 'SELECT bands.id, bands.vocalist_id, a_albums.id AS a_albums_id, a_albums.band_id, b_tracks.id AS b_tracks_id, b_tracks.album_id FROM bands LEFT OUTER JOIN albums AS a_albums ON (a_albums.band_id = bands.id) LEFT OUTER JOIN tracks AS b_tracks ON (b_tracks.album_id = a_albums.id) ORDER BY a_albums.name, b_tracks.id, b_tracks.album_id'
+    GraphAlbum.one_to_many :albums, :class=>'GraphAlbum', :key=>:band_id, :order=>[:band_id, :id]
+    GraphAlbum.eager_graph(:albums=>{:albums=>:albums}).sql.should == 'SELECT albums.id, albums.band_id, albums_0.id AS albums_0_id, albums_0.band_id AS albums_0_band_id, albums_1.id AS albums_1_id, albums_1.band_id AS albums_1_band_id, albums_2.id AS albums_2_id, albums_2.band_id AS albums_2_band_id FROM albums LEFT OUTER JOIN albums AS albums_0 ON (albums_0.band_id = albums.id) LEFT OUTER JOIN albums AS albums_1 ON (albums_1.band_id = albums_0.id) LEFT OUTER JOIN albums AS albums_2 ON (albums_2.band_id = albums_1.id) ORDER BY albums_0.band_id, albums_0.id, albums_1.band_id, albums_1.id, albums_2.band_id, albums_2.id'
+  end
+
+  it "should add the associations :order for multiple associations" do
+    GraphAlbum.many_to_many :a_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :order=>:id
+    GraphAlbum.one_to_many :b_tracks, :class=>'GraphTrack', :key=>:album_id, :order=>[:id, :album_id]
+    GraphAlbum.eager_graph(:a_genres, :b_tracks).sql.should == 'SELECT albums.id, albums.band_id, a_genres.id AS a_genres_id, b_tracks.id AS b_tracks_id, b_tracks.album_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS a_genres ON (a_genres.id = ag.genre_id) LEFT OUTER JOIN tracks AS b_tracks ON (b_tracks.album_id = albums.id) ORDER BY a_genres.id, b_tracks.id, b_tracks.album_id'
+  end
 end

data/spec/sequel_model/hooks_spec.rb

@@ -305,7 +305,7 @@ describe "Model#before_destroy && Model#after_destroy" do
   
   specify "should be called around record destruction" do
     @c.before_destroy {MODEL_DB << "BLAH before"}
-    m = @c.new(:id => 2233)
+    m = @c.load(:id => 2233)
     m.destroy
     MODEL_DB.sqls.should == [
       'BLAH before',

data/spec/sequel_model/model_spec.rb

@@ -171,6 +171,7 @@ describe Sequel::Model, "new" do
   before(:each) do
     @m = Class.new(Sequel::Model) do
       set_dataset MODEL_DB[:items]
+      columns :x, :id
     end
   end