sequel 3.47.0 → 3.48.0

data/spec/core/deprecated_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "Sequel::Deprecated" do
+  before do
+    @d = Sequel::Deprecation
+    @prev_prefix = @d.prefix
+    @prev_output = @d.output
+    @prev_backtrace_filter = @d.backtrace_filter
+    @output = []
+    def @output.puts(s)
+      self << s
+    end
+    @d.prefix = false
+    @d.output = @output
+    @d.backtrace_filter = false
+  end
+  after do
+    @d.prefix = @prev_prefix
+    @d.output = @prev_output
+    @d.backtrace_filter = @prev_backtrace_filter
+  end
+
+  specify "should output full messages to the given output" do
+    @d.deprecate("foo")
+    @output.should == ['foo']
+  end
+
+  specify "should consider two arguments to be a method name and additional text" do
+    @d.deprecate("foo", "Use bar instead")
+    @output.should == ['foo is deprecated and will be removed in Sequel 4.0.  Use bar instead.']
+  end
+
+  specify "should include a prefix if set" do
+    @d.prefix = "DEPWARN: "
+    @d.deprecate("foo")
+    @output.should == ['DEPWARN: foo']
+  end
+
+  specify "should not output anything if output is false" do
+    @d.output = false
+    proc{@d.deprecate("foo")}.should_not raise_error
+  end
+
+  specify "should include full backtrace if backtrace_filter is true" do
+    @d.backtrace_filter = true
+    @d.deprecate("foo")
+    @output.first.should == 'foo'
+    (4..100).should include(@output.count)
+  end
+
+  specify "should include given lines of backtrace if backtrace_filter is an integer" do
+    @d.backtrace_filter = 1
+    @d.deprecate("foo")
+    @output.first.should == 'foo'
+    @output.count.should == 2
+    
+    @output.clear
+    @d.backtrace_filter = 3
+    @d.deprecate("foo")
+    @output.first.should == 'foo'
+    @output.count.should == 4
+  end
+
+  specify "should select backtrace lines if backtrace_filter is a proc" do
+    @d.backtrace_filter = lambda{|line, line_no| line_no < 3 && line =~ /./}
+    @d.deprecate("foo")
+    @output.first.should == 'foo'
+    @output.count.should == 4
+  end
+
+  specify "should have deprecated_module return a module where all instance methods are marked deprecated" do
+    m = Module.new{def foo; 1 end}
+    dm = @d.deprecated_module(m){|meth| ["Module##{meth}", "Load the bar extension"]}
+    dm.should_not == m
+    c = Class.new{include dm}.new.foo.should == 1
+    @output.should == ['Module#foo is deprecated and will be removed in Sequel 4.0.  Load the bar extension.']
+  end
+end

data/spec/core/expression_filters_spec.rb

@@ -220,10 +220,9 @@ describe "Blockless Ruby Filters" do
     y.lit.should == y
   end
 
-  it "should return have .sql_literal operate like .to_s" do
+  it "should return have .sql_literal return the literal SQL for the expression" do
     y = Sequel.expr(:x) + 1
     y.sql_literal(@d).should == '(x + 1)'
-    y.sql_literal(@d).should == y.to_s(@d)
     y.sql_literal(@d).should == @d.literal(y)
   end
 
@@ -484,7 +483,7 @@ describe Sequel::SQL::VirtualRow do
     class << @d; remove_method :supports_window_functions? end
     meta_def(@d, :supports_window_functions?){false}
     proc{@d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}}.should raise_error(Sequel::Error)
-    proc{Sequel::Dataset.new(nil).filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
+    proc{Sequel.mock.dataset.filter{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.sql}.should raise_error(Sequel::Error)
   end
   
   it "should deal with classes without requiring :: prefix" do
@@ -932,7 +931,7 @@ end
 describe Sequel::SQL::Subscript do
   before do
     @s = Sequel::SQL::Subscript.new(:a, [1])
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
 
   specify "should have | return a new non-nested subscript" do

data/spec/core/mock_adapter_spec.rb

@@ -130,8 +130,8 @@ describe "Sequel Mock Adapter" do
   end
 
   specify "should raise Error if given an invalid object to fetch" do
-    proc{Sequel.mock(:fetch=>Class.new).get(1)}.should raise_error(Sequel::Error)
-    proc{Sequel.mock(:fetch=>Object.new).get(1)}.should raise_error(Sequel::Error)
+    proc{Sequel.mock(:fetch=>Class.new).get(:a)}.should raise_error(Sequel::Error)
+    proc{Sequel.mock(:fetch=>Object.new).get(:a)}.should raise_error(Sequel::Error)
   end
 
   specify "should be able to set the number of rows modified by update and delete using :numrows option as an integer" do
@@ -417,12 +417,12 @@ describe "Sequel Mock Adapter" do
 
   specify "should be able to load dialects based on the database name" do
     begin
-      qi = class Sequel::Database; @@quote_identifiers; end
-      ii = class Sequel::Database; @@identifier_input_method; end
-      io = class Sequel::Database; @@identifier_output_method; end
+      qi = class Sequel::Database; @quote_identifiers; end
+      ii = class Sequel::Database; @identifier_input_method; end
+      io = class Sequel::Database; @identifier_output_method; end
       Sequel.quote_identifiers = nil
-      class Sequel::Database; @@identifier_input_method=nil; end
-      class Sequel::Database; @@identifier_output_method=nil; end
+      class Sequel::Database; @identifier_input_method=nil; end
+      class Sequel::Database; @identifier_output_method=nil; end
       Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.should == 'SELECT #2011-12-13#'
       Sequel.mock(:host=>'db2').select(1).sql.should == 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
       Sequel.mock(:host=>'firebird')[:a].distinct.limit(1, 2).sql.should == 'SELECT DISTINCT FIRST 1 SKIP 2 * FROM "A"'
@@ -434,8 +434,8 @@ describe "Sequel Mock Adapter" do
       Sequel.mock(:host=>'sqlite')[:a___b].sql.should == "SELECT * FROM `a` AS 'b'"
     ensure
       Sequel.quote_identifiers = qi
-      Sequel::Database.send(:class_variable_set, :@@identifier_input_method, ii)
-      Sequel::Database.send(:class_variable_set, :@@identifier_output_method, io)
+      Sequel::Database.send(:instance_variable_set, :@identifier_input_method, ii)
+      Sequel::Database.send(:instance_variable_set, :@identifier_output_method, io)
     end
   end
 

data/spec/core/object_graph_spec.rb

@@ -43,28 +43,18 @@ describe Sequel::Dataset, " graphing" do
   it "#graph should use currently selected columns as the basis for the selected columns in a new graph" do
     ds = @ds1.select(:id).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, lines.id AS lines_id, lines.x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds._fetch = {:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5}
-    ds.all.should == [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
-    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(Sequel.identifier(:id), Sequel.qualify(:points, :x)).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
-    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(Sequel.identifier(:id).qualify(:points), Sequel.identifier(:x).as(:y)).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
-    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
 
     ds = @ds1.select(:id, Sequel.identifier(:x).qualify(Sequel.identifier(:points)).as(Sequel.identifier(:y))).graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
-    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
-    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
   end
 
   it "#graph should raise error if currently selected expressions cannot be handled" do
@@ -215,7 +205,7 @@ describe Sequel::Dataset, " graphing" do
     ].should(include(ds.sql))
   end
 
-  it "#graph_each should split the result set into component tables" do
+  qspecify "#graph_each should split the result set into component tables" do
     @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
       [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
       [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
@@ -230,7 +220,7 @@ describe Sequel::Dataset, " graphing" do
     @ds1.graph(@ds2, :x=>:id).ungraphed.all.should == [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
   end
 
-  it "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
+  qspecify "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
     @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil}],
       [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
       {:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
@@ -244,17 +234,17 @@ describe Sequel::Dataset, " graphing" do
       {: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 give a nil value instead of a hash when any value for a table is false" do
+  qspecify "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
     @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil}
     @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
   end
 
-  it "#graph_each should not included tables graphed with the :select => false option in the result set" do
+  qspecify "#graph_each should not included tables graphed with the :select => false option in the result set" do
     @db.fetch = {:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12}
     @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
   end
 
-  it "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
+  qspecify "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
     @db.fetch = [nil, [{:x=>2,:y=>3}], nil, [{:x=>2}], [{:x=>2, :q=>18}]]
 
     @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
@@ -264,22 +254,22 @@ describe Sequel::Dataset, " graphing" do
     ds.all.should == [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
   end
 
-  it "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
+  qspecify "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
     @db.fetch = [nil, {:x=>2,:y=>3}]
     @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, Sequel.function(:random)]).all.should == [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
   end
 
-  it "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
+  qspecify "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
     @db.fetch = [nil, {:x=>2,:y=>3}]
     @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
   end
 
-  it "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
+  qspecify "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
     @db.fetch = [nil, {:x=>2,:y=>3}]
     @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
   end
 
-  it "#graph_each should run the row_proc for graphed datasets" do
+  qspecify "#graph_each should run the row_proc for graphed datasets" do
     @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
     @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
     @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}

data/spec/core/schema_spec.rb

@@ -1125,7 +1125,7 @@ describe "Database#create_table" do
       'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)']
   end
 
-  specify "should not use default schema when creating a temporary table" do
+  qspecify "should not use default schema when creating a temporary table" do
     @db.default_schema = :foo
     @db.create_table :test_tmp, :temp => true do
       column :name, :text
@@ -1480,5 +1480,7 @@ describe "Schema Parser" do
     @db = Sequel.mock(:host=>'mysql')
     @db.extend(sm)
     @db.schema(:set).first.last[:type].should == :set
+    @db.schema(:mediumint).first.last[:type].should == :integer
+    @db.schema(:mediumtext).first.last[:type].should == :string
   end
 end

data/spec/core/spec_helper.rb

@@ -10,11 +10,30 @@ unless Object.const_defined?('Sequel')
   SEQUEL_NO_CORE_EXTENSIONS = true
   require 'sequel/core'
 end
+Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
 
 (defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
   def meta_def(obj, name, &block)
     (class << obj; self end).send(:define_method, name, &block)
   end
+
+  if ENV['SEQUEL_DEPRECATION_WARNINGS']
+    class << self
+      alias qspecify specify
+    end
+  else
+    def self.qspecify(*a, &block)
+      specify(*a) do
+        begin
+          output = Sequel::Deprecation.output
+          Sequel::Deprecation.output = false
+          instance_exec(&block)
+        ensure
+          Sequel::Deprecation.output = output 
+        end
+      end
+    end
+  end
 end
 
 if ENV['SEQUEL_COLUMNS_INTROSPECTION']

data/spec/core_extensions_spec.rb

@@ -7,7 +7,12 @@ end
 
 unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel/no_core_ext'
+  if dep_core_extensions = ENV['SEQUEL_DEPRECATED_CORE_EXTENSIONS']
+    require 'sequel'
+  else
+    require 'sequel/no_core_ext'
+  end
+  Sequel::Deprecation.backtrace_filter = false
 end
 
 Sequel.quote_identifiers = false
@@ -16,7 +21,12 @@ Sequel.identifier_output_method = nil
 
 Regexp.send(:include, Sequel::SQL::StringMethods)
 String.send(:include, Sequel::SQL::StringMethods)
-Sequel.extension :core_extensions
+if dep_core_extensions.nil? || dep_core_extensions =~ /OVERRIDDEN/
+  Sequel.extension :core_extensions
+end
+if RUBY_VERSION < '1.9.0' && (dep_core_extensions.nil? || dep_core_extensions =~ /SYMBOL18/)
+  Sequel.extension :ruby18_symbol_extensions
+end
 
 describe "Sequel core extensions" do
   specify "should have Sequel.core_extensions? be true if enabled" do
@@ -351,19 +361,47 @@ describe "String#to_sequel_blob" do
   end
 end
 
+describe "String cast methods" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
+  specify "should support cast method" do
+    @ds.literal('abc'.cast(:integer)).should == "CAST('abc' AS integer)"
+  end
+
+  specify "should support cast_numeric and cast_string" do
+    x = 'abc'.cast_numeric
+    x.should be_a_kind_of(Sequel::SQL::NumericExpression)
+    @ds.literal(x).should == "CAST('abc' AS integer)"
+
+    x = 'abc'.cast_numeric(:real)
+    x.should be_a_kind_of(Sequel::SQL::NumericExpression)
+    @ds.literal(x).should == "CAST('abc' AS real)"
+
+    x = 'abc'.cast_string
+    x.should be_a_kind_of(Sequel::SQL::StringExpression)
+    @ds.literal(x).should == "CAST('abc' AS varchar(255))"
+
+    x = 'abc'.cast_string(:varchar)
+    x.should be_a_kind_of(Sequel::SQL::StringExpression)
+    @ds.literal(x).should == "CAST('abc' AS varchar(255))"
+  end
+end
+  
 describe "#desc" do
   before do
     @ds = Sequel::Dataset.new(nil)
   end
   
   specify "should format a DESC clause for a column ref" do
-    :test.desc.to_s(@ds).should == 'test DESC'
+    @ds.literal(:test.desc).should == 'test DESC'
     
-    :items__price.desc.to_s(@ds).should == 'items.price DESC'
+    @ds.literal(:items__price.desc).should == 'items.price DESC'
   end
 
   specify "should format a DESC clause for a function" do
-    :avg.sql_function(:test).desc.to_s(@ds).should == 'avg(test) DESC'
+    @ds.literal(:avg.sql_function(:test).desc).should == 'avg(test) DESC'
   end
 end
 
@@ -373,13 +411,13 @@ describe "#asc" do
   end
   
   specify "should format a ASC clause for a column ref" do
-    :test.asc.to_s(@ds).should == 'test ASC'
+    @ds.literal(:test.asc).should == 'test ASC'
     
-    :items__price.asc.to_s(@ds).should == 'items.price ASC'
+    @ds.literal(:items__price.asc).should == 'items.price ASC'
   end
 
   specify "should format a ASC clause for a function" do
-    :avg.sql_function(:test).asc.to_s(@ds).should == 'avg(test) ASC'
+    @ds.literal(:avg.sql_function(:test).asc).should == 'avg(test) ASC'
   end
 end
 
@@ -389,17 +427,17 @@ describe "#as" do
   end
   
   specify "should format a AS clause for a column ref" do
-    :test.as(:t).to_s(@ds).should == 'test AS t'
+    @ds.literal(:test.as(:t)).should == 'test AS t'
     
-    :items__price.as(:p).to_s(@ds).should == 'items.price AS p'
+    @ds.literal(:items__price.as(:p)).should == 'items.price AS p'
   end
 
   specify "should format a AS clause for a function" do
-    :avg.sql_function(:test).as(:avg).to_s(@ds).should == 'avg(test) AS avg'
+    @ds.literal(:avg.sql_function(:test).as(:avg)).should == 'avg(test) AS avg'
   end
   
   specify "should format a AS clause for a literal value" do
-    'abc'.as(:abc).to_s(@ds).should == "'abc' AS abc"
+    @ds.literal('abc'.as(:abc)).should == "'abc' AS abc"
   end
 end
 
@@ -464,17 +502,17 @@ describe "Symbol#*" do
   end
   
   specify "should format a qualified wildcard if no argument" do
-    :xyz.*.to_s(@ds).should == 'xyz.*'
-    :abc.*.to_s(@ds).should == 'abc.*'
+    @ds.literal(:xyz.*).should == 'xyz.*'
+    @ds.literal(:abc.*).should == 'abc.*'
   end
 
   specify "should format a filter expression if an argument" do
-    :xyz.*(3).to_s(@ds).should == '(xyz * 3)'
-    :abc.*(5).to_s(@ds).should == '(abc * 5)'
+    @ds.literal(:xyz.*(3)).should == '(xyz * 3)'
+    @ds.literal(:abc.*(5)).should == '(abc * 5)'
   end
 
   specify "should support qualified symbols if no argument" do
-    :xyz__abc.*.to_s(@ds).should == 'xyz.abc.*'
+    @ds.literal(:xyz__abc.*).should == 'xyz.abc.*'
   end
 end
 
@@ -528,12 +566,12 @@ describe "Symbol" do
   end
   
   specify "should support sql_function method" do
-    :COUNT.sql_function('1').to_s(@ds).should == "COUNT('1')"
+    @ds.literal(:COUNT.sql_function('1')).should == "COUNT('1')"
     @ds.select(:COUNT.sql_function('1')).sql.should == "SELECT COUNT('1')"
   end
   
   specify "should support cast method" do
-    :abc.cast(:integer).to_s(@ds).should == "CAST(abc AS integer)"
+    @ds.literal(:abc.cast(:integer)).should == "CAST(abc AS integer)"
   end
 
   specify "should support sql array accesses via sql_subscript" do
@@ -546,21 +584,33 @@ describe "Symbol" do
   specify "should support cast_numeric and cast_string" do
     x = :abc.cast_numeric
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    x.to_s(@ds).should == "CAST(abc AS integer)"
+    @ds.literal(x).should == "CAST(abc AS integer)"
 
     x = :abc.cast_numeric(:real)
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    x.to_s(@ds).should == "CAST(abc AS real)"
+    @ds.literal(x).should == "CAST(abc AS real)"
 
     x = :abc.cast_string
     x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    x.to_s(@ds).should == "CAST(abc AS varchar(255))"
+    @ds.literal(x).should == "CAST(abc AS varchar(255))"
 
     x = :abc.cast_string(:varchar)
     x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    x.to_s(@ds).should == "CAST(abc AS varchar(255))"
+    @ds.literal(x).should == "CAST(abc AS varchar(255))"
   end
   
+  specify "should support boolean methods" do
+    @ds.literal(~:x).should == "NOT x"
+    @ds.literal(:x & :y).should == "(x AND y)"
+    @ds.literal(:x | :y).should == "(x OR y)"
+  end
+
+  specify "should support complex expression methods" do
+    @ds.literal(:x.sql_boolean & 1).should == "(x AND 1)"
+    @ds.literal(:x.sql_number & :y).should == "(x & y)"
+    @ds.literal(:x.sql_string + :y).should == "(x || y)"
+  end
+
   specify "should allow database independent types when casting" do
     db = @ds.db
     def db.cast_type_literal(type)
@@ -568,16 +618,16 @@ describe "Symbol" do
       return :bar if type == String
       type
     end
-    :abc.cast(String).to_s(@ds).should == "CAST(abc AS bar)"
-    :abc.cast(String).to_s(@ds).should == "CAST(abc AS bar)"
-    :abc.cast_string.to_s(@ds).should == "CAST(abc AS bar)"
-    :abc.cast_string(Integer).to_s(@ds).should == "CAST(abc AS foo)"
-    :abc.cast_numeric.to_s(@ds).should == "CAST(abc AS foo)"
-    :abc.cast_numeric(String).to_s(@ds).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast(String)).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast(String)).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast_string).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast_string(Integer)).should == "CAST(abc AS foo)"
+    @ds.literal(:abc.cast_numeric).should == "CAST(abc AS foo)"
+    @ds.literal(:abc.cast_numeric(String)).should == "CAST(abc AS bar)"
   end
 
   specify "should support SQL EXTRACT function via #extract " do
-    :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)"
+    @ds.literal(:abc.extract(:year)).should == "extract(year FROM abc)"
   end
 end