sequel_core 2.0.1 → 2.1.0

data/spec/database_spec.rb

@@ -23,7 +23,7 @@ context "A new Database" do
   end
   
   specify "should create a connection pool" do
-    @db.pool.should be_a_kind_of(ConnectionPool)
+    @db.pool.should be_a_kind_of(Sequel::ConnectionPool)
     @db.pool.max_size.should == 4
     
     Sequel::Database.new(:max_connections => 10).pool.max_size.should == 10
@@ -645,24 +645,24 @@ context "A single threaded database" do
   
   specify "should use a SingleThreadedPool instead of a ConnectionPool" do
     db = Sequel::Database.new(:single_threaded => true)
-    db.pool.should be_a_kind_of(SingleThreadedPool)
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
   end
   
   specify "should be constructable using :single_threaded => true option" do
     db = Sequel::Database.new(:single_threaded => true)
-    db.pool.should be_a_kind_of(SingleThreadedPool)
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
   end
   
   specify "should be constructable using Database.single_threaded = true" do
     Sequel::Database.single_threaded = true
     db = Sequel::Database.new
-    db.pool.should be_a_kind_of(SingleThreadedPool)
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
   end
 
   specify "should be constructable using Sequel.single_threaded = true" do
     Sequel.single_threaded = true
     db = Sequel::Database.new
-    db.pool.should be_a_kind_of(SingleThreadedPool)
+    db.pool.should be_a_kind_of(Sequel::SingleThreadedPool)
   end
 end
 

data/spec/dataset_spec.rb

@@ -317,7 +317,6 @@ context "Dataset#where" do
   end
   
   specify "should accept a subquery" do
-    # select all countries that have GDP greater than the average for Asia
     @dataset.filter('gdp > ?', @d1.select(:avg[:gdp])).sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
 
@@ -364,18 +363,22 @@ context "Dataset#where" do
       "SELECT * FROM test WHERE ((c LIKE 'ABC%') OR (c LIKE '%XYZ'))"
   end
   
-  specify "should raise if receiving a single boolean value" do
-    # the result of erroneous use of comparison not in a block
-    # so instead of filter{:x == y} someone writes filter(:x == y)
-    
-    proc {@dataset.filter(:a == 1)}.should raise_error(Sequel::Error::InvalidFilter)
-    proc {@dataset.filter(:a != 1)}.should raise_error(Sequel::Error::InvalidFilter)
-  end
-
   specify "should work for grouped datasets" do
     @dataset.group(:a).filter(:b => 1).sql.should ==
       'SELECT * FROM test WHERE (b = 1) GROUP BY a'
   end
+
+  specify "should accept true and false as arguments" do
+    @dataset.filter(true).sql.should ==
+      "SELECT * FROM test WHERE 't'"
+    @dataset.filter(false).sql.should ==
+      "SELECT * FROM test WHERE 'f'"
+  end
+
+  pt_specify "should allow the use of blocks and arguments simultaneously" do
+    @dataset.filter(:zz < 3){:yy > 3}.sql.should ==
+      'SELECT * FROM test WHERE ((zz < 3) AND (yy > 3))'
+  end
 end
 
 context "Dataset#or" do
@@ -412,6 +415,11 @@ context "Dataset#or" do
     @d1.or(:y => 2).filter(:z => 3).sql.should == 
       'SELECT * FROM test WHERE (((x = 1) OR (y = 2)) AND (z = 3))'
   end
+
+  pt_specify "should allow the use of blocks and arguments simultaneously" do
+    @d1.or(:zz < 3){:yy > 3}.sql.should ==
+      'SELECT * FROM test WHERE ((x = 1) OR ((zz < 3) AND (yy > 3)))'
+  end
 end
 
 context "Dataset#and" do
@@ -486,9 +494,14 @@ context "Dataset#exclude" do
   end
   
   pt_specify "should support proc expressions" do
-    @dataset.exclude {:id == (6...12)}.sql.should == 
+    @dataset.exclude{:id == (6...12)}.sql.should == 
       'SELECT * FROM test WHERE NOT (id >= 6 AND id < 12)'
   end
+  
+  pt_specify "should allow the use of blocks and arguments simultaneously" do
+    @dataset.exclude(:id => (7..11)){:id == (6...12)}.sql.should == 
+      'SELECT * FROM test WHERE (((id < 7) OR (id > 11)) OR NOT (id >= 6 AND id < 12))'
+  end
 end
 
 context "Dataset#invert" do
@@ -712,12 +725,6 @@ context "Dataset#from" do
     
     @dataset.from(:a[:i]).select_sql.should ==
       "SELECT * FROM a(i)"
-    
-    @dataset.from(:generate_series[1, 2].as(:a[:i])).select_sql.should ==
-      "SELECT * FROM generate_series(1, 2) AS a(i)"
-      
-    @dataset.from(:generate_series[1, 2] => :a[:i]).select_sql.should ==
-      "SELECT * FROM generate_series(1, 2) a(i)"
   end
 end
 
@@ -914,7 +921,7 @@ context "Dataset#reverse_order" do
   
   specify "should invert the order given" do
     @dataset.reverse_order(:name.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name'
+      'SELECT * FROM test ORDER BY name ASC'
   end
   
   specify "should invert the order for ASC expressions" do
@@ -924,14 +931,14 @@ context "Dataset#reverse_order" do
   
   specify "should accept multiple arguments" do
     @dataset.reverse_order(:name, :price.desc).sql.should ==
-      'SELECT * FROM test ORDER BY name DESC, price'
+      'SELECT * FROM test ORDER BY name DESC, price ASC'
   end
 
   specify "should reverse a previous ordering if no arguments are given" do
     @dataset.order(:name).reverse_order.sql.should ==
       'SELECT * FROM test ORDER BY name DESC'
     @dataset.order(:clumsy.desc, :fool).reverse_order.sql.should ==
-      'SELECT * FROM test ORDER BY clumsy, fool DESC'
+      'SELECT * FROM test ORDER BY clumsy ASC, fool DESC'
   end
   
   specify "should return an unordered dataset for a dataset with no order" do
@@ -1059,11 +1066,17 @@ context "Dataset#to_hash" do
     @d.to_hash(:a, :b).should == {1 => 2, 3 => 4, 5 => 6}
     @d.to_hash(:b, :a).should == {2 => 1, 4 => 3, 6 => 5}
   end
+  
+  specify "should provide a hash with the first column as key and the entire hash as value if the value column is blank or nil" do
+    @d.to_hash(:a).should == {1 => {:a => 1, :b => 2}, 3 => {:a => 3, :b => 4}, 5 => {:a => 5, :b => 6}}
+    @d.to_hash(:b).should == {2 => {:a => 1, :b => 2}, 4 => {:a => 3, :b => 4}, 6 => {:a => 5, :b => 6}}
+  end
 end
 
 context "Dataset#uniq" do
   setup do
-    @dataset = Sequel::Dataset.new(nil).from(:test).select(:name)
+    @db = MockDatabase.new
+    @dataset = @db[:test].select(:name)
   end
   
   specify "should include DISTINCT clause in statement" do
@@ -1079,6 +1092,11 @@ context "Dataset#uniq" do
 
     @dataset.uniq(:stamp.cast_as(:integer), :node_id).sql.should == 'SELECT DISTINCT ON (cast(stamp AS integer), node_id) name FROM test'
   end
+
+  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']
+  end
 end
 
 context "Dataset#count" do
@@ -1208,66 +1226,55 @@ context "Dataset#join_table" do
   end
   
   specify "should support multiple joins" do
-    @d.join_table(:inner, :b, :items_id).join_table(:left_outer, :c, :b_id => :b__id).sql.should ==
+    @d.join_table(:inner, :b, :items_id=>:id).join_table(:left_outer, :c, :b_id => :b__id).sql.should ==
       'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
   end
   
-  specify "should use id as implicit relation primary key if omitted" do
-    @d.join_table(:left_outer, :categories, :category_id).sql.should ==
-      @d.join_table(:left_outer, :categories, :category_id => :id).sql
-
-    # when doing multiple joins, id should be qualified using the last joined table
-    @d.join_table(:right_outer, :b, :items_id).join_table(:full_outer, :c, :b_id).sql.should ==
-      'SELECT * FROM "items" RIGHT OUTER JOIN "b" ON ("b"."items_id" = "items"."id") FULL OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
-  end
-  
   specify "should support left outer joins" do
-    @d.join_table(:left_outer, :categories, :category_id).sql.should ==
+    @d.join_table(:left_outer, :categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
 
-    @d.left_outer_join(:categories, :category_id).sql.should ==
+    @d.left_outer_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
 
   specify "should support right outer joins" do
-    @d.join_table(:right_outer, :categories, :category_id).sql.should ==
+    @d.join_table(:right_outer, :categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
 
-    @d.right_outer_join(:categories, :category_id).sql.should ==
+    @d.right_outer_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
 
   specify "should support full outer joins" do
-    @d.join_table(:full_outer, :categories, :category_id).sql.should ==
+    @d.join_table(:full_outer, :categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
 
-    @d.full_outer_join(:categories, :category_id).sql.should ==
+    @d.full_outer_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" FULL OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
 
   specify "should support inner joins" do
-    @d.join_table(:inner, :categories, :category_id).sql.should ==
+    @d.join_table(:inner, :categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
 
-    @d.inner_join(:categories, :category_id).sql.should ==
+    @d.inner_join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
   
-  specify "should default to an inner join" do
-    @d.join_table(nil, :categories, :category_id).sql.should ==
-      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+  specify "should default to a plain join if nil is used for the type" do
+    @d.join_table(nil, :categories, :category_id=>:id).sql.should ==
+      'SELECT * FROM "items"  JOIN "categories" ON ("categories"."category_id" = "items"."id")'
+  end
 
-    @d.join(:categories, :category_id).sql.should ==
+  specify "should use an inner join for Dataset#join" do
+    @d.join(:categories, :category_id=>:id).sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."category_id" = "items"."id")'
   end
   
-  specify "should raise if an invalid join type is specified" do
-    proc {@d.join_table(:invalid, :a, :b)}.should raise_error(Sequel::Error)
-  end
-  
   specify "should support aliased tables" do
     @d.from('stats').join('players', {:id => :player_id}, 'p').sql.should ==
-      'SELECT * FROM "stats" INNER JOIN "players" "p" ON ("p"."id" = "stats"."player_id")'
+      'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
 
     ds = MockDataset.new(nil).from(:foo => :f)
     ds.quote_identifiers = true
@@ -1295,23 +1302,30 @@ context "Dataset#join_table" do
     ds = Sequel::Dataset.new(nil).from(:categories)
     
     @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) "t1" ON ("t1"."item_id" = "items"."id")'
+      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "t1" ON ("t1"."item_id" = "items"."id")'
       
     ds.filter!(:active => true)
 
     @d.join_table(:left_outer, ds, :item_id => :id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active = \'t\')) "t1" ON ("t1"."item_id" = "items"."id")'
+      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories WHERE (active = \'t\')) AS "t1" ON ("t1"."item_id" = "items"."id")'
   end
-
+  
+  specify "should support joining datasets and aliasing the join" do
+    ds = Sequel::Dataset.new(nil).from(:categories)
+    
+    @d.join_table(:left_outer, ds, {:ds__item_id => :id}, :ds).sql.should ==
+      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "ds" ON ("ds"."item_id" = "items"."id")'      
+  end
+  
   specify "should support joining multiple datasets" do
     ds = Sequel::Dataset.new(nil).from(:categories)
     ds2 = Sequel::Dataset.new(nil).from(:nodes).select(:name)
     ds3 = Sequel::Dataset.new(nil).from(:attributes).filter("name = 'blah'")
 
     @d.join_table(:left_outer, ds, :item_id => :id).join_table(:inner, ds2, :node_id=>:id).join_table(:right_outer, ds3, :attribute_id=>:id).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) "t1" ON ("t1"."item_id" = "items"."id") ' \
-      'INNER JOIN (SELECT name FROM nodes) "t2" ON ("t2"."node_id" = "t1"."id") ' \
-      'RIGHT OUTER JOIN (SELECT * FROM attributes WHERE (name = \'blah\')) "t3" ON ("t3"."attribute_id" = "t2"."id")'
+      'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "t1" ON ("t1"."item_id" = "items"."id") ' \
+      'INNER JOIN (SELECT name FROM nodes) AS "t2" ON ("t2"."node_id" = "t1"."id") ' \
+      'RIGHT OUTER JOIN (SELECT * FROM attributes WHERE (name = \'blah\')) AS "t3" ON ("t3"."attribute_id" = "t2"."id")'
   end
 
   specify "should support joining objects that respond to :table_name" do
@@ -1321,6 +1335,104 @@ context "Dataset#join_table" do
     @d.join(ds, :item_id => :id).sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."item_id" = "items"."id")'
   end
+  
+  specify "should support using a SQL String as the join condition" do
+    @d.join(:categories, %{c.item_id = items.id}, :c).sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
+  end
+  
+  specify "should support using a boolean column as the join condition" do
+    @d.join(:categories, :active).sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" ON "active"'
+  end
+
+  specify "should support using an expression as the join condition" do
+    @d.join(:categories, :number > 10).sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" ON ("number" > 10)'
+  end
+
+  specify "should support natural and cross joins using nil" do
+    @d.join_table(:natural, :categories).sql.should ==
+      'SELECT * FROM "items" NATURAL JOIN "categories"'
+    @d.join_table(:cross, :categories, nil).sql.should ==
+      'SELECT * FROM "items" CROSS JOIN "categories"'
+    @d.join_table(:natural, :categories, nil, :c).sql.should ==
+      'SELECT * FROM "items" NATURAL JOIN "categories" AS "c"'
+  end
+
+  specify "should support joins with a USING clause if an array of symbols is used" do
+    @d.join(:categories, [:id]).sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" USING ("id")'
+    @d.join(:categories, [:id1, :id2]).sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" USING ("id1", "id2")'
+  end
+
+  specify "should raise an error if using an array of symbols with a block" do
+    proc{@d.join(:categories, [:id]){|j,lj,js|}}.should raise_error(Sequel::Error)
+  end
+
+  specify "should support using a block that receieves the join table/alias, last join table/alias, and array of previous joins" do
+    @d.join(:categories) do |join_alias, last_join_alias, joins| 
+      join_alias.should == :categories
+      last_join_alias.should == :items
+      joins.should == []
+    end
+
+    @d.from(:items=>:i).join(:categories, nil, :c) do |join_alias, last_join_alias, joins| 
+      join_alias.should == :c
+      last_join_alias.should == :i
+      joins.should == []
+    end
+
+    @d.from(:items___i).join(:categories, nil, :c) do |join_alias, last_join_alias, joins| 
+      join_alias.should == :c
+      last_join_alias.should == :i
+      joins.should == []
+    end
+
+    @d.join(:blah).join(:categories, nil, :c) do |join_alias, last_join_alias, joins| 
+      join_alias.should == :c
+      last_join_alias.should == :blah
+      joins.should be_a_kind_of(Array)
+      joins.length.should == 1
+      joins.first.should be_a_kind_of(Sequel::SQL::JoinClause)
+      joins.first.join_type.should == :inner
+    end
+
+    @d.join_table(:natural, :blah, nil, :b).join(:categories, nil, :c) do |join_alias, last_join_alias, joins| 
+      join_alias.should == :c
+      last_join_alias.should == :b
+      joins.should be_a_kind_of(Array)
+      joins.length.should == 1
+      joins.first.should be_a_kind_of(Sequel::SQL::JoinClause)
+      joins.first.join_type.should == :natural
+    end
+
+    @d.join(:blah).join(:categories).join(:blah2) do |join_alias, last_join_alias, joins| 
+      join_alias.should == :blah2
+      last_join_alias.should == :categories
+      joins.should be_a_kind_of(Array)
+      joins.length.should == 2
+      joins.first.should be_a_kind_of(Sequel::SQL::JoinClause)
+      joins.first.table.should == :blah
+      joins.last.should be_a_kind_of(Sequel::SQL::JoinClause)
+      joins.last.table.should == :categories
+    end
+  end
+
+  specify "should use the block result as the only condition if no condition is given" do
+    @d.join(:categories){|j,lj,js| {:b.qualify(j)=>:c.qualify(lj)}}.sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."b" = "items"."c")'
+    @d.join(:categories){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."b" > "items"."c")'
+  end
+
+  specify "should combine the block conditions and argument conditions if both given" do
+    @d.join(:categories, :a=>:d){|j,lj,js| {:b.qualify(j)=>:c.qualify(lj)}}.sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" = "items"."c"))'
+    @d.join(:categories, :a=>:d){|j,lj,js| :b.qualify(j) > :c.qualify(lj)}.sql.should ==
+      'SELECT * FROM "items" INNER JOIN "categories" ON (("categories"."a" = "items"."d") AND ("categories"."b" > "items"."c"))'
+  end
 end
 
 context "Dataset#[]=" do
@@ -1543,9 +1655,9 @@ context "Dataset #first and #last" do
   
   specify "#last should invert the order" do
     @d.order(:a).last.pop.should == 'SELECT * FROM test ORDER BY a DESC LIMIT 1'
-    @d.order(:b.desc).last.pop.should == 'SELECT * FROM test ORDER BY b LIMIT 1'
+    @d.order(:b.desc).last.pop.should == 'SELECT * FROM test ORDER BY b ASC LIMIT 1'
     @d.order(:c, :d).last.pop.should == 'SELECT * FROM test ORDER BY c DESC, d DESC LIMIT 1'
-    @d.order(:e.desc, :f).last.pop.should == 'SELECT * FROM test ORDER BY e, f DESC LIMIT 1'
+    @d.order(:e.desc, :f).last.pop.should == 'SELECT * FROM test ORDER BY e ASC, f DESC LIMIT 1'
   end
 end
 

data/spec/object_graph_spec.rb

@@ -48,7 +48,7 @@ describe Sequel::Dataset, " graphing" do
 
   it "#graph should accept a :table_alias option" do
     ds = @ds1.graph(:lines, {:x=>:id}, :table_alias=>:planes)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, planes.id AS planes_id, planes.x AS planes_x, planes.y AS planes_y, planes.graph_id FROM points LEFT OUTER JOIN lines planes ON (planes.x = points.id)'
+    ds.sql.should == 'SELECT points.id, points.x, points.y, planes.id AS planes_id, planes.x AS planes_x, planes.y AS planes_y, planes.graph_id FROM points LEFT OUTER JOIN lines AS planes ON (planes.x = points.id)'
   end
 
   it "#graph should accept a :join_type option" do
@@ -56,11 +56,16 @@ describe Sequel::Dataset, " graphing" do
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points INNER JOIN lines ON (lines.x = points.id)'
   end
 
-  it "#graph should accept a :select_option" do
+  it "#graph should not select any columns from the graphed table if :select option is false" do
     ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
     ds.sql.should == 'SELECT points.id, points.x, points.y, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
   end
 
+  it "#graph should use the given columns if :select option is used" do
+    ds = @ds1.graph(:lines, {:x=>:id}, :select=>[:x, :graph_id]).graph(:graphs, :id=>:graph_id)
+    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.x AS lines_x, lines.graph_id, graphs.id AS graphs_id, graphs.name, graphs.x AS graphs_x, graphs.y AS graphs_y, graphs.lines_x AS graphs_lines_x FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN graphs ON (graphs.id = lines.graph_id)'
+  end
+
   it "#graph should pass all join_conditions to join_table" do
     ds = @ds1.graph(@ds2, [[:x, :id], [:y, :id]])
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON ((lines.x = points.id) AND (lines.y = points.id))'
@@ -80,7 +85,7 @@ describe Sequel::Dataset, " graphing" do
 
   it "#graph should allow graphing of the same dataset multiple times" do
     ds = @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph)
-    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id, graph.id AS graph_id_0, graph.x AS graph_x, graph.y AS graph_y, graph.graph_id AS graph_graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN lines graph ON (graph.y = points.id)'
+    ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id, graph.id AS graph_id_0, graph.x AS graph_x, graph.y AS graph_y, graph.graph_id AS graph_graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id) LEFT OUTER JOIN lines AS graph ON (graph.y = points.id)'
   end
 
   it "#graph should raise an error if the table/table alias has already been used" do
@@ -170,7 +175,7 @@ describe Sequel::Dataset, " graphing" do
     results[3].should == {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}
   end
 
-  it "#graph_each should not included tables graphed with the :select option in the result set" do
+  it "#graph_each should not included tables graphed with the :select => false option in the result set" do
     ds = @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id)
     def ds.fetch_rows(sql, &block)
       yield({:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12})

data/spec/sequelizer_spec.rb

@@ -2,30 +2,21 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 context "Sequelizer without ParseTree" do
   setup do
-    module Kernel
-      alias_method :orig_sq_require, :require
-      def require(*args); raise LoadError; end
-    end
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-    load(File.join(File.dirname(__FILE__), '../lib/sequel_core/dataset/sequelizer.rb'))
-    $VERBOSE = old_verbose
+    Sequel.use_parse_tree = false
     @db = Sequel::Database.new
     @ds = @db[:items]
   end
   
   teardown do
-    module Kernel
-      alias_method :require, :orig_sq_require
-    end
-    old_verbose = $VERBOSE
-    $VERBOSE = nil
-    load(File.join(File.dirname(__FILE__), '../lib/sequel_core/dataset/sequelizer.rb'))
-    $VERBOSE = old_verbose
+    Sequel.use_parse_tree = true
   end
   
-  specify "should raise error when converting proc to SQL" do
-    proc {proc {:x > 1}.to_sql(@ds)}.should raise_error(Sequel::Error)
+  specify "should raise error when using ParseTree specific syntax without ParseTree" do
+    proc {@ds.filter{:x << 1}}.should raise_error
+  end
+
+  specify "should allow expression syntax inside block raise error when converting ParseTree proc to SQL" do
+    proc {@ds.filter{:x > 1}}.should_not raise_error(Sequel::Error)
   end
 end