sequel 4.39.0 → 4.40.0

data/lib/sequel/extensions/symbol_as.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+#
+# The symbol_as extension adds Symbol#as, for creating
+# Sequel::SQL::AliasedExpression objects. It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:column].as(:alias)
+#
+# you can just write:
+#
+#   :column.as(:alias)
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_as
+#
+# If you are using Ruby 2+, and you would like to use refinements, there
+# is a refinement version of this in the symbol_as_refinement extension.
+
+# 
+class Symbol
+  include Sequel::SQL::AliasMethods
+end

data/lib/sequel/extensions/symbol_as_refinement.rb

@@ -0,0 +1,35 @@
+# frozen-string-literal: true
+#
+# The symbol_as_refinement extension adds a refinement that makes
+# Symbol#as return Sequel::SQL::AliasedExpression instances.  It's
+# designed as a shortcut so that instead of:
+#
+#   Sequel[:column].as(:alias) # column AS alias
+#
+# you can just write:
+#   
+#   :column.as(:alias) # column AS alias
+#
+# To load the extension:
+#
+#   Sequel.extension :symbol_as_refinement
+#
+# To enable the refinement for the current file:
+#
+#   using Sequel::SymbolAs
+#
+# If you would like this extension to be enabled globally instead
+# of as a refinement, use the symbol_as extension.
+#
+# Related module: Sequel::SymbolAs
+
+raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+
+module Sequel::SymbolAs
+  refine Symbol do
+    def as(aliaz, columns=nil)
+      Sequel::SQL::AliasedExpression.new(self, aliaz, columns)
+    end
+  end
+end
+

data/lib/sequel/model/base.rb

@@ -1614,12 +1614,12 @@ module Sequel
         model.primary_key_hash(pk)
       end
       
-      # Returns a hash mapping the receivers primary key column(s) to their values.
+      # Returns a hash mapping the receivers qualified primary key column(s) to their values.
       # 
       #   Artist[1].qualified_pk_hash
-      #   # => {Sequel.qualify(:artists, :id)=>1}
+      #   # => {Sequel[:artists][:id]=>1}
       #   Artist[[1, 2]].qualified_pk_hash
-      #   # => {Sequel.qualify(:artists, :id1)=>1, Sequel.qualify(:artists, :id2)=>2}
+      #   # => {Sequel[:artists][:id1]=>1, Sequel[:artists][:id2]=>2}
       def qualified_pk_hash(qualifier=model.table_name)
         model.qualified_primary_key_hash(pk, qualifier)
       end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -31,9 +31,15 @@ module Sequel
     # The class_table_inheritance plugin assumes that the root table
     # (e.g. employees) has a primary key column (usually autoincrementing),
     # and all other tables have a foreign key of the same name that points
-    # to the same column in their superclass's table.  In this example,
-    # the employees id column is a primary key and the id column in every
-    # other table is a foreign key referencing the employees id.
+    # to the same column in their superclass's table, which is also the primary
+    # key for that table.  In this example, the employees table has an id column
+    # is a primary key and the id column in every other table is a foreign key
+    # referencing employees.id, which is also the primary key of that table.
+    #
+    # Additionally, note that other than the primary key column, no subclass
+    # table has a column with the same name as any superclass table. This plugin
+    # does not support cases where the column names in a subclass table overlap
+    # with any column names in a superclass table.
     #
     # In this example the staff table also stores Cook model objects and the
     # executives table also stores CEO model objects.
@@ -354,6 +360,11 @@ module Sequel
             cti_this(m).update(h) unless h.empty?
           end
         end
+
+        # Don't allow use of prepared statements.
+        def use_prepared_statements_for?(type)
+          false
+        end
       end
     end
   end

data/lib/sequel/plugins/column_select.rb

@@ -48,8 +48,10 @@ module Sequel
                 cols = cols.map{|c, _| c}
               end
             end
-            cols ||= check_non_connection_error{ds.columns}
-            ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+
+            if cols ||= check_non_connection_error{ds.columns}
+              ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+            end
           end
           ds
         end

data/lib/sequel/plugins/dataset_associations.rb

@@ -93,12 +93,20 @@ module Sequel
               where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :many_through_many, :one_through_many
-            fre = r.reverse_edges.first
             fe, *edges = r.edges
             edges << r.final_edge
-            mds = model.
-              select(*Array(r.qualify(fre[:table], fre[:left]))).
-              join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name).
+            if fre = r.reverse_edges.first
+              table = fre[:table]
+              left = fre[:left]
+              mds = model.join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name)
+            else
+              table = fe[:table]
+              left = edges.first[:left]
+              edges = []
+              mds = r.associated_dataset
+            end
+            mds = mds.
+              select(*Array(r.qualify(table, left))).
               where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
             edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
             ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))

data/lib/sequel/plugins/insert_returning_select.rb

@@ -35,7 +35,7 @@ module Sequel
         # When reseting the instance dataset, also reset the instance_insert_dataset.
         def reset_instance_dataset
           ret = super
-          ds = @instance_dataset
+          return unless ds = @instance_dataset
 
           if columns = insert_returning_columns(ds)
             ds = ds.returning(*columns)

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -84,7 +84,7 @@ module Sequel
         def _update_without_checking(columns)
           ds = _update_dataset
           lc = model.lock_column
-          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel.qualify(:inserted, lc)]).update_sql(columns))).all
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel[:inserted][lc]]).update_sql(columns))).all
           values[lc] = rows.first[lc] unless rows.empty?
           rows.length
         end

data/lib/sequel/plugins/prepared_statements.rb

@@ -134,6 +134,7 @@ module Sequel
 
         # Use a prepared statement to query the database for the row matching the given primary key.
         def primary_key_lookup(pk)
+          return super if dataset.joined_dataset?
           prepared_lookup.call(primary_key_hash(pk))
         end
 

data/lib/sequel/sql.rb

@@ -206,6 +206,9 @@ module Sequel
       # Operator symbols that take one or more arguments
       N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS - [:**]
 
+      # Operator symbols that are associative
+      ASSOCIATIVE_OPERATORS = [:AND, :OR, :'||', :+, :*, :&, :|]
+
       # Operator symbols that take only a single argument
       ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
 
@@ -229,9 +232,12 @@ module Sequel
         case op
         when *N_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
-          old_args = args.map{|a| a.is_a?(self.class) && a.op == :NOOP ? a.args.first : a}
-          args = []
-          old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
+          args.map!{|a| a.is_a?(self.class) && a.op == :NOOP ? a.args.first : a}
+          if ASSOCIATIVE_OPERATORS.include?(op)
+            old_args = args
+            args = []
+            old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
+          end
         when *TWO_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
           # With IN/NOT IN, even if the second argument is an array of two element arrays,
@@ -944,12 +950,21 @@ module Sequel
 
       # Qualify the receiver with the given +qualifier+ (table for column/schema for table).
       #
-      #   Sequel[:column].qualify(:table) # "table"."column"
-      #   Sequel[:table].qualify(:schema) # "schema"."table"
+      #   Sequel[:column].qualify(:table)                  # "table"."column"
+      #   Sequel[:table].qualify(:schema)                  # "schema"."table"
       #   Sequel.qualify(:table, :column).qualify(:schema) # "schema"."table"."column"
       def qualify(qualifier)
         QualifiedIdentifier.new(qualifier, self)
       end
+
+      # Qualify the receiver with the given +qualifier+ (table for column/schema for table).
+      #
+      #   Sequel[:table][:column]          # "table"."column"
+      #   Sequel[:schema][:table]          # "schema"."table"
+      #   Sequel[:schema][:table][:column] # "schema"."table"."column"
+      def [](identifier)
+        QualifiedIdentifier.new(self, identifier)
+      end
     end
 
     # This module includes the +like+ and +ilike+ methods used for pattern matching that are defined on objects that can be 
@@ -1635,7 +1650,8 @@ module Sequel
 
       # Set the table and column to the given arguments
       def initialize(table, column)
-        @table, @column = table, column
+        @table = convert_identifier(table)
+        @column = convert_identifier(column)
       end
       
       # Create a Function using this identifier as the functions name, with
@@ -1645,6 +1661,18 @@ module Sequel
       end
       
       to_s_method :qualified_identifier_sql, "@table, @column"
+
+      private
+
+      # Automatically convert SQL::Identifiers to strings
+      def convert_identifier(identifier)
+        case identifier
+        when SQL::Identifier
+          identifier.value.to_s
+        else
+          identifier
+        end
+      end
     end
     
     # Subclass of +ComplexExpression+ where the expression results
@@ -1869,8 +1897,12 @@ module Sequel
             end
           end
         elsif args.empty?
-          table, column = m.to_s.split(DOUBLE_UNDERSCORE, 2)
-          column ? QualifiedIdentifier.new(table, column) : Identifier.new(m)
+          if Sequel.split_symbols?
+            table, column = m.to_s.split(DOUBLE_UNDERSCORE, 2)
+            column ? QualifiedIdentifier.new(table, column) : Identifier.new(m)
+          else
+            Identifier.new(m)
+          end
         else
           Function.new(m, *args)
         end

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 = 39
+  MINOR = 40
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/firebird_spec.rb

@@ -125,7 +125,7 @@ describe "A Firebird dataset" do
     @d.select(:now[]).sql.must_equal \
     'SELECT now() FROM "TEST"'
 
-    @d.select(:max[:items__val]).sql.must_equal \
+    @d.select(:max[Sequel[:items][:val]]).sql.must_equal \
       'SELECT max("ITEMS"."VAL") FROM "TEST"'
 
     @d.order(:name.desc).sql.must_equal \
@@ -143,10 +143,10 @@ describe "A Firebird dataset" do
     @d.select(:test[:ABC, 'hello']).sql.must_equal \
       "SELECT test(\"ABC\", 'hello') FROM \"TEST\""
 
-    @d.select(:test[:ABC__DEF, 'hello']).sql.must_equal \
+    @d.select(:test[Sequel[:ABC][:DEF], 'hello']).sql.must_equal \
       "SELECT test(\"ABC\".\"DEF\", 'hello') FROM \"TEST\""
 
-    @d.select(:test[:ABC__DEF, 'hello'].as(:X2)).sql.must_equal \
+    @d.select(:test[Sequel[:ABC][:DEF], 'hello'].as(:X2)).sql.must_equal \
       "SELECT test(\"ABC\".\"DEF\", 'hello') AS \"X2\" FROM \"TEST\""
 
     @d.insert_sql(:val => 333).must_match \

data/spec/adapters/mssql_spec.rb

@@ -62,11 +62,11 @@ describe "MSSQL" do
   end
 
   it "should should support CROSS APPLY" do
-    @db[:test3].cross_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).must_equal [[1,1]]
+    @db[:test3].cross_apply(@db[:test4].where(Sequel[:test3][:v3]=>Sequel[:test4][:v4])).select_order_map([:v3, :v4]).must_equal [[1,1]]
   end
 
   it "should should support OUTER APPLY" do
-    @db[:test3].outer_apply(@db[:test4].where(:test3__v3=>:test4__v4)).select_order_map([:v3, :v4]).must_equal [[1,1], [2, nil]]
+    @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
 end
 
@@ -105,7 +105,7 @@ describe "MSSQL Dataset#join_table" do
     ['SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID1] = [ITEMS].[ID1]) AND ([CATEGORIES].[ID2] = [ITEMS].[ID2]))',
       'SELECT * FROM [ITEMS] INNER JOIN [CATEGORIES] ON (([CATEGORIES].[ID2] = [ITEMS].[ID2]) AND ([CATEGORIES].[ID1] = [ITEMS].[ID1]))'].
       must_include(DB[:items].join(:categories, [:id1, :id2]).sql)
-    DB[:items___i].join(:categories___c, [:id]).sql.must_equal 'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
+    DB[Sequel[:items].as(:i)].join(Sequel[:categories].as(:c), [:id]).sql.must_equal 'SELECT * FROM [ITEMS] AS [I] INNER JOIN [CATEGORIES] AS [C] ON ([C].[ID] = [I].[ID])'
   end
 end
 
@@ -121,56 +121,56 @@ describe "MSSQL Dataset#output" do
   end
 
   it "should format OUTPUT clauses without INTO for DELETE statements" do
-    @ds.output(nil, [:deleted__name, :deleted__value]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/)
+    @ds.output(nil, [Sequel[:deleted][:name], Sequel[:deleted][:value]]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\]/)
     @ds.output(nil, [Sequel::SQL::ColumnAll.new(:deleted)]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].*/)
   end
   
   it "should format OUTPUT clauses with INTO for DELETE statements" do
-    @ds.output(:out, [:deleted__name, :deleted__value]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\]/)
-    @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
+    @ds.output(:out, [Sequel[:deleted][:name], Sequel[:deleted][:value]]).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\]/)
+    @ds.output(:out, {:name => Sequel[:deleted][:name], :value => Sequel[:deleted][:value]}).delete_sql.must_match(/DELETE FROM \[ITEMS\] OUTPUT \[DELETED\].\[(NAME|VALUE)\], \[DELETED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
   end
 
   it "should format OUTPUT clauses without INTO for INSERT statements" do
-    @ds.output(nil, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/)
+    @ds.output(nil, [Sequel[:inserted][:name], Sequel[:inserted][:value]]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] VALUES \((N'name'|1), (N'name'|1)\)/)
     @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].* VALUES \((N'name'|1), (N'name'|1)\)/)
   end
 
   it "should format OUTPUT clauses with INTO for INSERT statements" do
-    @ds.output(:out, [:inserted__name, :inserted__value]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \((\[NAME\]|\[VALUE\]), (\[NAME\]|\[VALUE\])\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] VALUES \((N'name'|1), (N'name'|1)\)/)
-    @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) VALUES \((N'name'|1), (N'name'|1)\)/)
+    @ds.output(:out, [Sequel[:inserted][:name], Sequel[:inserted][:value]]).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \((\[NAME\]|\[VALUE\]), (\[NAME\]|\[VALUE\])\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] VALUES \((N'name'|1), (N'name'|1)\)/)
+    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:inserted][:value]}).insert_sql(:name => "name", :value => 1).must_match(/INSERT INTO \[ITEMS\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) OUTPUT \[INSERTED\].\[(NAME|VALUE)\], \[INSERTED\].\[(NAME|VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\) VALUES \((N'name'|1), (N'name'|1)\)/)
   end
 
   it "should format OUTPUT clauses without INTO for UPDATE statements" do
-    @ds.output(nil, [:inserted__name, :deleted__value]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/)
+    @ds.output(nil, [Sequel[:inserted][:name], Sequel[:deleted][:value]]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\]/)
     @ds.output(nil, [Sequel::SQL::ColumnAll.new(:inserted)]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[INSERTED\].*/)
   end
 
   it "should format OUTPUT clauses with INTO for UPDATE statements" do
-    @ds.output(:out, [:inserted__name, :deleted__value]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\]/)
-    @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
+    @ds.output(:out, [Sequel[:inserted][:name], Sequel[:deleted][:value]]).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\]/)
+    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:deleted][:value]}).update_sql(:value => 2).must_match(/UPDATE \[ITEMS\] SET \[VALUE\] = 2 OUTPUT \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\], \[(INSERTED\].\[NAME|DELETED\].\[VALUE)\] INTO \[OUT\] \(\[(NAME|VALUE)\], \[(NAME|VALUE)\]\)/)
   end
 
   it "should execute OUTPUT clauses in DELETE statements" do
     @ds.insert(:name => "name", :value => 1)
-    @ds.output(:out, [:deleted__name, :deleted__value]).delete
+    @ds.output(:out, [Sequel[:deleted][:name], Sequel[:deleted][:value]]).delete
     @db[:out].all.must_equal [{:name => "name", :value => 1}]
     @ds.insert(:name => "name", :value => 2)
-    @ds.output(:out, {:name => :deleted__name, :value => :deleted__value}).delete
+    @ds.output(:out, {:name => Sequel[:deleted][:name], :value => Sequel[:deleted][:value]}).delete
     @db[:out].all.must_equal [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
   end
 
   it "should execute OUTPUT clauses in INSERT statements" do
-    @ds.output(:out, [:inserted__name, :inserted__value]).insert(:name => "name", :value => 1)
+    @ds.output(:out, [Sequel[:inserted][:name], Sequel[:inserted][:value]]).insert(:name => "name", :value => 1)
     @db[:out].all.must_equal [{:name => "name", :value => 1}]
-    @ds.output(:out, {:name => :inserted__name, :value => :inserted__value}).insert(:name => "name", :value => 2)
+    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:inserted][:value]}).insert(:name => "name", :value => 2)
     @db[:out].all.must_equal [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
   end
 
   it "should execute OUTPUT clauses in UPDATE statements" do
     @ds.insert(:name => "name", :value => 1)
-    @ds.output(:out, [:inserted__name, :deleted__value]).update(:value => 2)
+    @ds.output(:out, [Sequel[:inserted][:name], Sequel[:deleted][:value]]).update(:value => 2)
     @db[:out].all.must_equal [{:name => "name", :value => 1}]
-    @ds.output(:out, {:name => :inserted__name, :value => :deleted__value}).update(:value => 3)
+    @ds.output(:out, {:name => Sequel[:inserted][:name], :value => Sequel[:deleted][:value]}).update(:value => 3)
     @db[:out].all.must_equal [{:name => "name", :value => 1}, {:name => "name", :value => 2}]
   end
 end
@@ -216,7 +216,7 @@ describe "MSSQL::Dataset#import" do
   
   it "#import should work correctly with an arbitrary output value" do
     @db.create_table!(:test){primary_key :x; Integer :y}
-    @ds.output(nil, [:inserted__y, :inserted__x]).import([:y], [[3], [4]]).must_equal [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
+    @ds.output(nil, [Sequel[:inserted][:y], Sequel[:inserted][:x]]).import([:y], [[3], [4]]).must_equal [{:y=>3, :x=>1}, {:y=>4, :x=>2}]
     @ds.all.must_equal [{:x=>1, :y=>3}, {:x=>2, :y=>4}]
   end
 
@@ -233,11 +233,11 @@ describe "MSSQL joined datasets" do
   end
 
   it "should format DELETE statements" do
-    @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).delete_sql.must_equal "DELETE FROM [T1] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
+    @db[:t1].inner_join(:t2, Sequel[:t1][:pk] => Sequel[:t2][:pk]).delete_sql.must_equal "DELETE FROM [T1] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
   end
 
   it "should format UPDATE statements" do
-    @db[:t1].inner_join(:t2, :t1__pk => :t2__pk).update_sql(:pk => :t2__pk).must_equal "UPDATE [T1] SET [PK] = [T2].[PK] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
+    @db[:t1].inner_join(:t2, Sequel[:t1][:pk] => Sequel[:t2][:pk]).update_sql(:pk => Sequel[:t2][:pk]).must_equal "UPDATE [T1] SET [PK] = [T2].[PK] FROM [T1] INNER JOIN [T2] ON ([T1].[PK] = [T2].[PK])"
   end
 end
 
@@ -281,7 +281,7 @@ describe "Common Table Expressions" do
     @ds.insert(:id=>1)
     @ds2.insert(:id=>2, :parent_id=>1)
     @ds2.insert(:id=>3, :parent_id=>2)
-    @ds.with(:t, @ds2).filter(:id => @db[:t].select(:id)).update(:parent_id => @db[:t].filter(:id => :i1__id).select(:parent_id).limit(1))
+    @ds.with(:t, @ds2).filter(:id => @db[:t].select(:id)).update(:parent_id => @db[:t].filter(:id => Sequel[:i1][:id]).select(:parent_id).limit(1))
     @ds[:id => 1].must_equal(:id => 1, :parent_id => nil)
     @ds[:id => 2].must_equal(:id => 2, :parent_id => 1)
     @ds[:id => 3].must_equal(:id => 3, :parent_id => 2)
@@ -289,7 +289,7 @@ describe "Common Table Expressions" do
   end
 
   it "using #with_recursive should be able to update" do
-    ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1).or(:id => 1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1).or(:id => 1), @ds.join(:t, :i=>:parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi])
     ds.exclude(:id => @db[:t].select(:i)).update(:parent_id => 1)
     @ds[:id => 1].must_equal(:id => 1, :parent_id => nil)
     @ds[:id => 2].must_equal(:id => 2, :parent_id => 1)
@@ -303,7 +303,7 @@ describe "Common Table Expressions" do
   end
 
   it "using #with_recursive should be able to insert" do
-    ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi])
     ds.insert @db[:t]
     @ds2.all.must_equal [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
   end
@@ -318,8 +318,8 @@ describe "Common Table Expressions" do
 
   it "using #with_recursive should be able to delete" do
     @ds.insert(:id=>7, :parent_id=>2)
-    ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
-    ds.filter(:i1__id => @db[:t].select(:i)).delete
+    ds = @ds.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi])
+    ds.filter(Sequel[:i1][:id] => @db[:t].select(:i)).delete
     @ds.all.must_equal [{:id => 1, :parent_id => nil}, {:id => 2, :parent_id => nil}, {:id => 7, :parent_id => 2}]
   end
 
@@ -330,7 +330,7 @@ describe "Common Table Expressions" do
   end
 
   it "using #with_recursive should be able to import" do
-    ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+    ds = @ds2.with_recursive(:t, @ds.filter(:parent_id=>1), @ds.join(:t, :i=>:parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi])
     ds.import [:id, :parent_id], @db[:t].select(:i, :pi)
     @ds2.all.must_equal [{:id => 3, :parent_id => 1}, {:id => 4, :parent_id => 1}, {:id => 5, :parent_id => 3}, {:id => 6, :parent_id => 5}]
   end
@@ -442,11 +442,11 @@ describe "MSSQL::Database#rename_table" do
       IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = 'MY')
         EXECUTE sp_executesql N'create schema MY'
     SQL
-    DB.create_table! :MY__foo do
+    DB.create_table! Sequel[:MY][:foo] do
       text :name
     end
-    DB.rename_table :MY__foo, :MY__bar
-    DB.rename_table :MY__bar, :foo
+    DB.rename_table Sequel[:MY][:foo], Sequel[:MY][:bar]
+    DB.rename_table Sequel[:MY][:bar], :foo
   end
 end
 
@@ -550,14 +550,14 @@ describe "MSSQL::Database#drop_column with a schema" do
     DB.run "create schema test" rescue nil
   end
   after do
-    DB.drop_table(:test__items)
+    DB.drop_table(Sequel[:test][:items])
     DB.run "drop schema test" rescue nil
   end
 
   it "drops columns with a default value" do
-    DB.create_table!(:test__items){ Integer :id; String :name, :default => 'widget' }
-    DB.drop_column(:test__items, :name)
-    DB[:test__items].columns.must_equal [:id]
+    DB.create_table!(Sequel[:test][:items]){ Integer :id; String :name, :default => 'widget' }
+    DB.drop_column(Sequel[:test][:items], :name)
+    DB[Sequel[:test][:items]].columns.must_equal [:id]
   end
 end
 
@@ -606,24 +606,24 @@ describe "Database#foreign_key_list" do
   describe "with multiple schemas" do
     before(:all) do
       DB.execute_ddl "create schema vendor"
-      DB.create_table! :vendor__vendors do
+      DB.create_table! Sequel[:vendor][:vendors] do
         primary_key :id
         varchar     :name
       end
-      DB.create_table! :vendor__mapping do
+      DB.create_table! Sequel[:vendor][:mapping] do
         integer :vendor_id
         integer :item_id
-        foreign_key [:vendor_id], :vendor__vendors, :name => :fk_mapping_vendor
+        foreign_key [:vendor_id], Sequel[:vendor][:vendors], :name => :fk_mapping_vendor
         foreign_key [:item_id], :items, :name => :fk_mapping_item
       end
     end
     after(:all) do
-      DB.drop_table? :vendor__mapping
-      DB.drop_table? :vendor__vendors
+      DB.drop_table? Sequel[:vendor][:mapping]
+      DB.drop_table? Sequel[:vendor][:vendors]
       DB.execute_ddl "drop schema vendor"
     end
     it "should support mixed schema bound tables" do
- DB.foreign_key_list(:vendor__mapping).sort_by{|h| h[:name].to_s}.must_equal [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => Sequel.qualify(:vendor, :vendors), :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
+ DB.foreign_key_list(Sequel[:vendor][:mapping]).sort_by{|h| h[:name].to_s}.must_equal [{:name => :fk_mapping_item, :table => :items, :columns => [:item_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }, {:name => :fk_mapping_vendor, :table => Sequel.qualify(:vendor, :vendors), :columns => [:vendor_id], :key => [:id], :on_update => :no_action, :on_delete => :no_action }]
     end
   end
 end