sequel 4.45.0 → 4.46.0

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 45
+  MINOR = 46
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -68,6 +68,26 @@ describe "MSSQL" do
   it "should should support OUTER APPLY" do
     @db[:test3].outer_apply(@db[:test4].where(Sequel[:test3][:v3]=>Sequel[:test4][:v4])).select_order_map([:v3, :v4]).must_equal [[1,1], [2, nil]]
   end
+
+  cspecify "should handle time values with fractional seconds", [:ado] do
+    # ado: Returns nil values
+    t = Sequel::SQLTime.create(10, 20, 30, 999900)
+    v = @db.get(Sequel.cast(t, 'time'))
+    v = Sequel.string_to_time(v) if v.is_a?(String)
+    pr = lambda{|x| [:hour, :min, :sec, :usec].map{|m| x.send(m)}}
+    pr[v].must_equal(pr[t])
+  end
+
+  cspecify "should get datetimeoffset values as Time with fractional seconds", [:odbc], [:ado], [:tinytds, proc{|db| TinyTds::VERSION < '0.9'}] do
+    # odbc: Returns string rounded to nearest second
+    # ado: Returns nil values
+    # tiny_tds < 0.9: Returns wrong value for hour
+    t = Time.local(2010, 11, 12, 10, 20, 30, 999000)
+    v = @db.get(Sequel.cast(t, 'datetimeoffset'))
+    v = Sequel.string_to_datetime(v) if v.is_a?(String)
+    pr = lambda{|x| [:year, :month, :day, :hour, :min, :sec, :usec].map{|m| x.send(m)}}
+    pr[v].must_equal(pr[t])
+  end
 end
 
 # This spec is currently disabled as the SQL Server 2008 R2 Express doesn't support

data/spec/adapters/mysql_spec.rb

@@ -354,7 +354,7 @@ describe "A MySQL database" do
 
   it "should handle qualified tables in #indexes" do
     DB.create_table!(:test_innodb){primary_key :id; String :name; index :name, :unique=>true, :name=>:test_innodb_name_idx}
-    DB.indexes(Sequel.qualify(DB.get{database{}}, :test_innodb)).must_equal(:test_innodb_name_idx=>{:unique=>true, :columns=>[:name]})
+    DB.indexes(Sequel.qualify(DB.get{database.function}, :test_innodb)).must_equal(:test_innodb_name_idx=>{:unique=>true, :columns=>[:name]})
   end
 end
 

data/spec/adapters/oracle_spec.rb

@@ -63,15 +63,19 @@ describe "An Oracle database" do
       DB.view_exists?(:cats).must_equal false
       DB.create_view(:cats, DB[:categories])
       DB.view_exists?(:cats).must_equal true
-      om = DB.identifier_output_method
-      im = DB.identifier_input_method
-      DB.identifier_output_method = :reverse
-      DB.identifier_input_method = :reverse
-      DB.view_exists?(:STAC).must_equal true
-      DB.view_exists?(:cats).must_equal false
+      if IDENTIFIER_MANGLING && !DB.frozen?
+        om = DB.identifier_output_method
+        im = DB.identifier_input_method
+        DB.identifier_output_method = :reverse
+        DB.identifier_input_method = :reverse
+        DB.view_exists?(:STAC).must_equal true
+        DB.view_exists?(:cats).must_equal false
+      end
     ensure
-      DB.identifier_output_method = om
-      DB.identifier_input_method = im
+      if IDENTIFIER_MANGLING && !DB.frozen?
+        DB.identifier_output_method = om
+        DB.identifier_input_method = im
+      end
       DB.drop_view(:cats)
     end
   end

data/spec/adapters/postgres_spec.rb

@@ -463,7 +463,7 @@ describe "A PostgreSQL dataset" do
   end if DB.server_version >= 90300
 
   it "should support ordered-set and hypothetical-set aggregate functions" do
-    @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{mode{}.within_group(:a)}.must_equal 1
+    @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{mode.function.within_group(:a)}.must_equal 1
   end if DB.server_version >= 90400
 
   it "should support filtered aggregate functions" do

data/spec/adapters/spec_helper.rb

@@ -40,7 +40,7 @@ class Minitest::HooksSpec
   end
 end
 
-IDENTIFIER_MANGLING = !ENV['SEQUEL_NO_MANGLE'] unless defined?(IDENTIFIER_MANGLING)
+IDENTIFIER_MANGLING = !!ENV['SEQUEL_IDENTIFIER_MANGLING'] unless defined?(IDENTIFIER_MANGLING)
 
 unless defined?(DB)
   env_var = "SEQUEL_#{SEQUEL_ADAPTER_TEST.to_s.upcase}_URL"

data/spec/adapters/sqlite_spec.rb

@@ -5,19 +5,23 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 describe "An SQLite database" do
   before do
     @db = DB
+    deprecated do
     @fk = @db.foreign_keys
+    end
   end
   after do
     @db.drop_table?(:fk)
-    @db.auto_vacuum = :none
-    @db.run 'VACUUM'
-    @db.foreign_keys = @fk
-    @db.case_sensitive_like = true
+    deprecated do
+      @db.auto_vacuum = :none
+      @db.run 'VACUUM'
+      @db.foreign_keys = @fk
+      @db.case_sensitive_like = true
+    end
     @db.use_timestamp_timezones = false
     Sequel.datetime_class = Time
   end
 
-  it "should support getting setting pragma values" do
+  deprecated "should support getting setting pragma values" do
     @db.pragma_set(:auto_vacuum, '0')
     @db.run 'VACUUM'
     @db.pragma_get(:auto_vacuum).to_s.must_equal '0'
@@ -29,7 +33,7 @@ describe "An SQLite database" do
     @db.pragma_get(:auto_vacuum).to_s.must_equal '2'
   end
   
-  it "should support getting and setting the auto_vacuum pragma" do
+  deprecated "should support getting and setting the auto_vacuum pragma" do
     @db.auto_vacuum = :full
     @db.run 'VACUUM'
     @db.auto_vacuum.must_equal :full
@@ -40,12 +44,12 @@ describe "An SQLite database" do
     proc {@db.auto_vacuum = :invalid}.must_raise(Sequel::Error)
   end
   
-  it "should respect case sensitive like false" do
+  deprecated "should respect case sensitive like false" do
     @db.case_sensitive_like = false
     @db.get(Sequel.like('a', 'A')).to_s.must_equal '1'
   end
   
-  it "should respect case sensitive like true" do
+  deprecated "should respect case sensitive like true" do
     @db.case_sensitive_like = true
     @db.get(Sequel.like('a', 'A')).to_s.must_equal '0'
   end
@@ -63,13 +67,13 @@ describe "An SQLite database" do
     @db.sqlite_version.must_be_kind_of(Integer)
   end
   
-  it "should support setting and getting the foreign_keys pragma" do
+  deprecated "should support setting and getting the foreign_keys pragma" do
     (@db.sqlite_version >= 30619 ? [true, false] : [nil]).must_include(@db.foreign_keys)
     @db.foreign_keys = true
     @db.foreign_keys = false
   end
   
-  it "should enforce foreign key integrity if foreign_keys pragma is set" do
+  deprecated "should enforce foreign key integrity if foreign_keys pragma is set" do
     @db.foreign_keys = true
     @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
     @db[:fk].insert(1, nil)
@@ -78,7 +82,7 @@ describe "An SQLite database" do
     proc{@db[:fk].insert(4, 5)}.must_raise(Sequel::ForeignKeyConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
   end if DB.sqlite_version >= 30619
   
-  it "should not enforce foreign key integrity if foreign_keys pragma is unset" do
+  deprecated "should not enforce foreign key integrity if foreign_keys pragma is unset" do
     @db.foreign_keys = false
     @db.create_table!(:fk){primary_key :id; foreign_key :parent_id, :fk}
     @db[:fk].insert(1, 2)
@@ -104,7 +108,7 @@ describe "An SQLite database" do
     @db.tables.must_include(:fk)
   end
 
-  it "should support getting and setting the synchronous pragma" do
+  deprecated "should support getting and setting the synchronous pragma" do
     @db.synchronous = :off
     @db.synchronous.must_equal :off
     @db.synchronous = :normal
@@ -115,7 +119,7 @@ describe "An SQLite database" do
     proc {@db.synchronous = :invalid}.must_raise(Sequel::Error)
   end
   
-  it "should support getting and setting the temp_store pragma" do
+  deprecated "should support getting and setting the temp_store pragma" do
     @db.temp_store = :default
     @db.temp_store.must_equal :default
     @db.temp_store = :file
@@ -527,30 +531,28 @@ describe "A SQLite database" do
     @db[:test3].select(:id).all.must_equal [{:id => 1}, {:id => 3}]
   end
 
-  if DB.foreign_keys
-    it "should keep foreign keys when dropping a column" do
-      @db.create_table! :test do
-        primary_key :id
-        String :name
-        Integer :value
-      end
-      @db.create_table! :test3 do
-        String :name
-        Integer :value
-        foreign_key :test_id, :test, :on_delete => :set_null, :on_update => :cascade
-      end
+  it "should keep foreign keys when dropping a column" do
+    @db.create_table! :test do
+      primary_key :id
+      String :name
+      Integer :value
+    end
+    @db.create_table! :test3 do
+      String :name
+      Integer :value
+      foreign_key :test_id, :test, :on_delete => :set_null, :on_update => :cascade
+    end
 
-      @db[:test3].insert(:name => "abc", :test_id => @db[:test].insert(:name => "foo", :value => 3))
-      @db[:test3].insert(:name => "def", :test_id => @db[:test].insert(:name => "bar", :value => 4))
+    @db[:test3].insert(:name => "abc", :test_id => @db[:test].insert(:name => "foo", :value => 3))
+    @db[:test3].insert(:name => "def", :test_id => @db[:test].insert(:name => "bar", :value => 4))
 
-      @db.drop_column :test3, :value
+    @db.drop_column :test3, :value
 
-      @db[:test].filter(:name => 'bar').delete
-      @db[:test3][:name => 'def'][:test_id].must_be_nil
+    @db[:test].filter(:name => 'bar').delete
+    @db[:test3][:name => 'def'][:test_id].must_be_nil
 
-      @db[:test].filter(:name => 'foo').update(:id=>100)
-      @db[:test3][:name => 'abc'][:test_id].must_equal 100
-    end
+    @db[:test].filter(:name => 'foo').update(:id=>100)
+    @db[:test3][:name => 'abc'][:test_id].must_equal 100
   end
 
   it "should support rename_column operations" do
@@ -690,7 +692,7 @@ describe "A SQLite database" do
       sqls.last.must_equal "BEGIN DEFERRED TRANSACTION"
     end
     @db.transaction do
-      sqls.last.must_equal Sequel::Database::SQL_BEGIN
+      sqls.last.must_equal 'BEGIN'
     end
 
     @db.transaction_mode.must_be_nil

data/spec/core/connection_pool_spec.rb

@@ -761,11 +761,12 @@ describe "SingleConnectionPool" do
   it "should provide a #disconnect method" do
     conn = nil
     x = nil
-    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| conn = c}){1234}, ST_CONNECTION_POOL_DEFAULTS)
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(proc{|c| conn = c; c.must_be_kind_of(Integer)}){1234}, ST_CONNECTION_POOL_DEFAULTS)
     pool.hold{|c| x = c}
     x.must_equal 1234
     pool.disconnect
     conn.must_equal 1234
+    pool.disconnect
   end
 end
 

data/spec/core/database_spec.rb

@@ -38,6 +38,7 @@ describe "A new Database" do
   it "should support :preconnect option to preconnect to database" do
     @db.pool.size.must_equal 0
     c = Class.new(Sequel::Database) do
+      def dataset_class_default; Sequel::Dataset end
       def connect(_)
         :connect
       end
@@ -191,17 +192,17 @@ describe "Database#log_yield" do
     @db = Sequel::Database.new(:logger=>@o)
   end
 
-  it "should yield to the passed block" do
+  deprecated "should yield to the passed block" do
     a = nil
     @db.log_yield('blah'){a = 1}
     a.must_equal 1
   end
 
-  it "should raise an exception if a block is not passed" do
+  deprecated "should raise an exception if a block is not passed" do
     proc{@db.log_yield('blah')}.must_raise LocalJumpError
   end
 
-  it "should log message with duration at info level to all loggers" do
+  deprecated "should log message with duration at info level to all loggers" do
     @db.log_yield('blah'){}
     @o.logs.length.must_equal 1
     @o.logs.first.length.must_equal 2
@@ -209,7 +210,7 @@ describe "Database#log_yield" do
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
   end
 
-  it "should respect sql_log_level setting" do
+  deprecated "should respect sql_log_level setting" do
     @db.sql_log_level = :debug
     @db.log_yield('blah'){}
     @o.logs.length.must_equal 1
@@ -218,7 +219,7 @@ describe "Database#log_yield" do
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
   end
 
-  it "should log message with duration at warn level if duration greater than log_warn_duration" do
+  deprecated "should log message with duration at warn level if duration greater than log_warn_duration" do
     @db.log_warn_duration = 0
     @db.log_yield('blah'){}
     @o.logs.length.must_equal 1
@@ -227,7 +228,7 @@ describe "Database#log_yield" do
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
   end
 
-  it "should log message with duration at info level if duration less than log_warn_duration" do
+  deprecated "should log message with duration at info level if duration less than log_warn_duration" do
     @db.log_warn_duration = 1000
     @db.log_yield('blah'){}
     @o.logs.length.must_equal 1
@@ -236,7 +237,7 @@ describe "Database#log_yield" do
     @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
   end
 
-  it "should log message at error level if block raises an error" do
+  deprecated "should log message at error level if block raises an error" do
     @db.log_warn_duration = 0
     proc{@db.log_yield('blah'){raise Sequel::Error, 'adsf'}}.must_raise Sequel::Error
     @o.logs.length.must_equal 1
@@ -245,7 +246,7 @@ describe "Database#log_yield" do
     @o.logs.first.last.must_match(/\ASequel::Error: adsf: blah\z/)
   end
 
-  it "should include args with message if args passed" do
+  deprecated "should include args with message if args passed" do
     @db.log_yield('blah', [1, 2]){}
     @o.logs.length.must_equal 1
     @o.logs.first.length.must_equal 2
@@ -259,6 +260,7 @@ describe "Database#log_connection_yield" do
     @o = Object.new
     def @o.logs; @logs || []; end
     def @o.to_ary; [self]; end
+    def @o.warn(*args); (@logs ||= []) << [:warn] + args; end
     def @o.method_missing(*args); (@logs ||= []) << args; end
     @conn = Object.new
     @db = Sequel::Database.new(:logger=>@o)
@@ -281,11 +283,74 @@ describe "Database#log_connection_yield" do
     @o.logs.first.first.must_equal :info
     @o.logs.first.last.must_match(/\(conn: -?\d+\) some SQL\z/)
   end
+
+  it "should yield to the passed block" do
+    a = nil
+    @db.log_connection_yield('blah', @conn){a = 1}
+    a.must_equal 1
+  end
+
+  it "should raise an exception if a block is not passed" do
+    proc{@db.log_connection_yield('blah', @conn)}.must_raise LocalJumpError
+  end
+
+  it "should log message with duration at info level to all loggers" do
+    @db.log_connection_yield('blah', @conn){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :info
+    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
+  end
+
+  it "should respect sql_log_level setting" do
+    @db.sql_log_level = :debug
+    @db.log_connection_yield('blah', @conn){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :debug
+    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
+  end
+
+  it "should log message with duration at warn level if duration greater than log_warn_duration" do
+    @db.log_warn_duration = 0
+    @db.log_connection_yield('blah', @conn){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :warn
+    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
+  end
+
+  it "should log message with duration at info level if duration less than log_warn_duration" do
+    @db.log_warn_duration = 1000
+    @db.log_connection_yield('blah', @conn){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :info
+    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah\z/)
+  end
+
+  it "should log message at error level if block raises an error" do
+    @db.log_warn_duration = 0
+    proc{@db.log_connection_yield('blah', @conn){raise Sequel::Error, 'adsf'}}.must_raise Sequel::Error
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :error
+    @o.logs.first.last.must_match(/\ASequel::Error: adsf: blah\z/)
+  end
+
+  it "should include args with message if args passed" do
+    @db.log_connection_yield('blah', @conn, [1, 2]){}
+    @o.logs.length.must_equal 1
+    @o.logs.first.length.must_equal 2
+    @o.logs.first.first.must_equal :info
+    @o.logs.first.last.must_match(/\A\(\d\.\d{6}s\) blah; \[1, 2\]\z/)
+  end
 end
 
 describe "Database#uri" do
   before do
     @c = Class.new(Sequel::Database) do
+      def dataset_class_default; Sequel::Dataset end
       set_adapter_scheme :mau
     end
     
@@ -310,6 +375,7 @@ describe "Database.adapter_scheme and #adapter_scheme" do
     Sequel::Database.adapter_scheme.must_be_nil
 
     @c = Class.new(Sequel::Database) do
+      def dataset_class_default; Sequel::Dataset end
       set_adapter_scheme :mau
     end
     
@@ -723,6 +789,18 @@ DatabaseTransactionSpecs = shared_description do
     @db.sqls.must_equal ['BEGIN']
   end
   
+  it "should raise original exception if there is an exception raised when rolling back when using :rollback=>:always" do
+    ec = Class.new(StandardError)
+    meta_def(@db, :database_error_classes){[ec]}
+    meta_def(@db, :log_connection_execute){|c, sql| sql =~ /ROLLBACK/ ? raise(ec, 'bad') : super(c, sql)}
+    begin
+      @db.transaction(:rollback=>:always){}
+    rescue => e
+    end
+    e.must_be_kind_of(ec)
+    @db.sqls.must_equal ['BEGIN']
+  end
+  
   it "should issue ROLLBACK if Sequel::Rollback is called in the transaction" do
     @db.transaction do
       @db.drop_table(:a)
@@ -834,7 +912,7 @@ DatabaseTransactionSpecs = shared_description do
     tr.must_be :empty?
   end
 
-  it "should correctly handle nested transacation use with separate shards" do
+  it "should correctly handle nested transaction use with separate shards" do
     @db.transaction do |c1|
       @db.transaction(:server=>:test) do |c2|
         c1.wont_equal c2

data/spec/core/dataset_spec.rb

@@ -310,10 +310,13 @@ describe "Dataset#unused_table_alias" do
     @ds.from(:test, :test_0).cross_join(:test_1).unused_table_alias(:test).must_equal :test_2
   end
 
-  it "should return an appropriate symbol if given other forms of identifiers" do
-    @ds.unused_table_alias('test').must_equal :test_0
+  with_symbol_splitting "should return an appropriate symbol if given splittable symbol" do
     @ds.unused_table_alias(:b__t___test).must_equal :test_0
     @ds.unused_table_alias(:b__test).must_equal :test_0
+  end
+
+  it "should return an appropriate symbol if given other forms of identifiers" do
+    @ds.unused_table_alias('test').must_equal :test_0
     @ds.unused_table_alias(Sequel.qualify(:b, :test)).must_equal :test_0
     @ds.unused_table_alias(Sequel.expr(:b).as(:test)).must_equal :test_0
     @ds.unused_table_alias(Sequel.expr(:b).as(Sequel.identifier(:test))).must_equal :test_0
@@ -346,65 +349,116 @@ describe "Dataset#where" do
   before do
     @dataset = Sequel.mock[:test]
     @d1 = @dataset.where(:region => 'Asia')
-    @d2 = @dataset.where('region = ?', 'Asia')
-    @d3 = @dataset.where("a = 1")
   end
   
-  it "should just clone if given an empty argument" do
+  if false # SEQUEL5: remove if
+  it "should just clone if given no arguments or block" do
+    proc{@dataset.where}.must_raise Sequel::Error
+  end
+  
+  it "should handle nil argument if block is given" do
+    @d1.where(nil){a}.sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND NULL AND a)"
+  end
+  
+  it "should handle nil argument if block has no existing filter" do
+    @dataset.where(nil).sql.must_equal "SELECT * FROM test WHERE NULL"
+  end
+  end
+  
+  it "should just clone if given an empty array or hash argument" do
     @dataset.where({}).sql.must_equal @dataset.sql
     @dataset.where([]).sql.must_equal @dataset.sql
-    @dataset.where('').sql.must_equal @dataset.sql
 
     @dataset.filter({}).sql.must_equal @dataset.sql
     @dataset.filter([]).sql.must_equal @dataset.sql
+  end
+
+  deprecated "should just clone if given an empty string argument" do
+    @dataset.where('').sql.must_equal @dataset.sql
     @dataset.filter('').sql.must_equal @dataset.sql
   end
   
+  deprecated "should just clone if given no arguments or block" do
+    @dataset.where.sql.must_equal @dataset.sql
+    @dataset.filter.sql.must_equal @dataset.sql
+  end
+  
+  deprecated "should ignore nil argument if block is given" do
+    @d1.where(nil){a}.sql.must_equal @d1.where(:a).sql
+  end
+  
+  deprecated "should ignore nil argument if block has no existing filter" do
+    @dataset.where(nil).sql.must_equal @dataset.sql
+  end
+  
   it "should work with hashes" do
     @dataset.where(:name => 'xyz', :price => 342).select_sql.
       must_match(/WHERE \(\(name = 'xyz'\) AND \(price = 342\)\)|WHERE \(\(price = 342\) AND \(name = 'xyz'\)\)/)
   end
   
-  it "should work with a string with placeholders and arguments for those placeholders" do
+  deprecated "should handle literal strings in arrays in filter methods" do
+    @dataset.where([Sequel.lit("a")]).sql.must_equal 'SELECT * FROM test WHERE (a)'
+  end
+
+  deprecated "should work with a string with placeholders and arguments for those placeholders" do
     @dataset.where('price < ? AND id in ?', 100, [1, 2, 3]).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
   end
   
-  it "should not modify passed array with placeholders" do
+  it "should work with a placeholder literal string" do
+    @dataset.where(Sequel.lit('price < ? AND id in ?', 100, [1, 2, 3])).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
+  end
+  
+  deprecated "should not modify passed array with placeholders" do
     a = ['price < ? AND id in ?', 100, 1, 2, 3]
     b = a.dup
     @dataset.where(a)
     b.must_equal a
   end
 
-  it "should work with strings (custom SQL expressions)" do
-    @dataset.where('(a = 1 AND b = 2)').select_sql.
-      must_equal "SELECT * FROM test WHERE ((a = 1 AND b = 2))"
+  deprecated "should work with strings (custom SQL expressions)" do
+    @dataset.where('(a = 1 AND b = 2)').select_sql.must_equal "SELECT * FROM test WHERE ((a = 1 AND b = 2))"
+  end
+    
+  it "should work with literal strings" do
+    @dataset.where(Sequel.lit('(a = 1 AND b = 2)')).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1 AND b = 2))"
+  end
+    
+  deprecated "should work with a string with named placeholders and a hash of placeholder value arguments" do
+    @dataset.where('price < :price AND id in :ids', :price=>100, :ids=>[1, 2, 3]).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
   end
     
-  it "should work with a string with named placeholders and a hash of placeholder value arguments" do
-    @dataset.where('price < :price AND id in :ids', :price=>100, :ids=>[1, 2, 3]).select_sql.
-      must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
+  it "should work with named placeholder strings" do
+    @dataset.where(Sequel.lit('price < :price AND id in :ids', :price=>100, :ids=>[1, 2, 3])).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
   end
     
-  it "should not modify passed array with named placeholders" do
+  deprecated "should not modify passed array with named placeholders" do
     a = ['price < :price AND id in :ids', {:price=>100}]
     b = a.dup
     @dataset.where(a)
     b.must_equal a
   end
 
-  it "should not replace named placeholders that don't exist in the hash" do
+  deprecated "should not replace named placeholders that don't exist in the hash" do
     @dataset.where('price < :price AND id in :ids', :price=>100).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in :ids)"
   end
   
-  it "should raise an error for a mismatched number of placeholders" do
+  it "should not replace named placeholders that don't exist in the hash when using placeholder strings" do
+    @dataset.where(Sequel.lit('price < :price AND id in :ids', :price=>100)).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in :ids)"
+  end
+  
+  deprecated "should raise an error for a mismatched number of placeholders" do
     proc{@dataset.where('price < ? AND id in ?', 100).select_sql}.must_raise(Sequel::Error)
     proc{@dataset.where('price < ? AND id in ?', 100, [1, 2, 3], 4).select_sql}.must_raise(Sequel::Error)
   end
 
+  it "should raise an error for a mismatched number of placeholders in placeholder literal strings" do
+    proc{@dataset.where(Sequel.lit('price < ? AND id in ?', 100)).select_sql}.must_raise(Sequel::Error)
+    proc{@dataset.where(Sequel.lit('price < ? AND id in ?', 100, [1, 2, 3], 4)).select_sql}.must_raise(Sequel::Error)
+  end
+
   it "should handle placeholders when using an array" do
-    @dataset.where(Sequel.lit(['price < ', ' AND id in '], 100, [1, 2, 3])).select_sql.must_equal "SELECT * FROM test WHERE price < 100 AND id in (1, 2, 3)"
-    @dataset.where(Sequel.lit(['price < ', ' AND id in '], 100)).select_sql.must_equal "SELECT * FROM test WHERE price < 100 AND id in "
+    @dataset.where(Sequel.lit(['price < ', ' AND id in '], 100, [1, 2, 3])).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
+    @dataset.where(Sequel.lit(['price < ', ' AND id in '], 100)).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in )"
   end
 
   it "should handle a mismatched number of placeholders when using an array" do
@@ -412,24 +466,49 @@ describe "Dataset#where" do
     proc{@dataset.where(Sequel.lit(['price < ', ' AND id in '], 100, [1, 2, 3], 4)).select_sql}.must_raise(Sequel::Error)
   end
   
-  it "should handle partial names" do
+  deprecated "should handle partial names" do
     @dataset.where('price < :price AND id = :p', :p=>2, :price=>100).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id = 2)"
   end
 
-  it "should handle ::cast syntax when no parameters are supplied" do
+  it "should handle partial names when using placeholder literal strings" do
+    @dataset.where(Sequel.lit('price < :price AND id = :p', :p=>2, :price=>100)).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id = 2)"
+  end
+
+  deprecated "should handle ::cast syntax when no parameters are supplied" do
     @dataset.where('price::float = 10', {}).select_sql.must_equal "SELECT * FROM test WHERE (price::float = 10)"
     @dataset.where('price::float ? 10', {}).select_sql.must_equal "SELECT * FROM test WHERE (price::float ? 10)"
   end
 
+  it "should handle ::cast syntax when no parameters are supplied when using placeholder strings" do
+    @dataset.where(Sequel.lit('price::float = 10', {})).select_sql.must_equal "SELECT * FROM test WHERE (price::float = 10)"
+    @dataset.where(Sequel.lit('price::float ? 10', {})).select_sql.must_equal "SELECT * FROM test WHERE (price::float ? 10)"
+  end
+
   it "should affect select, delete and update statements" do
     @d1.select_sql.must_equal "SELECT * FROM test WHERE (region = 'Asia')"
     @d1.delete_sql.must_equal "DELETE FROM test WHERE (region = 'Asia')"
     @d1.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (region = 'Asia')"
+  end
     
+  deprecated "should affect select, delete and update statements when using strings" do
+    @d2 = @dataset.where('region = ?', 'Asia')
+    @d2.select_sql.must_equal "SELECT * FROM test WHERE (region = 'Asia')"
+    @d2.delete_sql.must_equal "DELETE FROM test WHERE (region = 'Asia')"
+    @d2.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (region = 'Asia')"
+    
+    @d3 = @dataset.where("a = 1")
+    @d3.select_sql.must_equal "SELECT * FROM test WHERE (a = 1)"
+    @d3.delete_sql.must_equal "DELETE FROM test WHERE (a = 1)"
+    @d3.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (a = 1)"
+  end
+  
+  it "should affect select, delete and update statements when using literal strings" do
+    @d2 = @dataset.where(Sequel.lit('region = ?', 'Asia'))
     @d2.select_sql.must_equal "SELECT * FROM test WHERE (region = 'Asia')"
     @d2.delete_sql.must_equal "DELETE FROM test WHERE (region = 'Asia')"
     @d2.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (region = 'Asia')"
     
+    @d3 = @dataset.where(Sequel.lit("a = 1"))
     @d3.select_sql.must_equal "SELECT * FROM test WHERE (a = 1)"
     @d3.delete_sql.must_equal "DELETE FROM test WHERE (a = 1)"
     @d3.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (a = 1)"
@@ -437,27 +516,48 @@ describe "Dataset#where" do
   
   it "should be composable using AND operator (for scoping)" do
     @d1.where(:size => 'big').select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (size = 'big'))"
-    @d1.where('population > 1000').select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (population > 1000))"
-    @d1.where('(a > 1) OR (b < 2)').select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND ((a > 1) OR (b < 2)))"
-    @d1.where('GDP > ?', 1000).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > 1000))"
+    @d1.where{population > 1000}.select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (population > 1000))"
+    @d1.where{(a > 1) | (b < 2)}.select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND ((a > 1) OR (b < 2)))"
+    @d1.where{GDP() > 1000}.select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > 1000))"
+  end
+
+  deprecated "should be composable using AND operator (for scoping) when using strings" do
+    @d2 = @dataset.where('region = ?', 'Asia')
     @d2.where('GDP > ?', 1000).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > 1000))"
     @d2.where(:name => ['Japan', 'China']).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (name IN ('Japan', 'China')))"
     @d2.where('GDP > ?').select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > ?))"
+
+    @d3 = @dataset.where("a = 1")
     @d3.where('b = 2').select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (b = 2))"
     @d3.where(:c => 3).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (c = 3))"
     @d3.where('d = ?', 4).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (d = 4))"
   end
       
-  it "should be composable using AND operator (for scoping) with block" do
-    @d3.where{e < 5}.select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
+  it "should be composable using AND operator (for scoping) when using literal strings" do
+    @d2 = @dataset.where(Sequel.lit('region = ?', 'Asia'))
+    @d2.where(Sequel.lit('GDP > ?', 1000)).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > 1000))"
+    @d2.where(:name => ['Japan', 'China']).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (name IN ('Japan', 'China')))"
+    @d2.where(Sequel.lit('GDP > ?')).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > ?))"
+
+    @d3 = @dataset.where(Sequel.lit("a = 1"))
+    @d3.where(Sequel.lit('b = 2')).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (b = 2))"
+    @d3.where(:c => 3).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (c = 3))"
+    @d3.where(Sequel.lit('d = ?', 4)).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (d = 4))"
+  end
+      
+  deprecated "should be composable using AND operator (for scoping) with block and string" do
+    @dataset.where("a = 1").where{e < 5}.select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
+  end
+  
+  it "should be composable using AND operator (for scoping) with block and literal string" do
+    @dataset.where(Sequel.lit("a = 1")).where{e < 5}.select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
   end
   
   it "should accept ranges" do
     @dataset.filter(:id => 4..7).sql.must_equal 'SELECT * FROM test WHERE ((id >= 4) AND (id <= 7))'
     @dataset.filter(:id => 4...7).sql.must_equal 'SELECT * FROM test WHERE ((id >= 4) AND (id < 7))'
-
-    @dataset.filter(:table__id => 4..7).sql.must_equal 'SELECT * FROM test WHERE ((table.id >= 4) AND (table.id <= 7))'
-    @dataset.filter(:table__id => 4...7).sql.must_equal 'SELECT * FROM test WHERE ((table.id >= 4) AND (table.id < 7))'
+    @dataset.filter(:id => 4..7).sql.must_equal 'SELECT * FROM test WHERE ((id >= 4) AND (id <= 7))'
+    @dataset.filter(:id => 4...7).sql.must_equal 'SELECT * FROM test WHERE ((id >= 4) AND (id < 7))'
   end
 
   it "should accept nil" do
@@ -465,7 +565,7 @@ describe "Dataset#where" do
   end
 
   it "should accept a subquery" do
-    @dataset.filter('gdp > ?', @d1.select(Sequel.function(:avg, :gdp))).sql.must_equal "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
+    @dataset.filter{|o| o.gdp > @d1.select(Sequel.function(:avg, :gdp))}.sql.must_equal "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
   end
   
   it "should handle all types of IN/NOT IN queries with empty arrays" do
@@ -578,16 +678,16 @@ describe "Dataset#where" do
     x = nil
     @dataset.filter{|r| x = r; false}
     x.must_be_kind_of(Sequel::SQL::VirtualRow)
-    @dataset.filter{|r| ((r.name < 'b') & {r.table__id => 1}) | r.is_active(r.blah, r.xx, r.x__y_z)}.sql.
-      must_equal "SELECT * FROM test WHERE (((name < 'b') AND (table.id = 1)) OR is_active(blah, xx, x.y_z))"
+    @dataset.filter{|r| ((r.name < 'b') & {r.table_id => 1}) | r.is_active(r.blah, r.xx, r.x_y_z)}.sql.
+      must_equal "SELECT * FROM test WHERE (((name < 'b') AND (table_id = 1)) OR is_active(blah, xx, x_y_z))"
   end
 
   it "should instance_eval the block in the context of a VirtualRow if the block doesn't request an argument" do
     x = nil
     @dataset.filter{x = self; false}
     x.must_be_kind_of(Sequel::SQL::VirtualRow)
-    @dataset.filter{((name < 'b') & {table__id => 1}) | is_active(blah, xx, x__y_z)}.sql.
-      must_equal "SELECT * FROM test WHERE (((name < 'b') AND (table.id = 1)) OR is_active(blah, xx, x.y_z))"
+    @dataset.filter{((name < 'b') & {table_id => 1}) | is_active(blah, xx, x_y_z)}.sql.
+      must_equal "SELECT * FROM test WHERE (((name < 'b') AND (table_id = 1)) OR is_active(blah, xx, x_y_z))"
   end
 
   it "should handle arbitrary objects" do
@@ -620,9 +720,12 @@ describe "Dataset#or" do
     @dataset.or(:a => 1).sql.must_equal 'SELECT * FROM test'
   end
   
-  it "should just clone if given an empty argument" do
+  it "should just clone if given an empty array or hash argument" do
     @d1.or({}).sql.must_equal @d1.sql
     @d1.or([]).sql.must_equal @d1.sql
+  end
+
+  deprecated "should just clone if given an empty string argument" do
     @d1.or('').sql.must_equal @d1.sql
   end
   
@@ -630,8 +733,15 @@ describe "Dataset#or" do
     @d1.or(:y => 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) OR (y = 2))'
   end
   
-  it "should accept all forms of filters" do
+  deprecated "should accept string filters" do
     @d1.or('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) OR (y > 2))'
+  end
+
+  it "should accept literal string filters" do
+    @d1.or(Sequel.lit('y > ?', 2)).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) OR (y > 2))'
+  end
+
+  it "should accept expression filters" do
     @d1.or(Sequel.expr(:yy) > 3).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end    
 
@@ -663,8 +773,15 @@ describe "Dataset#and" do
     @d1.and(:y => 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y = 2))'
   end
   
-  it "should accept different types of filters" do
+  deprecated "should accept string filters with placeholders" do
     @d1.and('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
+  end
+
+  it "should accept placeholder literal string filters" do
+    @d1.and(Sequel.lit('y > ?', 2)).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
+  end
+
+  it "should accept expression filters" do
     @d1.and(Sequel.expr(:yy) > 3).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
       
@@ -693,14 +810,22 @@ describe "Dataset#exclude" do
                                 /WHERE \(\(name != 'Japan'\) OR \(region != 'Asia'\)\)/))
   end
 
-  it "should parenthesize a single string condition correctly" do
+  deprecated "should parenthesize a single string condition correctly" do
     @dataset.exclude("region = 'Asia' AND name = 'Japan'").select_sql.must_equal "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
   end
 
-  it "should parenthesize an array condition correctly" do
+  deprecated "should parenthesize an array condition correctly" do
     @dataset.exclude('region = ? AND name = ?', 'Asia', 'Japan').select_sql.must_equal "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
   end
 
+  it "should parenthesize a single literal string condition correctly" do
+    @dataset.exclude(Sequel.lit("region = 'Asia' AND name = 'Japan'")).select_sql.must_equal "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
+  end
+
+  it "should parenthesize a placeholder literal string condition correctly" do
+    @dataset.exclude(Sequel.lit('region = ? AND name = ?', 'Asia', 'Japan')).select_sql.must_equal "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
+  end
+
   it "should correctly parenthesize when it is used twice" do
     @dataset.exclude(:region => 'Asia').exclude(:name => 'Japan').select_sql.must_equal "SELECT * FROM test WHERE ((region != 'Asia') AND (name != 'Japan'))"
   end
@@ -763,16 +888,23 @@ describe "Dataset#having" do
     @grouped = @dataset.group(:region).select(:region, Sequel.function(:sum, :population), Sequel.function(:avg, :gdp))
   end
 
-  it "should just clone if given an empty argument" do
+  it "should just clone if given an empty array or hash argument" do
     @dataset.having({}).sql.must_equal @dataset.sql
     @dataset.having([]).sql.must_equal @dataset.sql
+  end
+
+  deprecated "should just clone if given an empty string argument" do
     @dataset.having('').sql.must_equal @dataset.sql
   end
   
-  it "should affect select statements" do
+  deprecated "should handle string arguments" do
     @grouped.having('sum(population) > 10').select_sql.must_equal "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 
+  it "should handle literal string arguments" do
+    @grouped.having(Sequel.lit('sum(population) > 10')).select_sql.must_equal "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING (sum(population) > 10)"
+  end
+
   it "should support proc expressions" do
     @grouped.having{Sequel.function(:sum, :population) > 10}.sql.must_equal "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
@@ -908,21 +1040,57 @@ describe "Dataset#as" do
   end
 end
 
-describe "Dataset#literal" do
+describe "Dataset#literal with expressions" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+  
+  it "should convert qualified identifiers into dot notation" do
+    @ds.literal(Sequel[:abc][:def]).must_equal 'abc.def'
+  end
+  
+  it "should convert aliased expressions into SQL AS notation" do
+    @ds.literal(Sequel[:xyz].as(:x)).must_equal 'xyz AS x'
+    @ds.literal(Sequel[:abc][:def].as(:x)).must_equal 'abc.def AS x'
+  end
+  
+  it "should support names with digits" do
+    @ds.literal(:abc2).must_equal 'abc2'
+    @ds.literal(Sequel[:xx][:yy3]).must_equal 'xx.yy3'
+    @ds.literal(Sequel[:ab34][:temp3_4ax]).must_equal 'ab34.temp3_4ax'
+    @ds.literal(Sequel[:x1].as(:y2)).must_equal 'x1 AS y2'
+    @ds.literal(Sequel[:abc2][:def3].as(:ggg4)).must_equal 'abc2.def3 AS ggg4'
+  end
+  
+  it "should support upper case and lower case" do
+    @ds.literal(:ABC).must_equal 'ABC'
+    @ds.literal(Sequel[:Zvashtoy][:aBcD]).must_equal 'Zvashtoy.aBcD'
+  end
+
+  it "should support spaces inside column names" do
+    @ds = @ds.with_quote_identifiers(true)
+    @ds.literal(:"AB C").must_equal '"AB C"'
+    @ds.literal(Sequel[:"Zvas htoy"][:"aB cD"]).must_equal '"Zvas htoy"."aB cD"'
+    @ds.literal(Sequel[:"aB cD"].as(:"XX XX")).must_equal '"aB cD" AS "XX XX"'
+    @ds.literal(Sequel[:"Zva shtoy"][:"aB cD"].as("XX XX")).must_equal '"Zva shtoy"."aB cD" AS "XX XX"'
+  end
+end
+
+describe "Dataset#literal with splittable symbols" do
   before do
     @ds = Sequel.mock.dataset
   end
   
-  it "should convert qualified symbol notation into dot notation" do
+  with_symbol_splitting "should convert qualified symbol notation into dot notation" do
     @ds.literal(:abc__def).must_equal 'abc.def'
   end
   
-  it "should convert AS symbol notation into SQL AS notation" do
+  with_symbol_splitting "should convert AS symbol notation into SQL AS notation" do
     @ds.literal(:xyz___x).must_equal 'xyz AS x'
     @ds.literal(:abc__def___x).must_equal 'abc.def AS x'
   end
   
-  it "should support names with digits" do
+  with_symbol_splitting "should support names with digits" do
     @ds.literal(:abc2).must_equal 'abc2'
     @ds.literal(:xx__yy3).must_equal 'xx.yy3'
     @ds.literal(:ab34__temp3_4ax).must_equal 'ab34.temp3_4ax'
@@ -930,12 +1098,12 @@ describe "Dataset#literal" do
     @ds.literal(:abc2__def3___ggg4).must_equal 'abc2.def3 AS ggg4'
   end
   
-  it "should support upper case and lower case" do
+  with_symbol_splitting "should support upper case and lower case" do
     @ds.literal(:ABC).must_equal 'ABC'
     @ds.literal(:Zvashtoy__aBcD).must_equal 'Zvashtoy.aBcD'
   end
 
-  it "should support spaces inside column names" do
+  with_symbol_splitting "should support spaces inside column names" do
     @ds = @ds.with_quote_identifiers(true)
     @ds.literal(:"AB C").must_equal '"AB C"'
     @ds.literal(:"Zvas htoy__aB cD").must_equal '"Zvas htoy"."aB cD"'
@@ -980,6 +1148,9 @@ describe "Dataset#literal" do
 
   it "should literalize symbols as column references" do
     @dataset.literal(:name).must_equal "name"
+  end
+
+  with_symbol_splitting "should literalize symbols with embedded qualifiers as column references" do
     @dataset.literal(:items__name).must_equal "items.name"
     @dataset.literal(:"items__na#m$e").must_equal "items.na#m$e"
   end
@@ -1023,6 +1194,13 @@ describe "Dataset#literal" do
     @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).must_equal "'2010-01-02 03:04:05.500'"
   end
   
+  it "should literalize times properly for databases with different time and timestamp precision" do
+    @dataset = @dataset.with_extend{def timestamp_precision; 3 end; def sqltime_precision; 6 end}
+    @dataset.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).must_equal "'01:02:03.500000'"
+    @dataset.literal(Time.local(2010, 1, 2, 3, 4, 5, 500000)).must_equal "'2010-01-02 03:04:05.500'"
+    @dataset.literal(DateTime.new(2010, 1, 2, 3, 4, Rational(55, 10))).must_equal "'2010-01-02 03:04:05.500'"
+  end
+  
   it "should literalize Date properly" do
     d = Date.today
     s = d.strftime("'%Y-%m-%d'")
@@ -1143,7 +1321,7 @@ describe "Dataset#from" do
     @dataset.select_sql.must_equal "SELECT * FROM DEFFROM"
   end
 
-  it "should accept :schema__table___alias symbol format" do
+  with_symbol_splitting "should accept :schema__table___alias symbol format" do
     @dataset.from(:abc__def).select_sql.must_equal "SELECT * FROM abc.def"
     @dataset.from(:a_b__c).select_sql.must_equal "SELECT * FROM a_b.c"
     @dataset.from(:'#__#').select_sql.must_equal 'SELECT * FROM #.#'
@@ -1155,7 +1333,7 @@ describe "Dataset#from" do
     @dataset.from(:'#___#').select_sql.must_equal 'SELECT * FROM # AS #'
   end
 
-  it "should not handle :foo__schema__table___alias specially" do
+  with_symbol_splitting "should not handle multi level qualification in embedded symbols specially" do
     @dataset.from(:foo__schema__table___alias).select_sql.must_equal "SELECT * FROM foo.schema__table AS alias"
   end
 
@@ -1176,15 +1354,20 @@ describe "Dataset#select" do
 
   it "should accept variable arity" do
     @d.select(:name).sql.must_equal 'SELECT name FROM test'
-    @d.select(:a, :b, :test__c).sql.must_equal 'SELECT a, b, test.c FROM test'
+    @d.select(:a, :b, Sequel[:test][:c]).sql.must_equal 'SELECT a, b, test.c FROM test'
+  end
+  
+  with_symbol_splitting "should accept symbols with embedded qualification and aliasing" do
+    @d.select(:test__cc).sql.must_equal 'SELECT test.cc FROM test'
+    @d.select(:test___cc).sql.must_equal 'SELECT test AS cc FROM test'
+    @d.select(:test__name___n).sql.must_equal 'SELECT test.name AS n FROM test'
   end
   
   it "should accept symbols and literal strings" do
     @d.select(Sequel.lit('aaa')).sql.must_equal 'SELECT aaa FROM test'
     @d.select(:a, Sequel.lit('b')).sql.must_equal 'SELECT a, b FROM test'
-    @d.select(:test__cc, Sequel.lit('test.d AS e')).sql.must_equal 'SELECT test.cc, test.d AS e FROM test'
-    @d.select(Sequel.lit('test.d AS e'), :test__cc).sql.must_equal 'SELECT test.d AS e, test.cc FROM test'
-    @d.select(:test__name___n).sql.must_equal 'SELECT test.name AS n FROM test'
+    @d.select(:test, Sequel.lit('test.d AS e')).sql.must_equal 'SELECT test, test.d AS e FROM test'
+    @d.select(Sequel.lit('test.d AS e'), :test).sql.must_equal 'SELECT test.d AS e, test FROM test'
   end
   
   it "should accept ColumnAlls" do
@@ -1192,6 +1375,10 @@ describe "Dataset#select" do
   end
   
   it "should accept QualifiedIdentifiers" do
+    @d.select(Sequel.expr(Sequel[:test][:name]).as(:n)).sql.must_equal 'SELECT test.name AS n FROM test'
+  end
+
+  with_symbol_splitting "should accept qualified identifiers in symbols in expressions" do
     @d.select(Sequel.expr(:test__name).as(:n)).sql.must_equal 'SELECT test.name AS n FROM test'
   end
 
@@ -1214,7 +1401,7 @@ describe "Dataset#select" do
   
   it "should accept arbitrary objects and literalize them correctly" do
     @d.select(1, :a, 't').sql.must_equal "SELECT 1, a, 't' FROM test"
-    @d.select(nil, Sequel.function(:sum, :t), :x___y).sql.must_equal "SELECT NULL, sum(t), x AS y FROM test"
+    @d.select(nil, Sequel.function(:sum, :t), Sequel[:x].as(:y)).sql.must_equal "SELECT NULL, sum(t), x AS y FROM test"
     @d.select(nil, 1, Sequel.as(:x, :y)).sql.must_equal "SELECT NULL, 1, x AS y FROM test"
   end
 
@@ -1240,6 +1427,10 @@ describe "Dataset#select_group" do
 
   it "should set both SELECT and GROUP" do
     @d.select_group(:name).sql.must_equal 'SELECT name FROM test GROUP BY name'
+    @d.select_group(:a, Sequel[:b][:c], Sequel[:d].as(:e)).sql.must_equal 'SELECT a, b.c, d AS e FROM test GROUP BY a, b.c, d'
+  end
+
+  with_symbol_splitting "should set both SELECT and GROUP when using splittable symbols" do
     @d.select_group(:a, :b__c, :d___e).sql.must_equal 'SELECT a, b.c, d AS e FROM test GROUP BY a, b.c, d'
   end
 
@@ -1275,11 +1466,11 @@ describe "Dataset#select_all" do
     @d.select_all(:test, :foo).sql.must_equal 'SELECT test.*, foo.* FROM test'
   end
   
-  it "should work correctly with qualified symbols" do
+  with_symbol_splitting "should work correctly with qualified symbols" do
     @d.select_all(:sch__test).sql.must_equal 'SELECT sch.test.* FROM test'
   end
   
-  it "should work correctly with aliased symbols" do
+  with_symbol_splitting "should work correctly with aliased symbols" do
     @d.select_all(:test___al).sql.must_equal 'SELECT al.* FROM test'
     @d.select_all(:sch__test___al).sql.must_equal 'SELECT al.* FROM test'
   end
@@ -1296,10 +1487,15 @@ describe "Dataset#select_all" do
     @d.select_all(Sequel.expr(:test).as(:al)).sql.must_equal 'SELECT al.* FROM test'
   end
   
-  it "should work correctly with SQL::JoinClauses" do
+  with_symbol_splitting "should work correctly with SQL::JoinClauses with splittable symbols" do
     d = @d.cross_join(:foo).cross_join(:test___al)
     @d.select_all(*d.opts[:join]).sql.must_equal 'SELECT foo.*, al.* FROM test'
   end
+  
+  it "should work correctly with SQL::JoinClauses" do
+    d = @d.cross_join(:foo).cross_join(Sequel[:test].as(:al))
+    @d.select_all(*d.opts[:join]).sql.must_equal 'SELECT foo.*, al.* FROM test'
+  end
 end
 
 describe "Dataset#select_more" do
@@ -1734,10 +1930,14 @@ describe "Dataset#qualified_column_name" do
     @dataset.literal(@dataset.send(:qualified_column_name, :b1, :items)).must_equal 'items.b1'
   end
 
-  it "should not changed the qualifed column's table if given a qualified symbol" do
+  with_symbol_splitting "should not changed the qualifed column's table if given a qualified symbol" do
     @dataset.literal(@dataset.send(:qualified_column_name, :ccc__b, :items)).must_equal 'ccc.b'
   end
 
+  it "should not changed the qualifed column's table if given a qualified identifier" do
+    @dataset.literal(@dataset.send(:qualified_column_name, Sequel[:ccc][:b], :items)).must_equal 'ccc.b'
+  end
+
   it "should handle an aliased identifier" do
     @dataset.literal(@dataset.send(:qualified_column_name, :ccc, Sequel.expr(:items).as(:i))).must_equal 'i.ccc'
   end
@@ -2018,6 +2218,11 @@ describe "Dataset#group_and_count" do
   end
 
   it "should format column aliases in the select clause but not in the group clause" do
+    @ds.group_and_count(Sequel[:name].as(:n)).sql.must_equal "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
+    @ds.group_and_count(Sequel[:name][:n]).sql.must_equal "SELECT name.n, count(*) AS count FROM test GROUP BY name.n"
+  end
+
+  with_symbol_splitting "should format column aliases in the select clause but not in the group clause when using splittable symbols" do
     @ds.group_and_count(:name___n).sql.must_equal "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
     @ds.group_and_count(:name__n).sql.must_equal "SELECT name.n, count(*) AS count FROM test GROUP BY name.n"
   end
@@ -2066,23 +2271,35 @@ describe "Dataset#first_source_alias" do
     @ds = Sequel.mock.dataset
   end
   
+  it "should be the entire first source if not aliased" do
+    deprecated do
+      # SEQUEL5: Remove deprecation block, but keep code
+      @ds.from(:s__t).first_source_alias.must_equal :s__t
+    end
+  end
+  
+  with_symbol_splitting "should be the alias if aliased when using symbol splitting" do
+    @ds.from(:t___a).first_source_alias.must_equal :a
+    @ds.from(:s__t___a).first_source_alias.must_equal :a
+  end
+  
+  with_symbol_splitting "should be aliased as first_source when using symbol splitting" do
+    @ds.from(:s__t___a).first_source.must_equal :a
+  end
+  
   it "should be the entire first source if not aliased" do
     @ds.from(:t).first_source_alias.must_equal :t
     @ds.from(Sequel.identifier(:t__a)).first_source_alias.must_equal Sequel.identifier(:t__a)
-    @ds.from(:s__t).first_source_alias.must_equal :s__t
     @ds.from(Sequel.qualify(:s, :t)).first_source_alias.must_equal Sequel.qualify(:s, :t)
   end
   
   it "should be the alias if aliased" do
-    @ds.from(:t___a).first_source_alias.must_equal :a
-    @ds.from(:s__t___a).first_source_alias.must_equal :a
     @ds.from(Sequel.expr(:t).as(:a)).first_source_alias.must_equal :a
   end
   
   it "should be aliased as first_source" do
     @ds.from(:t).first_source.must_equal :t
     @ds.from(Sequel.identifier(:t__a)).first_source.must_equal Sequel.identifier(:t__a)
-    @ds.from(:s__t___a).first_source.must_equal :a
     @ds.from(Sequel.expr(:t).as(:a)).first_source.must_equal :a
   end
   
@@ -2098,14 +2315,23 @@ describe "Dataset#first_source_table" do
   
   it "should be the entire first source if not aliased" do
     @ds.from(:t).first_source_table.must_equal :t
+    deprecated do
+      # SEQUEL5: Remove deprecation block, but keep code
+      @ds.from(:s__t).first_source_table.must_equal :s__t
+    end
+  end
+  
+  it "should be the entire first source if not aliased" do
     @ds.from(Sequel.identifier(:t__a)).first_source_table.must_equal Sequel.identifier(:t__a)
-    @ds.from(:s__t).first_source_table.must_equal :s__t
     @ds.from(Sequel.qualify(:s, :t)).first_source_table.must_equal Sequel.qualify(:s, :t)
   end
   
-  it "should be the unaliased part if aliased" do
+  with_symbol_splitting "should be the unaliased part if aliased symbols with embedded aliasing" do
     @ds.literal(@ds.from(:t___a).first_source_table).must_equal "t"
     @ds.literal(@ds.from(:s__t___a).first_source_table).must_equal "s.t"
+  end
+  
+  it "should be the unaliased part if aliased" do
     @ds.literal(@ds.from(Sequel.expr(:t).as(:a)).first_source_table).must_equal "t"
   end
   
@@ -2184,6 +2410,10 @@ describe "Dataset#join_table" do
   end
   
   it "should support multiple joins" do
+    @d.join_table(:inner, :b, :items_id=>:id).join_table(:left_outer, :c, :b_id => Sequel[:b][:id]).sql.must_equal 'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
+  end
+
+  with_symbol_splitting "should support multiple joins with splittable symbols" do
     @d.join_table(:inner, :b, :items_id=>:id).join_table(:left_outer, :c, :b_id => :b__id).sql.must_equal 'SELECT * FROM "items" INNER JOIN "b" ON ("b"."items_id" = "items"."id") LEFT OUTER JOIN "c" ON ("c"."b_id" = "b"."id")'
   end
 
@@ -2260,11 +2490,11 @@ describe "Dataset#join_table" do
     @d.from(Sequel.as(:foo, :f)).join_table(:inner, :bar, :id => :bar_id).sql.must_equal 'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
   end
   
-  it "should support implicit schemas in from table symbols" do
+  with_symbol_splitting "should support implicit schemas in from table symbols" do
     @d.from(:s__t).join(:u__v, {:id => :player_id}).sql.must_equal 'SELECT * FROM "s"."t" INNER JOIN "u"."v" ON ("u"."v"."id" = "s"."t"."player_id")'
   end
 
-  it "should support implicit aliases in from table symbols" do
+  with_symbol_splitting "should support implicit aliases in from table symbols" do
     @d.from(:t___z).join(:v___y, {:id => :player_id}).sql.must_equal 'SELECT * FROM "t" AS "z" INNER JOIN "v" AS "y" ON ("y"."id" = "z"."player_id")'
     @d.from(:s__t___z).join(:u__v___y, {:id => :player_id}).sql.must_equal 'SELECT * FROM "s"."t" AS "z" INNER JOIN "u"."v" AS "y" ON ("y"."id" = "z"."player_id")'
   end
@@ -2318,6 +2548,11 @@ describe "Dataset#join_table" do
   end
   
   it "should support joining datasets and aliasing the join" do
+    ds = Sequel.mock.dataset.from(:categories)
+    @d.join_table(:left_outer, ds, {Sequel[:ds][:item_id] => :id}, :table_alias=>:ds).sql.must_equal 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "ds" ON ("ds"."item_id" = "items"."id")'      
+  end
+  
+  with_symbol_splitting "should support joining datasets and aliasing the join when using symbols with embedded qualification" do
     ds = Sequel.mock.dataset.from(:categories)
     @d.join_table(:left_outer, ds, {:ds__item_id => :id}, :table_alias=>:ds).sql.must_equal 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "ds" ON ("ds"."item_id" = "items"."id")'      
   end
@@ -2325,7 +2560,7 @@ describe "Dataset#join_table" do
   it "should support joining multiple datasets" do
     ds = Sequel.mock.dataset.from(:categories)
     ds2 = Sequel.mock.dataset.from(:nodes).select(:name)
-    ds3 = Sequel.mock.dataset.from(:attributes).filter("name = 'blah'")
+    ds3 = Sequel.mock.dataset.from(:attributes).where(Sequel.lit("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.
       must_equal 'SELECT * FROM "items" LEFT OUTER JOIN (SELECT * FROM categories) AS "t1" ON ("t1"."item_id" = "items"."id") ' \
@@ -2333,10 +2568,14 @@ describe "Dataset#join_table" do
       'RIGHT OUTER JOIN (SELECT * FROM attributes WHERE (name = \'blah\')) AS "t3" ON ("t3"."attribute_id" = "t2"."id")'
   end
 
-  it "should support using an SQL String as the join condition" do
+  deprecated "should support using a string as the join condition" do
     @d.join(:categories, "c.item_id = items.id", :table_alias=>:c).sql.must_equal 'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
   end
   
+  it "should support using a literal string as the join condition" do
+    @d.join(:categories, Sequel.lit("c.item_id = items.id"), :table_alias=>:c).sql.must_equal 'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
+  end
+  
   it "should support using a boolean column as the join condition" do
     @d.join(:categories, :active).sql.must_equal 'SELECT * FROM "items" INNER JOIN "categories" ON "active"'
   end
@@ -2374,6 +2613,14 @@ describe "Dataset#join_table" do
     proc{@d.join(:categories, [:id]){|j,lj,js|}}.must_raise(Sequel::Error)
   end
 
+  with_symbol_splitting "should support using a block that receieves the join table/alias, last join table/alias, and array of previous joins when using splittable symbols" do
+    @d.from(:items___i).join(:categories, nil, :table_alias=>:c) do |join_alias, last_join_alias, joins| 
+      join_alias.must_equal :c
+      last_join_alias.must_equal :i
+      joins.must_equal []
+    end
+  end
+
   it "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.must_equal :categories
@@ -2387,12 +2634,6 @@ describe "Dataset#join_table" do
       joins.must_equal []
     end
 
-    @d.from(:items___i).join(:categories, nil, :table_alias=>:c) do |join_alias, last_join_alias, joins| 
-      join_alias.must_equal :c
-      last_join_alias.must_equal :i
-      joins.must_equal []
-    end
-
     @d.join(:blah).join(:categories, nil, :table_alias=>:c) do |join_alias, last_join_alias, joins| 
       join_alias.must_equal :c
       last_join_alias.must_equal :blah
@@ -2434,6 +2675,12 @@ describe "Dataset#join_table" do
   end
 
   it "should prefer explicit aliases over implicit" do
+    @d.from(Sequel[:items].as(:i)).join(Sequel[:categories].as(:c), {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.must_equal 'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
+    @d.from(Sequel.expr(:items).as(:i)).join(Sequel.expr(:categories).as(:c), {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.
+      must_equal 'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
+  end
+  
+  with_symbol_splitting "should prefer explicit aliases over implicit when using splittable symbols" do
     @d.from(:items___i).join(:categories___c, {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.must_equal 'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
     @d.from(Sequel.expr(:items).as(:i)).join(Sequel.expr(:categories).as(:c), {:category_id => :id}, {:table_alias=>:c2, :implicit_qualifier=>:i2}).sql.
       must_equal 'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
@@ -2478,7 +2725,7 @@ describe "Dataset aggregate methods" do
   
   it "should accept qualified columns" do
     5.times do
-      @d.avg(:test__bc).must_equal 'SELECT avg(test.bc) AS avg FROM test LIMIT 1'
+      @d.avg(Sequel[:test][:bc]).must_equal 'SELECT avg(test.bc) AS avg FROM test LIMIT 1'
     end
   end
   
@@ -2586,9 +2833,9 @@ describe "Dataset #first and #last" do
     ds = @d.order(:a).freeze
     5.times do
       ds.first(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1')
-      ds.first('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1')
+      ds.first([[:z, 15]]).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1')
       ds.last(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a DESC LIMIT 1')
-      ds.last('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a DESC LIMIT 1')
+      ds.last([[:z, 15]]).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a DESC LIMIT 1')
     end
   end
   
@@ -2613,10 +2860,30 @@ describe "Dataset #first and #last" do
     ds = @d.order(:name).freeze
     5.times do
       @d.first(:y=>25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
-      ds.last('y = ?', 16){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
+      ds.last(:y=>16){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
     end
   end
   
+  it "should combine block and standard argument filters if argument is a literal string" do
+    ds = @d.order(:name).freeze
+    5.times do
+      @d.first(Sequel.lit('y = 25')){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
+      ds.last(Sequel.lit('y = 16')){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
+      @d.first(Sequel.lit('y = ?', 25)){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
+      ds.last(Sequel.lit('y = ?', 16)){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
+    end
+  end
+
+  deprecated "should combine block and standard argument filters if argument is a string" do
+    ds = @d.order(:name).freeze
+    5.times do
+      @d.first('y = 25'){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
+      ds.last('y = 16'){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
+      @d.first('y = ?', 25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
+      ds.last('y = ?', 16){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
+    end
+  end
+
   it "should filter and return an array of records if an Integer argument is provided and a block is given" do
     ds = @d.order(:a).freeze
     5.times do
@@ -2657,7 +2924,7 @@ describe "Dataset #first!" do
 
   it "should return the first! matching record if argument is not an Integer" do
     @d.order(:a).first!(:z => 26).must_equal(:s=>'SELECT * FROM test WHERE (z = 26) ORDER BY a LIMIT 1')
-    @d.order(:a).first!('z = ?', 15).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1')
+    @d.order(:a).first!(Sequel.lit('z = ?', 15)).must_equal(:s=>'SELECT * FROM test WHERE (z = 15) ORDER BY a LIMIT 1')
   end
   
   it "should set the limit and return an array of records if the given number is > 1" do
@@ -2902,7 +3169,7 @@ describe "Dataset#get" do
   it "should work with aliased fields" do
     @d.freeze
     5.times do
-      @d.get(Sequel.expr(:x__b).as(:name)).must_equal "SELECT x.b AS name FROM test LIMIT 1"
+      @d.get(Sequel.expr(Sequel[:x][:b]).as(:name)).must_equal "SELECT x.b AS name FROM test LIMIT 1"
     end
   end
   
@@ -2914,7 +3181,7 @@ describe "Dataset#get" do
   end
   
   it "should accept a block that yields a virtual row" do
-    @d.get{|o| o.x__b.as(:name)}.must_equal "SELECT x.b AS name FROM test LIMIT 1"
+    @d.get{|o| o.x_b.as(:name)}.must_equal "SELECT x_b AS name FROM test LIMIT 1"
     @d.get{x(1).as(:name)}.must_equal "SELECT x(1) AS name FROM test LIMIT 1"
   end
   
@@ -2937,26 +3204,32 @@ describe "Dataset#get" do
     @d.get([:name]).must_equal ['SELECT name FROM test LIMIT 1']
   end
   
-  it "should handle an array with aliases" do
+  it "should handle an array with aliased expressions" do
     @d = @d.with_fetch(:name=>1, :abc=>2)
-    @d.get([:n___name, Sequel.as(:a, :abc)]).must_equal [1, 2]
+    @d.get([Sequel[:n].as(:name), Sequel.as(:a, :abc)]).must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT n AS name, a AS abc FROM test LIMIT 1']
   end
   
+  with_symbol_splitting "should handle an array with symbols with embedded aliases" do
+    @d = @d.with_fetch(:name=>1, :abc=>2)
+    @d.get([:n___name, :a__b___abc]).must_equal [1, 2]
+    @d.db.sqls.must_equal ['SELECT n AS name, a.b AS abc FROM test LIMIT 1']
+  end
+  
   it "should raise an Error if an alias cannot be determined" do
     proc{@d.with_fetch(:name=>1, :abc=>2).get([Sequel.+(:a, 1), :a])}.must_raise(Sequel::Error)
   end
   
   it "should support an array of expressions in a virtual row" do
     @d = @d.with_fetch(:name=>1, :abc=>2)
-    @d.get{[name, n__abc]}.must_equal [1, 2]
+    @d.get{[name, n[abc]]}.must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT name, n.abc FROM test LIMIT 1']
   end
   
   it "should work with static SQL" do
     @d.with_sql('SELECT foo').get(:name).must_equal "SELECT foo"
     @d = @d.with_fetch(:name=>1, :abc=>2)
-    @d.with_sql('SELECT foo').get{[name, n__abc]}.must_equal [1, 2]
+    @d.with_sql('SELECT foo').get{[name, n[abc]]}.must_equal [1, 2]
     @d.db.sqls.must_equal ['SELECT foo'] * 2
   end
 
@@ -3023,7 +3296,7 @@ describe "Dataset#columns" do
     @dataset.db.sqls.must_equal ['SELECT * FROM items LIMIT 1']
     @dataset.columns.must_equal [:a]
     @dataset.db.sqls.must_equal []
-    ds = @dataset.select{foo{}}
+    ds = @dataset.select{foo.function}
     ds.columns.must_equal [:b]
     @dataset.db.sqls.must_equal ['SELECT foo() FROM items LIMIT 1']
   end
@@ -3251,7 +3524,7 @@ describe "Dataset#multi_insert" do
       'COMMIT']
   end
   
-  it "should handle different formats for tables" do
+  with_symbol_splitting "should handle splittable symbols for tables" do
     @ds = @ds.from(:sch__tab)
     @ds.multi_insert(@list)
     @db.sqls.must_equal ['BEGIN',
@@ -3259,7 +3532,9 @@ describe "Dataset#multi_insert" do
       "INSERT INTO sch.tab (name) VALUES ('def')",
       "INSERT INTO sch.tab (name) VALUES ('ghi')",
       'COMMIT']
+  end
 
+  it "should handle SQL::QualifiedIdentifier for tables" do
     @ds = @ds.from(Sequel.qualify(:sch, :tab))
     @ds.multi_insert(@list)
     @db.sqls.must_equal ['BEGIN',
@@ -3267,7 +3542,9 @@ describe "Dataset#multi_insert" do
       "INSERT INTO sch.tab (name) VALUES ('def')",
       "INSERT INTO sch.tab (name) VALUES ('ghi')",
       'COMMIT']
+  end
 
+  it "should handle SQL::Identifier for tables" do
     @ds = @ds.from(Sequel.identifier(:sch__tab))
     @ds.multi_insert(@list)
     @db.sqls.must_equal ['BEGIN',
@@ -3320,11 +3597,19 @@ describe "Dataset#update_sql" do
     @ds = Sequel.mock.dataset.from(:items)
   end
   
-  it "should accept strings" do
+  deprecated "should accept strings" do
     @ds.update_sql("a = b").must_equal "UPDATE items SET a = b"
   end
   
-  it "should handle implicitly qualified symbols" do
+  it "should accept literal strings" do
+    @ds.update_sql(Sequel.lit("a = b")).must_equal "UPDATE items SET a = b"
+  end
+  
+  it "should handle qualified identifiers" do
+    @ds.update_sql(Sequel[:items][:a]=>:b).must_equal "UPDATE items SET items.a = b"
+  end
+  
+  with_symbol_splitting "should handle implicitly qualified symbols" do
     @ds.update_sql(:items__a=>:b).must_equal "UPDATE items SET items.a = b"
   end
   
@@ -3400,8 +3685,11 @@ describe "Dataset#insert_sql" do
     @ds.insert_sql([:a, :b, :c], Sequel.lit('VALUES (1, 2, 3)')).must_equal "INSERT INTO items (a, b, c) VALUES (1, 2, 3)"
   end
 
-  it "should use unaliased table name" do
+  with_symbol_splitting "should use unaliased table name when using splittable symbol" do
     @ds.from(:items___i).insert_sql(1).must_equal "INSERT INTO items VALUES (1)"
+  end
+
+  it "should use unaliased table name" do
     @ds.from(Sequel.as(:items, :i)).insert_sql(1).must_equal "INSERT INTO items VALUES (1)"
   end
 end
@@ -3724,11 +4012,16 @@ describe "Dataset prepared statements and bound variables " do
       '<Sequel::Mock::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = $n)">'
   end
     
-  it "should handle literal strings" do
+  deprecated "should handle literal strings" do
     @ds.filter("num = ?", :$n).call(:select, :n=>1)
     @db.sqls.must_equal ['SELECT * FROM items WHERE (num = 1)']
   end
     
+  it "should handle literal strings" do
+    @ds.filter(Sequel.lit("num = ?", :$n)).call(:select, :n=>1)
+    @db.sqls.must_equal ['SELECT * FROM items WHERE (num = 1)']
+  end
+    
   it "should handle columns on prepared statements correctly" do
     @db.columns = [:num]
     @ds = @ds.with_extend{def select_where_sql(sql) super(sql); sql << " OR #{columns.first} = 1" if opts[:where] end}
@@ -3751,11 +4044,16 @@ describe "Dataset prepared statements and bound variables " do
     @db.sqls.must_equal ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num IN (SELECT num FROM items WHERE (num = 1))))))']
   end
     
-  it "should handle subselects with literal strings" do
+  deprecated "should handle subselects with strings" do
     @ds.filter(:$b).filter(:num=>@ds.select(:num).filter("num = ?", :$n)).call(:select, :n=>1, :b=>0)
     @db.sqls.must_equal ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))))']
   end
     
+  it "should handle subselects with literal strings" do
+    @ds.filter(:$b).filter(:num=>@ds.select(:num).filter(Sequel.lit("num = ?", :$n))).call(:select, :n=>1, :b=>0)
+    @db.sqls.must_equal ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))))']
+  end
+    
   it "should handle subselects with static sql and placeholders" do
     @ds.filter(:$b).filter(:num=>@db["SELECT num FROM items WHERE (num = ?)", :$n]).call(:select, :n=>1, :b=>0)
     @db.sqls.must_equal ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))))']
@@ -3873,6 +4171,10 @@ describe "Sequel::Dataset#qualify" do
   end
 
   it "should handle symbols" do
+    @ds.select(:a).qualify.sql.must_equal 'SELECT t.a FROM t'
+  end
+
+  with_symbol_splitting "should handle splittable symbols" do
     @ds.select(:a, :b__c, :d___e, :f__g___h).qualify.sql.must_equal 'SELECT t.a, b.c, t.d AS e, f.g AS h FROM t'
   end
 
@@ -3922,11 +4224,11 @@ describe "Sequel::Dataset#qualify" do
   end
 
   it "should handle SQL::PlaceholderLiteralStrings" do
-    @ds.filter('? > ?', :a, 1).qualify.sql.must_equal 'SELECT t.* FROM t WHERE (t.a > 1)'
+    @ds.filter(Sequel.lit('? > ?', :a, 1)).qualify.sql.must_equal 'SELECT t.* FROM t WHERE (t.a > 1)'
   end
 
   it "should handle SQL::PlaceholderLiteralStrings with named placeholders" do
-    @ds.filter(':a > :b', :a=>:c, :b=>1).qualify.sql.must_equal 'SELECT t.* FROM t WHERE (t.c > 1)'
+    @ds.filter(Sequel.lit(':a > :b', :a=>:c, :b=>1)).qualify.sql.must_equal 'SELECT t.* FROM t WHERE (t.c > 1)'
   end
 
   it "should handle SQL::Wrappers" do
@@ -3960,7 +4262,7 @@ describe "Sequel::Dataset#qualify" do
   end
 
   it "should handle all other objects by returning them unchanged" do
-    @ds.select("a").filter{a(3)}.filter('blah').order(Sequel.lit('true')).group(Sequel.lit('a > ?', 1)).having(false).qualify.sql.must_equal "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
+    @ds.select("a").filter{a(3)}.filter(Sequel.lit('blah')).order(Sequel.lit('true')).group(Sequel.lit('a > ?', 1)).having(false).qualify.sql.must_equal "SELECT 'a' FROM t WHERE (a(3) AND (blah)) GROUP BY a > 1 HAVING 'f' ORDER BY true"
   end
 end
 
@@ -4313,7 +4615,12 @@ describe "Sequel::Dataset#select_map" do
     @ds.db.sqls.must_equal ['SELECT a FROM t']
   end
 
-  it "should handle implicit qualifiers in arguments" do
+  it "should handle qualified identifiers in arguments" do
+    @ds.select_map(Sequel[:a][:b]).must_equal [1, 2]
+    @ds.db.sqls.must_equal ['SELECT a.b FROM t']
+  end
+
+  with_symbol_splitting "should handle implicit qualifiers in arguments" do
     @ds.select_map(:a__b).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a.b FROM t']
   end
@@ -4321,14 +4628,19 @@ describe "Sequel::Dataset#select_map" do
   it "should raise if multiple arguments and can't determine alias" do
     proc{@ds.select_map([Sequel.function(:a), :b])}.must_raise(Sequel::Error)
     proc{@ds.select_map(Sequel.function(:a)){b}}.must_raise(Sequel::Error)
-    proc{@ds.select_map{[a{}, b]}}.must_raise(Sequel::Error)
+    proc{@ds.select_map{[a.function, b]}}.must_raise(Sequel::Error)
   end
 
-  it "should handle implicit aliases in arguments" do
+  with_symbol_splitting "should handle implicit aliases in arguments" do
     @ds.select_map(:a___b).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a AS b FROM t']
   end
 
+  it "should handle aliased expressions in arguments" do
+    @ds.select_map(Sequel[:a].as(:b)).must_equal [1, 2]
+    @ds.db.sqls.must_equal ['SELECT a AS b FROM t']
+  end
+
   it "should handle other objects" do
     @ds.select_map(Sequel.lit("a").as(:b)).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a AS b FROM t']
@@ -4345,35 +4657,40 @@ describe "Sequel::Dataset#select_map" do
   end
   
   it "should handle an expression without a determinable alias" do
-    @ds.select_map{a(t__c)}.must_equal [1, 2]
+    @ds.select_map{a(t[c])}.must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a(t.c) AS v FROM t']
   end
 
   it "should accept a block" do
-    @ds.select_map{a(t__c).as(b)}.must_equal [1, 2]
+    @ds.select_map{a(t[c]).as(b)}.must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a(t.c) AS b FROM t']
   end
 
   it "should accept a block with an array of columns" do
-    @ds.select_map{[a(t__c).as(c), a(t__c).as(c)]}.must_equal [[1, 1], [2, 2]]
+    @ds.select_map{[a(t[c]).as(c), a(t[c]).as(c)]}.must_equal [[1, 1], [2, 2]]
     @ds.db.sqls.must_equal ['SELECT a(t.c) AS c, a(t.c) AS c FROM t']
   end
 
   it "should accept a block with a column" do
-    @ds.select_map(:c){a(t__c).as(c)}.must_equal [[1, 1], [2, 2]]
+    @ds.select_map(:c){a(t[c]).as(c)}.must_equal [[1, 1], [2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, a(t.c) AS c FROM t']
   end
 
   it "should accept a block and array of arguments" do
-    @ds.select_map([:c, :c]){[a(t__c).as(c), a(t__c).as(c)]}.must_equal [[1, 1, 1, 1], [2, 2, 2, 2]]
+    @ds.select_map([:c, :c]){[a(t[c]).as(c), a(t[c]).as(c)]}.must_equal [[1, 1, 1, 1], [2, 2, 2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, c, a(t.c) AS c, a(t.c) AS c FROM t']
   end
 
   it "should handle an array of columns" do
     @ds.select_map([:c, :c]).must_equal [[1, 1], [2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, c FROM t']
-    @ds.select_map([Sequel.expr(:d).as(:c), Sequel.qualify(:b, :c), Sequel.identifier(:c), Sequel.identifier(:c).qualify(:b), :a__c, :a__d___c]).must_equal [[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2]]
-    @ds.db.sqls.must_equal ['SELECT d AS c, b.c, c, b.c, a.c, a.d AS c FROM t']
+    @ds.select_map([Sequel.expr(:d).as(:c), Sequel.qualify(:b, :c), Sequel.identifier(:c), Sequel.identifier(:c).qualify(:b)]).must_equal [[1, 1, 1, 1], [2, 2, 2, 2]]
+    @ds.db.sqls.must_equal ['SELECT d AS c, b.c, c, b.c FROM t']
+  end
+
+  with_symbol_splitting "should handle an array of columns with splittable symbols" do
+    @ds.select_map([:a__c, :a__d___c]).must_equal [[1, 1], [2, 2]]
+    @ds.db.sqls.must_equal ['SELECT a.c, a.d AS c FROM t']
   end
 
   it "should handle an array with a single element" do
@@ -4392,7 +4709,12 @@ describe "Sequel::Dataset#select_order_map" do
     @ds.db.sqls.must_equal ['SELECT a FROM t ORDER BY a']
   end
 
-  it "should handle implicit qualifiers in arguments" do
+  it "should handle qualified identifiers in arguments" do
+    @ds.select_order_map(Sequel[:a][:b]).must_equal [1, 2]
+    @ds.db.sqls.must_equal ['SELECT a.b FROM t ORDER BY a.b']
+  end
+
+  with_symbol_splitting "should handle implicit qualifiers in arguments" do
     @ds.select_order_map(:a__b).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a.b FROM t ORDER BY a.b']
   end
@@ -4400,15 +4722,15 @@ describe "Sequel::Dataset#select_order_map" do
   it "should raise if multiple arguments and can't determine alias" do
     proc{@ds.select_order_map([Sequel.function(:a), :b])}.must_raise(Sequel::Error)
     proc{@ds.select_order_map(Sequel.function(:a)){b}}.must_raise(Sequel::Error)
-    proc{@ds.select_order_map{[a{}, b]}}.must_raise(Sequel::Error)
+    proc{@ds.select_order_map{[a.function, b]}}.must_raise(Sequel::Error)
   end
 
-  it "should handle implicit aliases in arguments" do
+  with_symbol_splitting "should handle implicit aliases in arguments" do
     @ds.select_order_map(:a___b).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a AS b FROM t ORDER BY a']
   end
 
-  it "should handle implicit qualifiers and aliases in arguments" do
+  with_symbol_splitting "should handle implicit qualifiers and aliases in arguments" do
     @ds.select_order_map(:t__a___b).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT t.a AS b FROM t ORDER BY t.a']
   end
@@ -4416,6 +4738,10 @@ describe "Sequel::Dataset#select_order_map" do
   it "should handle AliasedExpressions" do
     @ds.select_order_map(Sequel.lit("a").as(:b)).must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a AS b FROM t ORDER BY a']
+    @ds.select_order_map(Sequel[:a].as(:b)).must_equal [1, 2]
+    @ds.db.sqls.must_equal ['SELECT a AS b FROM t ORDER BY a']
+    @ds.select_order_map(Sequel[:t][:a].as(:b)).must_equal [1, 2]
+    @ds.db.sqls.must_equal ['SELECT t.a AS b FROM t ORDER BY t.a']
   end
   
   it "should handle OrderedExpressions" do
@@ -4424,35 +4750,43 @@ describe "Sequel::Dataset#select_order_map" do
   end
   
   it "should handle an expression without a determinable alias" do
-    @ds.select_order_map{a(t__c)}.must_equal [1, 2]
+    @ds.select_order_map{a(t[c])}.must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a(t.c) AS v FROM t ORDER BY a(t.c)']
   end
 
   it "should accept a block" do
-    @ds.select_order_map{a(t__c).as(b)}.must_equal [1, 2]
+    @ds.select_order_map{a(t[c]).as(b)}.must_equal [1, 2]
     @ds.db.sqls.must_equal ['SELECT a(t.c) AS b FROM t ORDER BY a(t.c)']
   end
 
   it "should accept a block with an array of columns" do
-    @ds.select_order_map{[c.desc, a(t__c).as(c)]}.must_equal [[1, 1], [2, 2]]
+    @ds.select_order_map{[c.desc, a(t[c]).as(c)]}.must_equal [[1, 1], [2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, a(t.c) AS c FROM t ORDER BY c DESC, a(t.c)']
   end
 
   it "should accept a block with a column" do
-    @ds.select_order_map(:c){a(t__c).as(c)}.must_equal [[1, 1], [2, 2]]
+    @ds.select_order_map(:c){a(t[c]).as(c)}.must_equal [[1, 1], [2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, a(t.c) AS c FROM t ORDER BY c, a(t.c)']
   end
 
   it "should accept a block and array of arguments" do
-    @ds.select_order_map([:c, :c]){[a(t__c).as(c), c.desc]}.must_equal [[1, 1, 1, 1], [2, 2, 2, 2]]
+    @ds.select_order_map([:c, :c]){[a(t[c]).as(c), c.desc]}.must_equal [[1, 1, 1, 1], [2, 2, 2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, c, a(t.c) AS c, c FROM t ORDER BY c, c, a(t.c), c DESC']
   end
 
   it "should handle an array of columns" do
     @ds.select_order_map([:c, :c]).must_equal [[1, 1], [2, 2]]
     @ds.db.sqls.must_equal ['SELECT c, c FROM t ORDER BY c, c']
-    @ds.select_order_map([Sequel.expr(:d).as(:c), Sequel.qualify(:b, :c), Sequel.identifier(:c), Sequel.identifier(:c).qualify(:b), Sequel.identifier(:c).qualify(:b).desc, :a__c, Sequel.desc(:a__d___c), Sequel.desc(Sequel.expr(:a__d___c))]).must_equal [[1, 1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2, 2]]
-    @ds.db.sqls.must_equal ['SELECT d AS c, b.c, c, b.c, b.c, a.c, a.d AS c, a.d AS c FROM t ORDER BY d, b.c, c, b.c, b.c DESC, a.c, a.d DESC, a.d DESC']
+  end
+
+  it "should handle an array of columns" do
+    @ds.select_order_map([Sequel.expr(:d).as(:c), Sequel.qualify(:b, :c), Sequel.identifier(:c), Sequel.identifier(:c).qualify(:b), Sequel.identifier(:c).qualify(:b).desc]).must_equal [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2]]
+    @ds.db.sqls.must_equal ['SELECT d AS c, b.c, c, b.c, b.c FROM t ORDER BY d, b.c, c, b.c, b.c DESC']
+  end
+
+  with_symbol_splitting "should handle an array of columns with splittable symbols" do
+    @ds.select_order_map([:a__c, Sequel.desc(:a__d___c), Sequel.desc(Sequel.expr(:a__d___c))]).must_equal [[1, 1, 1], [2, 2, 2]]
+    @ds.db.sqls.must_equal ['SELECT a.c, a.d AS c, a.d AS c FROM t ORDER BY a.c, a.d DESC, a.d DESC']
   end
 
   it "should handle an array with a single element" do
@@ -4472,17 +4806,32 @@ describe "Sequel::Dataset#select_hash" do
     @ds.db.sqls.must_equal ['SELECT a, b FROM t']
   end
 
-  it "should handle implicit qualifiers in arguments" do
+  it "should handle qualified identifiers in arguments" do
+    @ds.select_hash(Sequel[:t][:a], Sequel[:t][:b]).must_equal(1=>2, 3=>4)
+    @ds.db.sqls.must_equal ['SELECT t.a, t.b FROM t']
+  end
+
+  with_symbol_splitting "should handle implicit qualifiers in arguments" do
     @ds.select_hash(:t__a, :t__b).must_equal(1=>2, 3=>4)
     @ds.db.sqls.must_equal ['SELECT t.a, t.b FROM t']
   end
 
-  it "should handle implicit aliases in arguments" do
+  it "should handle aliased expresssions in arguments" do
+    @ds.select_hash(Sequel[:c].as(:a), Sequel[:d].as(:b)).must_equal(1=>2, 3=>4)
+    @ds.db.sqls.must_equal ['SELECT c AS a, d AS b FROM t']
+  end
+
+  with_symbol_splitting "should handle implicit aliases in arguments" do
     @ds.select_hash(:c___a, :d___b).must_equal(1=>2, 3=>4)
     @ds.db.sqls.must_equal ['SELECT c AS a, d AS b FROM t']
   end
 
-  it "should handle implicit qualifiers and aliases in arguments" do
+  it "should handle qualified identifiers and aliased expressions in arguments" do
+    @ds.select_hash(Sequel[:t][:c].as(:a), Sequel[:t][:d].as(:b)).must_equal(1=>2, 3=>4)
+    @ds.db.sqls.must_equal ['SELECT t.c AS a, t.d AS b FROM t']
+  end
+
+  with_symbol_splitting "should handle implicit qualifiers and aliases in arguments" do
     @ds.select_hash(:t__c___a, :t__d___b).must_equal(1=>2, 3=>4)
     @ds.db.sqls.must_equal ['SELECT t.c AS a, t.d AS b FROM t']
   end
@@ -4528,17 +4877,17 @@ describe "Sequel::Dataset#select_hash_groups" do
     @ds.db.sqls.must_equal ['SELECT a, b FROM t']
   end
 
-  it "should handle implicit qualifiers in arguments" do
+  with_symbol_splitting "should handle implicit qualifiers in arguments" do
     @ds.select_hash_groups(:t__a, :t__b).must_equal(1=>[2], 3=>[4])
     @ds.db.sqls.must_equal ['SELECT t.a, t.b FROM t']
   end
 
-  it "should handle implicit aliases in arguments" do
+  with_symbol_splitting "should handle implicit aliases in arguments" do
     @ds.select_hash_groups(:c___a, :d___b).must_equal(1=>[2], 3=>[4])
     @ds.db.sqls.must_equal ['SELECT c AS a, d AS b FROM t']
   end
 
-  it "should handle implicit qualifiers and aliases in arguments" do
+  with_symbol_splitting "should handle implicit qualifiers and aliases in arguments" do
     @ds.select_hash_groups(:t__c___a, :t__d___b).must_equal(1=>[2], 3=>[4])
     @ds.db.sqls.must_equal ['SELECT t.c AS a, t.d AS b FROM t']
   end
@@ -4558,6 +4907,11 @@ describe "Sequel::Dataset#select_hash_groups" do
     @ds.db.sqls.must_equal ['SELECT c AS a, t AS b FROM t']
   end
 
+  it "should handle SQL::QualifiedIdentifiers and SQL::AliasedExpressions in arguments" do
+    @ds.select_hash_groups(Sequel[:t][:c].as(:a), Sequel[:t][:d].as(:b)).must_equal(1=>[2], 3=>[4])
+    @ds.db.sqls.must_equal ['SELECT t.c AS a, t.d AS b FROM t']
+  end
+
   it "should work with arrays of columns" do
     @db.fetch = [{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}]
     @ds.select_hash_groups([:a, :c], :b).must_equal([1, 3]=>[2], [4, 6]=>[5])
@@ -4631,15 +4985,24 @@ describe "Dataset#skip_locked" do
 end
   
 describe "Custom ASTTransformer" do
-  it "should transform given objects" do
-    c = Class.new(Sequel::ASTTransformer) do
+  before do
+    @c = Class.new(Sequel::ASTTransformer) do
       def v(s)
         (s.is_a?(Symbol) || s.is_a?(String)) ? :"#{s}#{s}" : super
       end
     end.new
+  end
+
+  it "should transform given objects" do
+    ds = Sequel.mock.dataset.from(:t).cross_join(Sequel[:a].as(:g)).join(Sequel[:b].as(:h), [:c]).join(Sequel[:d].as(:i), :e=>:f)
+    ds.sql.must_equal 'SELECT * FROM t CROSS JOIN a AS g INNER JOIN b AS h USING (c) INNER JOIN d AS i ON (i.e = h.f)'
+    ds.clone(:from=>@c.transform(ds.opts[:from]), :join=>@c.transform(ds.opts[:join])).sql.must_equal 'SELECT * FROM tt CROSS JOIN aa AS g INNER JOIN bb AS h USING (cc) INNER JOIN dd AS i ON (ii.ee = hh.ff)'
+  end
+
+  with_symbol_splitting "should transform given objects with splittable symbols" do
     ds = Sequel.mock.dataset.from(:t).cross_join(:a___g).join(:b___h, [:c]).join(:d___i, :e=>:f)
     ds.sql.must_equal 'SELECT * FROM t CROSS JOIN a AS g INNER JOIN b AS h USING (c) INNER JOIN d AS i ON (i.e = h.f)'
-    ds.clone(:from=>c.transform(ds.opts[:from]), :join=>c.transform(ds.opts[:join])).sql.must_equal 'SELECT * FROM tt CROSS JOIN aa AS g INNER JOIN bb AS h USING (cc) INNER JOIN dd AS i ON (ii.ee = hh.ff)'
+    ds.clone(:from=>@c.transform(ds.opts[:from]), :join=>@c.transform(ds.opts[:join])).sql.must_equal 'SELECT * FROM tt CROSS JOIN aa AS g INNER JOIN bb AS h USING (cc) INNER JOIN dd AS i ON (ii.ee = hh.ff)'
   end
 end
 
@@ -4795,7 +5158,7 @@ describe "Dataset#schema_and_table" do
     @ds = Sequel.mock[:test]
   end
 
-  it "should correctly handle symbols" do
+  with_symbol_splitting "should correctly handle symbols" do
     @ds.schema_and_table(:s).must_equal [nil, 's']
     @ds.schema_and_table(:s___a).must_equal [nil, 's']
     @ds.schema_and_table(:t__s).must_equal ['t', 's']
@@ -4827,6 +5190,9 @@ describe "Dataset#split_qualifiers" do
 
   it "should correctly handle symbols" do
     @ds.split_qualifiers(:s).must_equal ['s']
+  end
+
+  with_symbol_splitting "should correctly handle splittable symbols" do
     @ds.split_qualifiers(:s___a).must_equal ['s']
     @ds.split_qualifiers(:t__s).must_equal ['t', 's']
     @ds.split_qualifiers(:t__s___a).must_equal ['t', 's']
@@ -4844,12 +5210,15 @@ describe "Dataset#split_qualifiers" do
     @ds.split_qualifiers(Sequel.qualify(:t, :s)).must_equal ['t', 's']
   end
 
-  it "should correctly handle complex qualified identifiers" do
+  with_symbol_splitting "should correctly handle complex qualified identifiers with splittable symbols" do
     @ds.split_qualifiers(Sequel.qualify(:d__t, :s)).must_equal ['d', 't', 's']
-    @ds.split_qualifiers(Sequel.qualify(Sequel.qualify(:d, :t), :s)).must_equal ['d', 't', 's']
     @ds.split_qualifiers(Sequel.qualify(:d, :t__s)).must_equal ['d', 't', 's']
-    @ds.split_qualifiers(Sequel.qualify(:d, Sequel.qualify(:t, :s))).must_equal ['d', 't', 's']
     @ds.split_qualifiers(Sequel.qualify(:d__t, :s__s2)).must_equal ['d', 't', 's', 's2']
+  end
+
+  it "should correctly handle complex qualified identifiers" do
+    @ds.split_qualifiers(Sequel.qualify(Sequel.qualify(:d, :t), :s)).must_equal ['d', 't', 's']
+    @ds.split_qualifiers(Sequel.qualify(:d, Sequel.qualify(:t, :s))).must_equal ['d', 't', 's']
     @ds.split_qualifiers(Sequel.qualify(Sequel.qualify(:d, :t), Sequel.qualify(:s, :s2))).must_equal ['d', 't', 's', 's2']
   end
 end
@@ -5115,6 +5484,9 @@ describe "#unqualified_column_for" do
 
   it "should handle Symbols" do
     @ds.unqualified_column_for(:a).must_equal Sequel.identifier('a')
+  end
+
+  with_symbol_splitting "should handle splittable symbols" do
     @ds.unqualified_column_for(:b__a).must_equal Sequel.identifier('a')
     @ds.unqualified_column_for(:a___c).must_equal Sequel.identifier('a').as('c')
     @ds.unqualified_column_for(:b__a___c).must_equal Sequel.identifier('a').as('c')