sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/core_extensions.rb

@@ -1,11 +1,9 @@
+# frozen-string-literal: true
+#
 # These are extensions to core classes that Sequel enables by default.
 # They make using Sequel's DSL easier by adding methods to Array,
 # Hash, String, and Symbol to add methods that return Sequel
-# expression objects.
-#
-# This extension is currently loaded by default, but that will no
-# longer be true in Sequel 4.  Starting in Sequel 4, you will
-# need to load it manually via:
+# expression objects.  To load the extension:
 #
 #   Sequel.extension :core_extensions
 
@@ -14,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.
@@ -21,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
@@ -30,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)
@@ -42,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
@@ -57,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
@@ -75,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
@@ -87,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
@@ -101,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
@@ -111,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
@@ -120,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
@@ -141,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
@@ -150,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
@@ -159,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
@@ -174,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
@@ -197,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
@@ -207,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)

data/lib/sequel/extensions/core_refinements.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # These are refinements to core classes that allow the Sequel
 # DSL to be used without modifying the core classes directly.
 # After loading the extension via:
@@ -8,15 +10,17 @@
 #
 #   using Sequel::CoreRefinements
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::CoreRefinements
   refine Array do
     # 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
@@ -24,7 +28,7 @@ module Sequel::CoreRefinements
     # 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)
@@ -36,9 +40,9 @@ module Sequel::CoreRefinements
     # 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
@@ -50,17 +54,17 @@ module Sequel::CoreRefinements
     # 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
@@ -68,8 +72,8 @@ module Sequel::CoreRefinements
     # 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
@@ -80,9 +84,9 @@ module Sequel::CoreRefinements
     # 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
@@ -93,8 +97,8 @@ module Sequel::CoreRefinements
     # 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
@@ -103,8 +107,8 @@ module Sequel::CoreRefinements
     # 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
@@ -112,19 +116,17 @@ module Sequel::CoreRefinements
     # 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
@@ -133,8 +135,8 @@ module Sequel::CoreRefinements
     # 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
@@ -142,8 +144,8 @@ module Sequel::CoreRefinements
     # 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
@@ -151,8 +153,8 @@ module Sequel::CoreRefinements
     # 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
@@ -165,16 +167,16 @@ module Sequel::CoreRefinements
     # 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
@@ -197,19 +199,15 @@ module Sequel::CoreRefinements
     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"
+    #   :ab.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)

data/lib/sequel/extensions/current_datetime_timestamp.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+#
 # The current_datetime_timestamp extension makes Dataset#current_datetime
 # return an object that operates like Sequel.datetime_class.now, but will
 # be literalized as CURRENT_TIMESTAMP.
@@ -20,6 +22,8 @@
 # datasets of a given database.
 #
 #   DB.extension(:current_datetime_timestamp)
+#
+# Related module: Sequel::CurrentDateTimeTimestamp
 
 #
 module Sequel
@@ -28,7 +32,7 @@ module Sequel
       # Return an instance of Sequel.datetime_class that will be literalized
       # as CURRENT_TIMESTAMP.
       def current_datetime
-        MAP.fetch(Sequel.datetime_class).now
+        (Sequel.datetime_class == ::Time ? Time : DateTime).now
       end
 
       private
@@ -49,9 +53,6 @@ module Sequel
 
     # DateTime subclass literalized as CURRENT_TIMESTAMP
     class DateTime < ::DateTime; end
-
-    # Mapping of Time/DateTime classes to subclasses literalized as CURRENT_TIMESTAMP
-    MAP = {::Time=>Time, ::DateTime=>DateTime}
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)