sequel 4.36.0 → 5.61.0

data/lib/sequel/extensions/connection_validator.rb

@@ -51,6 +51,7 @@
 module Sequel
   module ConnectionValidator
     class Retry < Error; end
+    Sequel::Deprecation.deprecate_constant(self, :Retry)
 
     # The number of seconds that need to pass since
     # connection checkin before attempting to validate
@@ -60,7 +61,7 @@ module Sequel
 
     # Initialize the data structures used by this extension.
     def self.extended(pool)
-      pool.instance_eval do
+      pool.instance_exec do
         sync do
           @connection_timestamps ||= {}
           @connection_validation_timeout ||= 3600
@@ -79,7 +80,7 @@ module Sequel
     # Record the time the connection was checked back into the pool.
     def checkin_connection(*)
       conn = super
-      @connection_timestamps[conn] = Time.now
+      @connection_timestamps[conn] = Sequel.start_timer
       conn
     end
 
@@ -94,23 +95,23 @@ module Sequel
     # test the connection for validity.  If it is not valid,
     # disconnect the connection, and retry with a new connection.
     def acquire(*a)
-      begin
+      conn = nil
+
+      1.times do
         if (conn = super) &&
-           (t = sync{@connection_timestamps.delete(conn)}) &&
-           Time.now - t > @connection_validation_timeout &&
+           (timer = sync{@connection_timestamps.delete(conn)}) &&
+           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
            !db.valid_connection?(conn)
 
           if pool_type == :sharded_threaded
-            sync{allocated(a.last).delete(Thread.current)}
+            sync{allocated(a.last).delete(Sequel.current)}
           else
-            sync{@allocated.delete(Thread.current)}
+            sync{@allocated.delete(Sequel.current)}
           end
 
           disconnect_connection(conn)
-          raise Retry
+          redo
         end
-      rescue Retry
-        retry
       end
 
       conn

data/lib/sequel/extensions/constant_sql_override.rb

@@ -0,0 +1,65 @@
+# frozen-string-literal: true
+#
+# The constant_sql_override extension allows you to change the SQL
+# generated for Sequel constants.
+#
+# One possible use-case for this is to have Sequel::CURRENT_TIMESTAMP use UTC time when
+# you have Sequel.database_timezone = :utc, but the database uses localtime when
+# generating CURRENT_TIMESTAMP.
+#
+# You can set SQL overrides with Database#set_constant_sql:
+#
+#   DB.set_constant_sql(Sequel::CURRENT_TIMESTAMP, "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'")
+#
+# Now, using Sequel::CURRENT_TIMESTAMP will use your override instead:
+#
+#   Album.where(released_at: Sequel::CURRENT_TIMESTAMP).sql
+#   # => SELECT "albums.*" FROM "albums" WHERE ("released_at" = CURRENT_TIMESTAMP AT TIME ZONE 'UTC')
+#
+# To use this extension, first load it into your Sequel::Database instance:
+#
+#   DB.extension :constant_sql_override
+#
+# Related module: Sequel::ConstantSqlOverride
+
+#
+module Sequel
+  module ConstantSqlOverride
+    module DatabaseMethods
+      # Create the initial empty hash of constant sql overrides.
+      def self.extended(db)
+        db.instance_exec do
+          @constant_sqls ||= {}
+          extend_datasets(DatasetMethods)
+        end
+      end
+
+      # Hash mapping constant symbols to SQL.  For internal use only.
+      attr_reader :constant_sqls # :nodoc:
+
+      # Set the SQL to use for the given Sequel::SQL::Constant
+      def set_constant_sql(constant, override)
+        @constant_sqls[constant.constant] = override
+      end
+
+      # Freeze the constant_sqls hash to prevent adding new overrides.
+      def freeze
+        @constant_sqls.freeze
+        super
+      end
+    end
+
+    module DatasetMethods
+      # Use overridden constant SQL
+      def constant_sql_append(sql, constant)
+        if constant_sql = db.constant_sqls[constant]
+          sql << constant_sql
+        else
+          super
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:constant_sql_override, ConstantSqlOverride::DatabaseMethods)
+end

data/lib/sequel/extensions/constraint_validations.rb

@@ -22,7 +22,7 @@
 # generally want to create it first, before creating any other application
 # tables.
 #
-# Because migrations instance_eval the up and down blocks on a database,
+# Because migrations instance_exec the up and down blocks on a database,
 # using this extension in a migration can be done via:
 #
 #   Sequel.migration do
@@ -43,7 +43,7 @@
 # similar to the validation_helpers model plugin API.  However,
 # instead of having separate validates_* methods, it just adds a validate
 # method that accepts a block to the schema generators.  Like the
-# create_table and alter_table blocks, this block is instance_evaled and
+# create_table and alter_table blocks, this block is instance_execed and
 # offers its own DSL. Example:
 #
 #   DB.create_table(:table) do
@@ -56,8 +56,8 @@
 #     end
 #   end
 #
-# instance_eval is used in this case because create_table and alter_table
-# already use instance_eval, so losing access to the surrounding receiver
+# instance_exec is used in this case because create_table and alter_table
+# already use instance_exec, so losing access to the surrounding receiver
 # is not an issue.
 #
 # Here's a breakdown of the constraints created for each constraint validation
@@ -130,6 +130,10 @@
 #   readd all constraints you want to use inside the alter table block,
 #   making no other changes inside the alter_table block.
 #
+# Dropping a table will automatically delete all constraint validations for
+# that table.  However, altering a table (e.g. to drop a column) will not
+# currently make any changes to the constraint validations metadata.
+#
 # Related module: Sequel::ConstraintValidations
 
 #
@@ -196,9 +200,9 @@ module Sequel
         @generator.validation({:type=>:drop, :name=>constraint})
       end
 
-      # Alias of instance_eval for a nicer API.
+      # Alias of instance_exec for a nicer API.
       def process(&block)
-        instance_eval(&block)
+        instance_exec(&block)
       end
     end
 
@@ -260,10 +264,20 @@ module Sequel
       super do
         extend CreateTableGeneratorMethods
         @validations = []
-        instance_eval(&block) if block
+        instance_exec(&block) if block
       end
     end
 
+    # Drop all constraint validations for a table if dropping the table.
+    def drop_table(*names)
+      names.each do |name|
+        if !name.is_a?(Hash) && table_exists?(constraint_validations_table)
+          drop_constraint_validations_for(:table=>name)
+        end
+      end
+      super
+    end
+
     # Drop the constraint validations table.
     def drop_constraint_validations_table
       drop_table(constraint_validations_table)
@@ -308,7 +322,7 @@ module Sequel
       super do
         extend AlterTableGeneratorMethods
         @validations = []
-        instance_eval(&block) if block
+        instance_exec(&block) if block
       end
     end
 
@@ -343,9 +357,7 @@ module Sequel
     # This allows the code to handle schema qualified tables,
     # without quoting all table names.
     def constraint_validations_literal_table(table)
-      ds = dataset
-      ds.quote_identifiers = false
-      ds.literal(table)
+      dataset.with_quote_identifiers(false).literal(table)
     end
 
     # Before creating the table, add constraints for all of the
@@ -357,6 +369,18 @@ module Sequel
       super
     end
 
+    def constraint_validation_expression(cols, allow_nil)
+      exprs = cols.map do |c|
+        expr = yield c
+        if allow_nil
+          Sequel.|({c=>nil}, expr)
+        else
+          Sequel.&(Sequel.~(c=>nil), expr)
+        end
+      end
+      Sequel.&(*exprs)
+    end
+
     # For the given table, generator, and validations, add constraints
     # to the generator for each of the validations, as well as adding
     # validation metadata to the constraint validations table.
@@ -367,28 +391,44 @@ module Sequel
 
         case validation_type
         when :presence
-          string_check = columns.select{|c| generator_string_column?(generator, table, c)}.map{|c| [Sequel.trim(c), blank_string_value]}
-          generator_add_constraint_from_validation(generator, val, (Sequel.negate(string_check) unless string_check.empty?))
+          strings, non_strings = columns.partition{|c| generator_string_column?(generator, table, c)}
+          if !non_strings.empty? && !allow_nil
+            non_strings_expr = Sequel.&(*non_strings.map{|c| Sequel.~(c=>nil)})
+          end
+
+          unless strings.empty?
+            strings_expr = constraint_validation_expression(strings, allow_nil){|c| Sequel.~(Sequel.trim(c) => blank_string_value)}
+          end
+
+          expr = if non_strings_expr && strings_expr
+            Sequel.&(strings_expr, non_strings_expr)
+          else
+            strings_expr || non_strings_expr
+          end
+
+          if expr
+            generator.constraint(constraint, expr)
+          end
         when :exact_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {Sequel.char_length(c) => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {Sequel.char_length(c) => arg}})
         when :min_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) >= arg}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.char_length(c) >= arg})
         when :max_length
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.char_length(c) <= arg}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.char_length(c) <= arg})
         when *REVERSE_OPERATOR_MAP.keys
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.identifier(c).send(REVERSE_OPERATOR_MAP[validation_type], arg)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.identifier(c).public_send(REVERSE_OPERATOR_MAP[validation_type], arg)})
         when :length_range
           op = arg.exclude_end? ? :< : :<=
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).send(op, arg.end)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| (Sequel.char_length(c) >= arg.begin) & Sequel.char_length(c).public_send(op, arg.end)})
           arg = "#{arg.begin}..#{'.' if arg.exclude_end?}#{arg.end}"
         when :format
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {c => arg}})
           if arg.casefold?
             validation_type = :iformat
           end
           arg = arg.source
         when :includes
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| {c => arg}}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| {c => arg}})
           if arg.is_a?(Range)
             if arg.begin.is_a?(Integer) && arg.end.is_a?(Integer)
               validation_type = :includes_int_range
@@ -409,7 +449,7 @@ module Sequel
             raise Error, "validates includes only supports arrays and ranges currently, cannot handle: #{arg.inspect}"
           end
         when :like, :ilike
-          generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.send(validation_type, c, arg)}))
+          generator.constraint(constraint, constraint_validation_expression(columns, allow_nil){|c| Sequel.public_send(validation_type, c, arg)})
         when :unique
           generator.unique(columns, :name=>constraint)
           columns = [columns.join(',')]
@@ -433,30 +473,13 @@ module Sequel
         end
       end
 
-      ds = from(:sequel_constraint_validations)
+      ds = from(constraint_validations_table)
       unless drop_rows.empty?
         ds.where([:table, :constraint_name]=>drop_rows).delete
       end
       ds.multi_insert(rows.flatten)
     end
 
-    # Add the constraint to the generator, including a NOT NULL constraint
-    # for all columns unless the :allow_nil option is given.
-    def generator_add_constraint_from_validation(generator, val, cons)
-      if val[:allow_nil]
-        nil_cons = Sequel.expr(val[:columns].map{|c| [c, nil]})
-        cons = Sequel.|(nil_cons, cons) if cons
-      else
-        nil_cons = Sequel.negate(val[:columns].map{|c| [c, nil]})
-        cons = cons ? Sequel.&(nil_cons, cons) : nil_cons
-      end
-
-      if cons
-        generator.constraint(val[:name], cons)
-      end
-    end
-
-
     # Introspect the generator to determine if column
     # created is a string or not.
     def generator_string_column?(generator, table, c)

data/lib/sequel/extensions/core_extensions.rb

@@ -12,6 +12,8 @@ def Sequel.core_extensions?
   true
 end
 
+Sequel.extension :symbol_as
+
 # Sequel extends +Array+ to add methods to implement the SQL DSL.
 # Most of these methods require that the array not be empty and that it
 # must consist solely of other arrays that have exactly two elements.
@@ -19,8 +21,8 @@ class Array
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, not matching all of the
   # conditions.
   #
-  #   ~[[:a, true]] # SQL: a IS NOT TRUE
-  #   ~[[:a, 1], [:b, [2, 3]]] # SQL: a != 1 OR b NOT IN (2, 3)
+  #   ~[[:a, true]] # SQL: (a IS NOT TRUE)
+  #   ~[[:a, 1], [:b, [2, 3]]] # SQL: ((a != 1) OR (b NOT IN (2, 3)))
   def ~
     Sequel.~(self)
   end
@@ -28,7 +30,7 @@ class Array
   # Return a <tt>Sequel::SQL::CaseExpression</tt> with this array as the conditions and the given
   # default value and expression.
   #
-  #   [[{:a=>[2,3]}, 1]].case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
+  #   [[{a: [2,3]}, 1]].case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
   #   [[:a, 1], [:b, 2]].case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
   def case(*args)
     ::Sequel::SQL::CaseExpression.new(self, *args)
@@ -40,13 +42,12 @@ class Array
   # this array as a value in a filter, but may be necessary if you are using it as a
   # value with placeholder SQL:
   #
-  #   DB[:a].filter([:a, :b]=>[[1, 2], [3, 4]]) # SQL: (a, b) IN ((1, 2), (3, 4))
-  #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: (a, b) IN ((1 = 2) AND (3 = 4))
-  #   DB[:a].filter('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: (a, b) IN ((1, 2), (3, 4))
+  #   DB[:a].where([:a, :b]=>[[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1, 2), (3, 4)))
+  #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]]) # SQL: ((a, b) IN ((1 = 2) AND (3 = 4)))
+  #   DB[:a].where('(a, b) IN ?', [[1, 2], [3, 4]].sql_value_list) # SQL: ((a, b) IN ((1, 2), (3, 4)))
   def sql_value_list
     ::Sequel::SQL::ValueList.new(self)
   end
-  alias sql_array sql_value_list
 
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching all of the
   # conditions.  Rarely do you need to call this explicitly, as Sequel generally
@@ -55,17 +56,17 @@ class Array
   # and want to use the = operator instead of the IN operator (which is used by default for
   # arrays of two element arrays).
   #
-  #   [[:a, true]].sql_expr # SQL: a IS TRUE
-  #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
+  #   [[:a, true]].sql_expr # SQL: (a IS TRUE)
+  #   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
   def sql_expr
-    Sequel.expr(self)
+    Sequel[self]
   end
 
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching none
   # of the conditions.
   #
-  #   [[:a, true]].sql_negate # SQL: a IS NOT TRUE
-  #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
+  #   [[:a, true]].sql_negate # SQL: (a IS NOT TRUE)
+  #   [[:a, 1], [:b, [2, 3]]].sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
   def sql_negate
     Sequel.negate(self)
   end
@@ -73,8 +74,8 @@ class Array
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this array, matching any of the
   # conditions.
   #
-  #   [[:a, true]].sql_or # SQL: a IS TRUE
-  #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: a = 1 OR b IN (2, 3)
+  #   [[:a, true]].sql_or # SQL: (a IS TRUE)
+  #   [[:a, 1], [:b, [2, 3]]].sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
   def sql_or
     Sequel.or(self)
   end
@@ -85,9 +86,9 @@ class Array
   # concatenation.
   #
   #   [:a].sql_string_join # SQL: a
-  #   [:a, :b].sql_string_join # SQL: a || b
-  #   [:a, 'b'].sql_string_join # SQL: a || 'b'
-  #   ['a', :b].sql_string_join(' ') # SQL: 'a' || ' ' || b
+  #   [:a, :b].sql_string_join # SQL: (a || b)
+  #   [:a, 'b'].sql_string_join # SQL: (a || 'b')
+  #   ['a', :b].sql_string_join(' ') # SQL: ('a' || ' ' || b)
   def sql_string_join(joiner=nil)
     Sequel.join(self, joiner)
   end
@@ -99,8 +100,8 @@ class Hash
   # all of the conditions in this hash and the condition specified by
   # the given argument.
   #
-  #   {:a=>1} & :b # SQL: a = 1 AND b
-  #   {:a=>true} & ~:b # SQL: a IS TRUE AND NOT b
+  #   {a: 1} & :b # SQL: ((a = 1) AND b)
+  #   {a: true} & ~:b # SQL: ((a IS TRUE) AND NOT b)
   def &(ce)
     ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
   end
@@ -109,8 +110,8 @@ class Hash
   # all of the conditions in this hash or the condition specified by
   # the given argument.
   #
-  #   {:a=>1} | :b # SQL: a = 1 OR b
-  #   {:a=>true} | ~:b # SQL: a IS TRUE OR NOT b
+  #   {a: 1} | :b # SQL: ((a = 1) OR b)
+  #   {a: true} | ~:b # SQL: ((a IS TRUE) OR NOT b)
   def |(ce)
     ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
   end
@@ -118,19 +119,17 @@ class Hash
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, not matching all of the
   # conditions.
   #
-  #   ~{:a=>true} # SQL: a IS NOT TRUE
-  #   ~{:a=>1, :b=>[2, 3]} # SQL: a != 1 OR b NOT IN (2, 3)
+  #   ~{a: true} # SQL: (a IS NOT TRUE)
+  #   ~{a: 1, b: [2, 3]} # SQL: ((a != 1) OR (b NOT IN (2, 3)))
   def ~
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
   end
 
   # Return a <tt>Sequel::SQL::CaseExpression</tt> with this hash as the conditions and the given
-  # default value.  Note that the order of the conditions will be arbitrary on ruby 1.8, so all
-  # conditions should be orthogonal.
+  # default value.
   #
-  #   {{:a=>[2,3]}=>1}.case(0) # SQL: CASE WHEN a IN (2, 3) THEN 1 ELSE 0 END
-  #   {:a=>1, :b=>2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
-  #                                 #  or: CASE c WHEN b THEN 2 WHEN a THEN 1 ELSE d END
+  #   {{a: [2,3]}=>1}.case(0) # SQL: CASE WHEN (a IN (2, 3)) THEN 1 ELSE 0 END
+  #   {a: 1, b: 2}.case(:d, :c) # SQL: CASE c WHEN a THEN 1 WHEN b THEN 2 ELSE d END
   def case(*args)
     ::Sequel::SQL::CaseExpression.new(to_a, *args)
   end
@@ -139,8 +138,8 @@ class Hash
   # conditions.  Rarely do you need to call this explicitly, as Sequel generally
   # assumes that hashes specify this type of condition.
   #
-  #   {:a=>true}.sql_expr # SQL: a IS TRUE
-  #   {:a=>1, :b=>[2, 3]}.sql_expr # SQL: a = 1 AND b IN (2, 3)
+  #   {a: true}.sql_expr # SQL: (a IS TRUE)
+  #   {a: 1, b: [2, 3]}.sql_expr # SQL: ((a = 1) AND (b IN (2, 3)))
   def sql_expr
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
   end
@@ -148,8 +147,8 @@ class Hash
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching none
   # of the conditions.
   #
-  #   {:a=>true}.sql_negate # SQL: a IS NOT TRUE
-  #   {:a=>1, :b=>[2, 3]}.sql_negate # SQL: a != 1 AND b NOT IN (2, 3)
+  #   {a: true}.sql_negate # SQL: (a IS NOT TRUE)
+  #   {a: 1, b: [2, 3]}.sql_negate # SQL: ((a != 1) AND (b NOT IN (2, 3)))
   def sql_negate
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
   end
@@ -157,8 +156,8 @@ class Hash
   # Return a <tt>Sequel::SQL::BooleanExpression</tt> created from this hash, matching any of the
   # conditions.
   #
-  #   {:a=>true}.sql_or # SQL: a IS TRUE
-  #   {:a=>1, :b=>[2, 3]}.sql_or # SQL: a = 1 OR b IN (2, 3)
+  #   {a: true}.sql_or # SQL: (a IS TRUE)
+  #   {a: 1, b: [2, 3]}.sql_or # SQL: ((a = 1) OR (b IN (2, 3)))
   def sql_or
     ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
   end
@@ -172,16 +171,16 @@ class String
   # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
   # literalization, e.g.:
   #
-  #   DB[:items].filter(:abc => 'def').sql #=>
-  #     "SELECT * FROM items WHERE (abc = 'def')"
+  #   DB[:items].where(abc: 'def')
+  #   # "SELECT * FROM items WHERE (abc = 'def')"
   #
-  #   DB[:items].filter(:abc => 'def'.lit).sql #=>
-  #     "SELECT * FROM items WHERE (abc = def)"
+  #   DB[:items].where(abc: 'def'.lit)
+  #   # "SELECT * FROM items WHERE (abc = def)"
   #
   # You can also provide arguments, to create a <tt>Sequel::SQL::PlaceholderLiteralString</tt>:
   #
-  #    DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}.sql #=>
-  #      "SELECT count(DISTINCT a) FROM items"
+  #   DB[:items].select{|o| o.count('DISTINCT ?'.lit(:a))}
+  #   # "SELECT count(DISTINCT a) FROM items"
   def lit(*args)
     args.empty? ? Sequel::LiteralString.new(self) : Sequel::SQL::PlaceholderLiteralString.new(self, args)
   end
@@ -195,7 +194,6 @@ end
 
 # Sequel extends +Symbol+ to add methods to implement the SQL DSL.
 class Symbol
-  include Sequel::SQL::AliasMethods
   include Sequel::SQL::CastMethods
   include Sequel::SQL::OrderMethods
   include Sequel::SQL::BooleanMethods
@@ -205,19 +203,15 @@ class Symbol
   include Sequel::SQL::SubscriptMethods
   include Sequel::SQL::ComplexExpressionMethods
 
-  # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.  Usually used to
-  # prevent splitting the symbol.
+  # Returns receiver wrapped in an <tt>Sequel::SQL::Identifier</tt>.
   #
-  #   :a__b # SQL: "a"."b"
-  #   :a__b.identifier # SQL: "a__b"
+  #   :a.identifier # SQL: "a"
   def identifier
     Sequel::SQL::Identifier.new(self)
   end
 
   # Returns a <tt>Sequel::SQL::Function</tt> with this as the function name,
-  # and the given arguments. This is aliased as <tt>Symbol#[]</tt> if the RUBY_VERSION
-  # is less than 1.9.0. Ruby 1.9 defines <tt>Symbol#[]</tt>, and Sequel
-  # doesn't override methods defined by ruby itself.
+  # and the given arguments.
   #
   #   :now.sql_function # SQL: now()
   #   :sum.sql_function(:a) # SQL: sum(a)