sequel_core 1.0.0.1 → 1.0.1

data/spec/adapters/postgres_spec.rb

@@ -80,6 +80,64 @@ context "A PostgreSQL dataset" do
     proc {@d.literal(false)}.should_not raise_error
   end
   
+  specify "should quote columns using double quotes" do
+    @d.select(:name).sql.should == \
+      'SELECT "name" FROM test'
+      
+    @d.select('COUNT(*)'.lit).sql.should == \
+      'SELECT COUNT(*) FROM test'
+
+    @d.select(:value.MAX).sql.should == \
+      'SELECT max("value") FROM test'
+      
+    @d.select(:NOW[]).sql.should == \
+    'SELECT NOW() FROM test'
+
+    @d.select(:items__value.MAX).sql.should == \
+      'SELECT max(items."value") FROM test'
+
+    @d.order(:name.DESC).sql.should == \
+      'SELECT * FROM test ORDER BY "name" DESC'
+
+    @d.select('test.name AS item_name'.lit).sql.should == \
+      'SELECT test.name AS item_name FROM test'
+      
+    @d.select('"name"'.lit).sql.should == \
+      'SELECT "name" FROM test'
+
+    @d.select('max(test."name") AS "max_name"'.lit).sql.should == \
+      'SELECT max(test."name") AS "max_name" FROM test'
+      
+    @d.select(:test[:abc, 'hello']).sql.should == \
+      "SELECT test(\"abc\", 'hello') FROM test"
+
+    @d.select(:test[:abc__def, 'hello']).sql.should == \
+      "SELECT test(abc.\"def\", 'hello') FROM test"
+
+    @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
+      "SELECT test(abc.\"def\", 'hello') AS \"x2\" FROM test"
+
+    @d.insert_sql(:value => 333).should == \
+      'INSERT INTO test ("value") VALUES (333)'
+
+    @d.insert_sql(:x => :y).should == \
+      'INSERT INTO test ("x") VALUES ("y")'
+  end
+  
+  specify "should quote fields correctly when reversing the order" do
+    @d.reverse_order(:name).sql.should == \
+      'SELECT * FROM test ORDER BY "name" DESC'
+
+    @d.reverse_order(:name.DESC).sql.should == \
+      'SELECT * FROM test ORDER BY "name"'
+
+    @d.reverse_order(:name, :test.DESC).sql.should == \
+      'SELECT * FROM test ORDER BY "name" DESC, "test"'
+
+    @d.reverse_order(:name.DESC, :test).sql.should == \
+      'SELECT * FROM test ORDER BY "name", "test" DESC'
+  end
+  
   specify "should support transactions" do
     PGSQL_DB.transaction do
       @d << {:name => 'abc', :value => 1}

data/spec/adapters/sqlite_spec.rb

@@ -132,6 +132,18 @@ context "An SQLite database" do
     SQLITE_DB[:time] << {:t => t1}
     SQLITE_DB[:time].first[:t].should == t1
   end
+  
+  specify "should support sequential primary keys" do
+    @db.create_table!(:with_pk) {primary_key :id; text :name}
+    @db[:with_pk] << {:name => 'abc'}
+    @db[:with_pk] << {:name => 'def'}
+    @db[:with_pk] << {:name => 'ghi'}
+    @db[:with_pk].order(:name).all.should == [
+      {:id => 1, :name => 'abc'},
+      {:id => 2, :name => 'def'},
+      {:id => 3, :name => 'ghi'}
+    ]
+  end
 end
 
 context "An SQLite dataset" do
@@ -310,6 +322,8 @@ context "SQLite dataset" do
   end
 end
 
+__END__
+
 context "A SQLite database" do
   setup do
     @db = SQLITE_DB
@@ -324,7 +338,7 @@ context "A SQLite database" do
   end
   
   specify "should not support drop_column operations" do
-    proc {@db.drop_column :test2, :xyz}.should raise_error(SequelError)
+    proc {@db.drop_column :test2, :xyz}.should raise_error(Sequel::Error)
   end
   
   specify "should not support rename_column operations" do
@@ -333,13 +347,13 @@ context "A SQLite database" do
     @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
 
     @db[:test2].columns.should == [:name, :value, :xyz]
-    proc {@db.rename_column :test2, :xyz, :zyx}.should raise_error(SequelError)
+    proc {@db.rename_column :test2, :xyz, :zyx}.should raise_error(Sequel::Error)
   end
   
   specify "should not support set_column_type operations" do
     @db.add_column :test2, :xyz, :float
     @db[:test2].delete
     @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
-    proc {@db.set_column_type :test2, :xyz, :integer}.should raise_error(SequelError)
+    proc {@db.set_column_type :test2, :xyz, :integer}.should raise_error(Sequel::Error)
   end
 end  

data/spec/database_spec.rb

@@ -810,3 +810,29 @@ context "Database#alter_table_sql" do
     proc {@db.alter_table_sql(:mau, :op => :blah)}.should raise_error(Sequel::Error)
   end
 end
+
+context "Database.connect" do
+  EEE_YAML = "development:\r\n  adapter: eee\r\n  username: mau\r\n  password: tau\r\n  host: alfonso\r\n  database: mydb\r\n"
+  
+  setup do
+    class EEE < Sequel::Database
+      set_adapter_scheme :eee
+    end
+    
+    @fn = File.join(File.dirname(__FILE__), 'eee.yaml')
+    File.open(@fn, 'w') {|f| f << EEE_YAML}
+  end
+  
+  teardown do
+    FileUtils.rm(@fn)
+  end
+  
+  specify "should accept hashes loaded from YAML files" do
+    db = Sequel(YAML.load_file(@fn)['development'])
+    db.class.should == EEE
+    db.opts[:database].should == 'mydb'
+    db.opts[:user].should == 'mau'
+    db.opts[:password].should == 'tau'
+    db.opts[:host].should == 'alfonso'
+  end
+end

data/spec/dataset_spec.rb

@@ -276,7 +276,9 @@ context "Dataset#where" do
   end
   
   specify "should raise if the dataset is grouped" do
-    proc {@dataset.group(:t).where(:a => 1)}.should raise_error
+    proc {@dataset.group(:t).where(:a => 1)}.should_not raise_error
+    @dataset.group(:t).where(:a => 1).sql.should ==
+      "SELECT * FROM test WHERE (a = 1) GROUP BY t"
   end
   
   specify "should accept ranges" do
@@ -405,6 +407,9 @@ context "Dataset#and" do
   
   specify "should raise if no filter exists" do
     proc {@dataset.and(:a => 1)}.should raise_error(Sequel::Error)
+    proc {@dataset.where(:a => 1).group(:t).and(:b => 2)}.should_not raise_error(Sequel::Error)
+    @dataset.where(:a => 1).group(:t).and(:b => 2).sql ==
+      "SELECT * FROM test WHERE (a = 1) AND (b = 2) GROUP BY t"
   end
   
   specify "should add an alternative expression to the where clause" do
@@ -489,6 +494,11 @@ context "Dataset#having" do
     @grouped.having {:sum[:population] > 10}.sql.should == 
       "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
+
+  specify "should work with and on the having clause" do
+    @grouped.having{ :a > 1 }.and{ :b < 2 }.sql.should ==
+      "SELECT #{@columns} FROM test GROUP BY region HAVING (a > 1) AND (b < 2)"
+  end
 end
 
 context "a grouped dataset" do

data/spec/sequelizer_spec.rb

@@ -25,7 +25,7 @@ context "Sequelizer without ParseTree" do
   end
   
   specify "should raise error when converting proc to SQL" do
-    proc {@ds.proc_to_sql(proc {:x > 1})}.should raise_error(Sequel::Error)
+    proc {proc {:x > 1}.to_sql(@ds)}.should raise_error(Sequel::Error)
   end
 end
 
@@ -54,8 +54,48 @@ context "Sequelizer without Ruby2Ruby" do
   end
   
   specify "should raise error only when using external expressions" do
-    proc {@ds.proc_to_sql(proc {:x > 1})}.should_not raise_error(Sequel::Error)
-    proc {@ds.proc_to_sql(proc {1 + 1})}.should raise_error(Sequel::Error)
+    proc {proc {:x > 1}.to_sql(@ds)}.should_not raise_error(Sequel::Error)
+    proc {proc {1 + 1}.to_sql(@ds)}.should raise_error(Sequel::Error)
+  end
+end
+
+context "Proc without #to_sexp method (Ruby2Ruby missing)" do
+  setup do
+    class Proc
+      alias_method :orig_to_sexp, :to_sexp
+      remove_method :to_sexp
+    end
+    
+    module Kernel
+      alias_method :orig_sq_require, :require
+      def require(name); raise LoadError if name == 'ruby2ruby'; end
+    end
+    old_verbose = $VERBOSE
+    $VERBOSE = nil
+    load(File.join(File.dirname(__FILE__), '../lib/sequel_core/dataset/sequelizer.rb'))
+    $VERBOSE = old_verbose
+    @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
+    
+    class Proc
+      alias_method :to_sexp, :orig_to_sexp
+    end
+  end
+  
+  specify "should define a replacement Proc#to_sexp implementation" do
+    pr = proc {1 + 1}
+    proc {pr.to_sexp}.should_not raise_error
+    pr.to_sexp.should == [:bmethod, nil, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]
   end
 end
 
@@ -64,12 +104,12 @@ context "Proc#to_sql" do
   DS = DB[:items]
 
   class ::Proc
-    def to_sql
-      DS.proc_to_sql(self)
+    def sql
+      to_sql(DS)
     end
     
-    def to_sql_comma_separated
-      DS.proc_to_sql(self, :comma_separated => true)
+    def sql_comma_separated
+      to_sql(DS, :comma_separated => true)
     end
   end
   
@@ -85,253 +125,253 @@ context "Proc#to_sql" do
   end
   
   specify "should support <sym> <op> <lit>" do
-    proc {:x > 100}.to_sql.should == '(x > 100)'
-    proc {:x < 100}.to_sql.should == '(x < 100)'
-    proc {:x >= 100}.to_sql.should == '(x >= 100)'
-    proc {:x <= 100}.to_sql.should == '(x <= 100)'
-    proc {:x == 100}.to_sql.should == '(x = 100)'
+    proc {:x > 100}.sql.should == '(x > 100)'
+    proc {:x < 100}.sql.should == '(x < 100)'
+    proc {:x >= 100}.sql.should == '(x >= 100)'
+    proc {:x <= 100}.sql.should == '(x <= 100)'
+    proc {:x == 100}.sql.should == '(x = 100)'
   end
   
   specify "should support number literals" do
-    proc {:x > 123.45}.to_sql.should == '(x > 123.45)'
-    proc {:x > -30_000}.to_sql.should == '(x > -30000)'
+    proc {:x > 123.45}.sql.should == '(x > 123.45)'
+    proc {:x > -30_000}.sql.should == '(x > -30000)'
   end
 
   specify "should support string literals" do
-    proc {:x == 'abc'}.to_sql.should == "(x = 'abc')"
-    proc {:y == "ab'cd"}.to_sql.should == "(y = 'ab''cd')"
+    proc {:x == 'abc'}.sql.should == "(x = 'abc')"
+    proc {:y == "ab'cd"}.sql.should == "(y = 'ab''cd')"
   end
   
   specify "should support boolean literals" do
-    proc {:x == false}.to_sql.should == "(x = 'f')"
-    proc {:x == true}.to_sql.should == "(x = 't')"
+    proc {:x == false}.sql.should == "(x = 'f')"
+    proc {:x == true}.sql.should == "(x = 't')"
   end
   
   specify "should support nil literal and nil?" do
-    proc {:x == nil}.to_sql.should == "(x IS NULL)"
-    proc {:x.nil?}.to_sql.should == "(x IS NULL)"
+    proc {:x == nil}.sql.should == "(x IS NULL)"
+    proc {:x.nil?}.sql.should == "(x IS NULL)"
   end
   
   specify "should support local vars or method references" do
-    proc {proc {:x == a}.to_sql}.should raise_error(NameError)
+    proc {proc {:x == a}.sql}.should raise_error(NameError)
     b = 123
-    proc {:x == b}.to_sql.should == "(x = 123)"
+    proc {:x == b}.sql.should == "(x = 123)"
     def xyz; 321; end
-    proc {:x == xyz}.to_sql.should == "(x = 321)"
-    proc {:x == xyz.to_s}.to_sql.should == "(x = '321')"
+    proc {:x == xyz}.sql.should == "(x = 321)"
+    proc {:x == xyz.to_s}.sql.should == "(x = '321')"
     
     def y1(x); x; end
     def y2; 111; end
     
-    proc {:x == y1(222)}.to_sql.should == "(x = 222)"
-    proc {:x == y2}.to_sql.should == "(x = 111)"
+    proc {:x == y1(222)}.sql.should == "(x = 222)"
+    proc {:x == y2}.sql.should == "(x = 111)"
   end
   
   specify "sould support subscript access on symbols" do
-    proc {:x|1 > 0}.to_sql.should == "(x[1] > 0)"
-    proc {:x|2|3 > 0}.to_sql.should == "(x[2, 3] > 0)"
-    proc {:x|[4, 5] > 0}.to_sql.should == "(x[4, 5] > 0)"
+    proc {:x|1 > 0}.sql.should == "(x[1] > 0)"
+    proc {:x|2|3 > 0}.sql.should == "(x[2, 3] > 0)"
+    proc {:x|[4, 5] > 0}.sql.should == "(x[4, 5] > 0)"
   end
   
   specify "should support constants" do
     ZZZ = 444
-    proc {:x == ZZZ}.to_sql.should == "(x = 444)"
+    proc {:x == ZZZ}.sql.should == "(x = 444)"
     
     CCCD = Module.new
     CCCD::DDD = 'hi'
-    proc {:x == CCCD::DDD}.to_sql.should == "(x = 'hi')"
+    proc {:x == CCCD::DDD}.sql.should == "(x = 'hi')"
   end
   
   specify "should support instance attributes" do
     @abc = 123
-    proc {:x == @abc}.to_sql.should == "(x = 123)"
+    proc {:x == @abc}.sql.should == "(x = 123)"
   end
   
   specify "should support class attributes" do
     @@abc = 321
-    proc {:x == @@abc}.to_sql.should == "(x = 321)"
+    proc {:x == @@abc}.sql.should == "(x = 321)"
   end
   
   specify "should support like? pattern" do
-    proc {:x.like? '%abc'}.to_sql.should == "(x LIKE '%abc')"
+    proc {:x.like? '%abc'}.sql.should == "(x LIKE '%abc')"
   end
   
   specify "should support =~ operator" do
     # stock SQL version does not know about regexps
-    proc {:x =~ '123'}.to_sql.should == "(x LIKE '123')"
+    proc {:x =~ '123'}.sql.should == "(x LIKE '123')"
 
-    proc {:x =~ /^123/}.to_sql.should == "(x ~ '^123')"
+    proc {:x =~ /^123/}.sql.should == "(x ~ '^123')"
   end
   
   specify "should raise on =~ operator for unsupported types" do
-    proc {proc {:x =~ 123}.to_sql}.should raise_error(Sequel::Error)
+    proc {proc {:x =~ 123}.sql}.should raise_error(Sequel::Error)
   end
   
   specify "should support != operator" do
-    proc {:x != 100}.to_sql.should == "(NOT (x = 100))"
+    proc {:x != 100}.sql.should == "(NOT (x = 100))"
   end
 
   specify "should support !~ operator" do
-    proc {:x !~ '123'}.to_sql.should == "(NOT (x LIKE '123'))"
+    proc {:x !~ '123'}.sql.should == "(NOT (x LIKE '123'))"
   end
   
   specify "should support ! operator" do
-    proc {!:x}.to_sql.should == "(x = 'f')"
-    proc {!(:x > 100)}.to_sql.should == "(NOT (x > 100))"
+    proc {!:x}.sql.should == "(x = 'f')"
+    proc {!(:x > 100)}.sql.should == "(NOT (x > 100))"
   end
   
   specify "should support && operator" do
-    proc {1 && 2}.to_sql.should == "(1 AND 2)"
-    proc {:x > 100 && :y < 100}.to_sql.should == "((x > 100) AND (y < 100))"
-    proc {:x && :y && :z}.to_sql.should == "(x AND (y AND z))"
+    proc {1 && 2}.sql.should == "(1 AND 2)"
+    proc {:x > 100 && :y < 100}.sql.should == "((x > 100) AND (y < 100))"
+    proc {:x && :y && :z}.sql.should == "(x AND (y AND z))"
   end
   
   specify "should support << operator for assignment" do
-    proc {:x << 1}.to_sql.should == "x = 1"
+    proc {:x << 1}.sql.should == "x = 1"
   end
   
   specify "should concatenate separate statements using AND" do
-    proc {:x == 20; :y == 30}.to_sql.should == "((x = 20) AND (y = 30))"
-    proc {:x != 1; :y != 2; :z != 3}.to_sql.should == \
+    proc {:x == 20; :y == 30}.sql.should == "((x = 20) AND (y = 30))"
+    proc {:x != 1; :y != 2; :z != 3}.sql.should == \
       "((NOT (x = 1)) AND (NOT (y = 2)) AND (NOT (z = 3)))"
   end
   
   specify "should concatenate separate statements using custom join argument" do
-    proc {:x << 20; :y << 30}.to_sql_comma_separated.should == "x = 20, y = 30"
+    proc {:x << 20; :y << 30}.sql_comma_separated.should == "x = 20, y = 30"
     z = 333
-    proc {:x << :x + 1; :y << z}.to_sql_comma_separated.should == "x = (x + 1), y = 333"
+    proc {:x << :x + 1; :y << z}.sql_comma_separated.should == "x = (x + 1), y = 333"
   end
   
   specify "should support || operator" do
-    proc {1 || 2}.to_sql.should == "(1 OR 2)"
-    proc {:x > 100 || :y < 100}.to_sql.should == "((x > 100) OR (y < 100))"
-    proc {:x || :y || :z}.to_sql.should == "(x OR (y OR z))"
+    proc {1 || 2}.sql.should == "(1 OR 2)"
+    proc {:x > 100 || :y < 100}.sql.should == "((x > 100) OR (y < 100))"
+    proc {:x || :y || :z}.sql.should == "(x OR (y OR z))"
   end
   
   specify "should support operator combinations" do
-    proc {(:x > 1 || :y > 2) && (:z > 3)}.to_sql.should == "(((x > 1) OR (y > 2)) AND (z > 3))"
-    proc {(1 && 2) || (3 || 4)}.to_sql.should == "((1 AND 2) OR (3 OR 4))"
-    proc {(:x != 2) || (:y == 3) || !(:z == 4)}.to_sql.should == \
+    proc {(:x > 1 || :y > 2) && (:z > 3)}.sql.should == "(((x > 1) OR (y > 2)) AND (z > 3))"
+    proc {(1 && 2) || (3 || 4)}.sql.should == "((1 AND 2) OR (3 OR 4))"
+    proc {(:x != 2) || (:y == 3) || !(:z == 4)}.sql.should == \
       "((NOT (x = 2)) OR ((y = 3) OR (NOT (z = 4))))"
   end
   
   specify "should support late bound column references" do
     def abc; :tttt; end
-    proc {abc > 2}.to_sql.should == "(tttt > 2)"
+    proc {abc > 2}.sql.should == "(tttt > 2)"
   end
   
   specify "should support qualified column references" do
-    proc {:x__y > 3}.to_sql.should == "(x.y > 3)"
+    proc {:x__y > 3}.sql.should == "(x.y > 3)"
   end
   
   specify "should support functions on columns" do
-    proc {:x.MAX > 100}.to_sql.should == "(max(x) > 100)"
-    proc {:x.COUNT > 100}.to_sql.should == "(count(x) > 100)"
+    proc {:x.MAX > 100}.sql.should == "(max(x) > 100)"
+    proc {:x.COUNT > 100}.sql.should == "(count(x) > 100)"
   end
   
   specify "should support SQL functions" do
-    proc {:MAX[:x] > 100}.to_sql.should == "(MAX(x) > 100)"
+    proc {:MAX[:x] > 100}.sql.should == "(MAX(x) > 100)"
 
-    proc {:MAX[:x__y] > 100}.to_sql.should == "(MAX(x.y) > 100)"
+    proc {:MAX[:x__y] > 100}.sql.should == "(MAX(x.y) > 100)"
   end
   
   specify "should support SQL functions with multiple arguments" do
-    proc {:sum[1, 2, 3] > 100}.to_sql.should == "(sum(1, 2, 3) > 100)"
+    proc {:sum[1, 2, 3] > 100}.sql.should == "(sum(1, 2, 3) > 100)"
     
-    proc {:x[1, DB[:y].select(:z), "a'b"] > 100}.to_sql.should == \
+    proc {:x[1, DB[:y].select(:z), "a'b"] > 100}.sql.should == \
       "(x(1, (SELECT z FROM y), 'a''b') > 100)"
   end
   
   specify "should support SQL functions without arguments" do
-    proc {:abc[] > 100}.to_sql.should == "(abc() > 100)"
+    proc {:abc[] > 100}.sql.should == "(abc() > 100)"
     
-    proc {:now[] - :last_stamp > 100}.to_sql.should == \
+    proc {:now[] - :last_stamp > 100}.sql.should == \
       "((now() - last_stamp) > 100)"
   end
   
   specify "should do stuff like..." do
-    proc {:price < 100 || :category != 'ruby'}.to_sql.should == \
+    proc {:price < 100 || :category != 'ruby'}.sql.should == \
       "((price < 100) OR (NOT (category = 'ruby')))"
     t = Time.now
-    proc {:node_id == 1 && :stamp < t}.to_sql.should == \
+    proc {:node_id == 1 && :stamp < t}.sql.should == \
       "((node_id = 1) AND (stamp < #{DS.literal(t)}))"
       
-    proc {1 < :x}.to_sql.should == "(1 < x)"
+    proc {1 < :x}.sql.should == "(1 < x)"
   end
   
   specify "should complain if someone is crazy" do
-    proc {proc {def x; 1; end}.to_sql}.should raise_error(Sequel::Error::InvalidExpression)
+    proc {proc {def x; 1; end}.sql}.should raise_error(Sequel::Error::InvalidExpression)
     a = 1
-    proc {proc {a = 1}.to_sql}.should raise_error(Sequel::Error::InvalidExpression)
+    proc {proc {a = 1}.sql}.should raise_error(Sequel::Error::InvalidExpression)
   end
   
   specify "should support comparison to Range objects" do
-    proc {:x == (1..10)}.to_sql.should == \
+    proc {:x == (1..10)}.sql.should == \
       "(x >= 1 AND x <= 10)"
 
-    proc {:x == (1...10)}.to_sql.should == \
+    proc {:x == (1...10)}.sql.should == \
       "(x >= 1 AND x < 10)"
       
     a, b = 3, 5
-    proc {:x == (a..b)}.to_sql.should == \
+    proc {:x == (a..b)}.sql.should == \
       "(x >= 3 AND x <= 5)"
 
-    proc {:x == (a...b)}.to_sql.should == \
+    proc {:x == (a...b)}.sql.should == \
       "(x >= 3 AND x < 5)"
       
     t1 = Time.now - 4000
     t2 = Time.now - 2000
     
-    proc {:stamp == (t1..t2)}.to_sql.should == \
+    proc {:stamp == (t1..t2)}.sql.should == \
       "(stamp >= #{DS.literal(t1)} AND stamp <= #{DS.literal(t2)})"
   end
 
   specify "should support comparison to sub-queries" do
     @ds2 = DB[:test].select(:node_id)
     
-    proc {:id == @ds2}.to_sql.should == \
+    proc {:id == @ds2}.sql.should == \
       "(id IN (SELECT node_id FROM test))"
       
-    proc {:id == DB[:test].select(:node_id)}.to_sql.should == \
+    proc {:id == DB[:test].select(:node_id)}.sql.should == \
     "(id IN (SELECT node_id FROM test))"
 
-    proc {:id == DB[:test].select(:node_id).filter {:active == true}}.to_sql.should == \
+    proc {:id == DB[:test].select(:node_id).filter {:active == true}}.sql.should == \
       "(id IN (SELECT node_id FROM test WHERE (active = 't')))"
     
-    proc {:price >= DB[:items].select(:price)}.to_sql.should == \
+    proc {:price >= DB[:items].select(:price)}.sql.should == \
       "(price >= (SELECT price FROM items))"
   end
 
   specify "should support comparison to arrays" do
-    proc {:id == [1, 3, 7, 15]}.to_sql.should == \
+    proc {:id == [1, 3, 7, 15]}.sql.should == \
       "(id IN (1, 3, 7, 15))"
   end
   
   specify "should not literalize String#expr and String#lit" do
-    proc {'x'.lit == 1}.to_sql.should == "(x = 1)"
-    proc {'x.y'.expr == 1}.to_sql.should == "(x.y = 1)"
+    proc {'x'.lit == 1}.sql.should == "(x = 1)"
+    proc {'x.y'.expr == 1}.sql.should == "(x.y = 1)"
   end
 
   specify "should support in/in? operator" do
-    proc {:x.in [3, 4, 5]}.to_sql.should == "(x IN (3, 4, 5))"
-    proc {:x.in?(3, 4, 5)}.to_sql.should == "(x IN (3, 4, 5))"
+    proc {:x.in [3, 4, 5]}.sql.should == "(x IN (3, 4, 5))"
+    proc {:x.in?(3, 4, 5)}.sql.should == "(x IN (3, 4, 5))"
 
-    proc {:x.in(1..10)}.to_sql.should == "(x >= 1 AND x <= 10)"
-    proc {:x.in?(1..10)}.to_sql.should == "(x >= 1 AND x <= 10)"
+    proc {:x.in(1..10)}.sql.should == "(x >= 1 AND x <= 10)"
+    proc {:x.in?(1..10)}.sql.should == "(x >= 1 AND x <= 10)"
 
     @ds2 = DB[:test].select(:node_id)
-    proc {:x.in @ds2}.to_sql.should == "(x IN (SELECT node_id FROM test))"
+    proc {:x.in @ds2}.sql.should == "(x IN (SELECT node_id FROM test))"
   end
   
   specify "should support nested procs" do
-    proc {:x > 10 || proc{:y > 20}}.to_sql.should == \
+    proc {:x > 10 || proc{:y > 20}}.sql.should == \
       "((x > 10) OR (y > 20))"
     
     def pr(&block)
       proc {:x > 10 || block}
     end
     
-    pr {:y > 20}.to_sql.should == \
+    pr {:y > 20}.sql.should == \
       "((x > 10) OR (y > 20))"
   end
   
@@ -345,7 +385,7 @@ context "Proc#to_sql" do
         (p|idx) << (p|idx) + v
       end
     end
-    pr.to_sql_comma_separated.should == \
+    pr.sql_comma_separated.should == \
       "day[1] = (day[1] + 2), week[1] = (week[1] + 2), month[1] = (month[1] + 2), year[1] = (year[1] + 2), alltime[1] = (alltime[1] + 2)"
   end
   
@@ -357,12 +397,12 @@ context "Proc#to_sql" do
         k << k + v
       end
     end
-    pr.to_sql_comma_separated.should == "month = (month + 3)"
+    pr.sql_comma_separated.should == "month = (month + 3)"
   end
   
   specify "should support local arguments" do
     def t(x)
-      proc {x > 10}.to_sql
+      proc {x > 10}.sql
     end
     t(:y).should == "(y > 10)"
   end
@@ -370,69 +410,69 @@ context "Proc#to_sql" do
   specify "should support binary operators on local context" do
     XXX = 1
     YYY = 2
-    proc {XXX || YYY}.to_sql.should == "(1 OR 2)"
+    proc {XXX || YYY}.sql.should == "(1 OR 2)"
     
     xxx = 1
     yyy = 2
-    proc {xxx && yyy}.to_sql.should == "(1 AND 2)"
+    proc {xxx && yyy}.sql.should == "(1 AND 2)"
   end
   
   specify "should support arithmetics" do
     zzz = 300
-    proc {(:x + 100) > zzz}.to_sql.should == "((x + 100) > 300)"
+    proc {(:x + 100) > zzz}.sql.should == "((x + 100) > 300)"
     
-    proc {(:x + :y * 100) > zzz}.to_sql.should == "((x + (y * 100)) > 300)"
+    proc {(:x + :y * 100) > zzz}.sql.should == "((x + (y * 100)) > 300)"
     
-    proc {:units * :price}.to_sql.should == "(units * price)"
+    proc {:units * :price}.sql.should == "(units * price)"
   end
   
   specify "should support | operator" do
-    proc {(:x | 1) > 0}.to_sql.should == "(x[1] > 0)"
-    proc {10 | 1}.to_sql.should == 11
+    proc {(:x | 1) > 0}.sql.should == "(x[1] > 0)"
+    proc {10 | 1}.sql.should == 11
   end
   
   specify "should support globals" do
     $aaaa_zzzz = 400
-    proc {:x > $aaaa_zzzz}.to_sql.should == "(x > 400)"
+    proc {:x > $aaaa_zzzz}.sql.should == "(x > 400)"
   end
   
   specify "should support Regexp macros" do
     "abc" =~ /(ab)/
-    proc {:x == $1}.to_sql.should == "(x = 'ab')"
+    proc {:x == $1}.sql.should == "(x = 'ab')"
   end
   
   specify "should evaluate expression not referring to symbols or literal strings." do
-    proc {:x > 2 * 3}.to_sql.should == "(x > 6)"
+    proc {:x > 2 * 3}.sql.should == "(x > 6)"
     y = 3
-    proc {:x > y * 4}.to_sql.should == "(x > 12)"
+    proc {:x > y * 4}.sql.should == "(x > 12)"
 
-    proc {:AVG[:x] > 4}.to_sql.should == "(AVG(x) > 4)"
+    proc {:AVG[:x] > 4}.sql.should == "(AVG(x) > 4)"
 
-    proc {:AVG[:x] > 4}.to_sql.should == "(AVG(x) > 4)"
+    proc {:AVG[:x] > 4}.sql.should == "(AVG(x) > 4)"
     
-    proc {:y == (1 > 2)}.to_sql.should == "(y = 'f')"
+    proc {:y == (1 > 2)}.sql.should == "(y = 'f')"
   end
   
   specify "should support ternary operator" do
     y = true
-    proc {:x > (y ? 1 : 2)}.to_sql.should == "(x > 1)"
+    proc {:x > (y ? 1 : 2)}.sql.should == "(x > 1)"
     
-    proc {((1 > 2) ? :x : :y) > 3}.to_sql.should == "(y > 3)"
+    proc {((1 > 2) ? :x : :y) > 3}.sql.should == "(y > 3)"
   end
   
   specify "should support strings with embedded Ruby code in them and literalize them" do
-    proc {:n == "#{1+2}"}.to_sql.should == "(n = '3')"
+    proc {:n == "#{1+2}"}.sql.should == "(n = '3')"
     
     y = "12'34"
     
-    proc {:x > "#{y}"}.to_sql.should == "(x > '12''34')"
+    proc {:x > "#{y}"}.sql.should == "(x > '12''34')"
   end
   
   specify "should support format strings and literalize the result" do
     prod = 1
-    proc {:x == "abc%d" % prod}.to_sql.should == "(x = 'abc1')"
+    proc {:x == "abc%d" % prod}.sql.should == "(x = 'abc1')"
     
-    proc {:x == ("%d" % prod).lit}.to_sql.should == "(x = 1)"
+    proc {:x == ("%d" % prod).lit}.sql.should == "(x = 1)"
   end
 end
 
@@ -442,7 +482,7 @@ context "Proc#to_sql stock" do
     ds = db[:items]
 
     p = proc {:x =~ /abc/}
-    proc {ds.proc_to_sql(p)}.should raise_error(Sequel::Error)
+    proc {p.to_sql(ds)}.should raise_error(Sequel::Error)
   end
 end