sequel 4.49.0 → 5.3.0

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
@@ -196,9 +196,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,7 +260,7 @@ module Sequel
       super do
         extend CreateTableGeneratorMethods
         @validations = []
-        instance_eval(&block) if block
+        instance_exec(&block) if block
       end
     end
 
@@ -308,7 +308,7 @@ module Sequel
       super do
         extend AlterTableGeneratorMethods
         @validations = []
-        instance_eval(&block) if block
+        instance_exec(&block) if block
       end
     end
 
@@ -374,10 +374,10 @@ module Sequel
         when :max_length
           generator_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|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_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|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_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|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}}))
@@ -407,7 +407,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_add_constraint_from_validation(generator, val, Sequel.&(*columns.map{|c| Sequel.public_send(validation_type, c, arg)}))
         when :unique
           generator.unique(columns, :name=>constraint)
           columns = [columns.join(',')]

data/lib/sequel/extensions/core_extensions.rb

@@ -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,16 +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].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))
+  #   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
-  def sql_array
-    Sequel::Deprecation.deprecate("Array#sql_array in the core_extensions extension", "Use Array#sql_value_list instead")
-    sql_value_list
-  end
 
   # 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
@@ -60,8 +56,8 @@ 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[self]
   end
@@ -69,8 +65,8 @@ class Array
   # 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
@@ -78,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
@@ -90,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
@@ -104,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
@@ -114,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
@@ -123,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
@@ -144,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
@@ -153,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
@@ -162,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
@@ -177,16 +171,16 @@ class String
   # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
   # literalization, e.g.:
   #
-  #   DB[:items].where(:abc => 'def').sql #=>
-  #     "SELECT * FROM items WHERE (abc = 'def')"
+  #   DB[:items].where(abc: 'def')
+  #   # "SELECT * FROM items WHERE (abc = 'def')"
   #
-  #   DB[:items].where(: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
@@ -209,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

@@ -17,8 +17,8 @@ module Sequel::CoreRefinements
     # 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
@@ -26,7 +26,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)
@@ -38,9 +38,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].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))
+    #   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
@@ -52,8 +52,8 @@ 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[self]
     end
@@ -61,8 +61,8 @@ module Sequel::CoreRefinements
     # 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
@@ -70,8 +70,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
@@ -82,9 +82,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
@@ -95,8 +95,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
@@ -105,8 +105,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
@@ -114,19 +114,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
@@ -135,8 +133,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
@@ -144,8 +142,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
@@ -153,8 +151,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
@@ -167,16 +165,16 @@ module Sequel::CoreRefinements
     # Converts a string into a <tt>Sequel::LiteralString</tt>, in order to override string
     # literalization, e.g.:
     #
-    #   DB[:items].where(:abc => 'def').sql #=>
-    #     "SELECT * FROM items WHERE (abc = 'def')"
+    #   DB[:items].where(abc: 'def')
+    #   # "SELECT * FROM items WHERE (abc = 'def')"
     #
-    #   DB[:items].where(: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
@@ -199,19 +197,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

@@ -53,10 +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}
-    Sequel::Deprecation.deprecate_constant(self, :MAP)
   end
 
   Dataset.register_extension(:current_datetime_timestamp, CurrentDateTimeTimestamp::DatasetMethods)

data/lib/sequel/extensions/date_arithmetic.rb

@@ -10,8 +10,8 @@
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
 # to return Sequel expressions:
 #
-#   add = Sequel.date_add(:date_column, :years=>1, :months=>2, :days=>3)
-#   sub = Sequel.date_sub(:date_column, :hours=>1, :minutes=>2, :seconds=>3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, days: 3)
+#   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
 # support for specifying the interval as an ActiveSupport::Duration
@@ -66,8 +66,6 @@ module Sequel
         DERBY_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit("SQL_TSI_#{s.to_s.upcase[0...-1]}").freeze}).freeze
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map(&:freeze)).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
-        FDBSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.chop).freeze}).freeze
-        Sequel::Deprecation.deprecate_constant(self, :FDBSQL_DURATION_UNITS)
 
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
@@ -93,8 +91,7 @@ module Sequel
               args << "#{value} #{sql_unit}"
             end
             return function_sql_append(sql, Sequel.function(:datetime, *args))
-          # SEQUEL5: Remove cubrid
-          when :mysql, :hsqldb, :cubrid
+          when :mysql, :hsqldb
             if db_type == :hsqldb
               # HSQLDB requires 2.2.9+ for the DATE_ADD function
               expr = Sequel.cast(expr, Time)
@@ -181,12 +178,15 @@ module Sequel
                raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
              end
           end
-          interval
+          Hash[interval]
         else
           h = Hash.new(0)
           interval.parts.each{|unit, value| h[unit] += value}
           Hash[h]
         end
+
+        @interval.freeze
+        freeze
       end
 
       to_s_method :date_add_sql

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -10,24 +10,28 @@
 #
 #   DB.extension :duplicate_columns_handler
 #
+# or into individual datasets:
+#
+#   ds = DB[:items].extension(:duplicate_columns_handler)
+#
 # A database option is introduced: :on_duplicate_columns. It accepts a Symbol
 # or any object that responds to :call.
 #
-#   :on_duplicate_columns => :raise
-#   :on_duplicate_columns => :warn
-#   :on_duplicate_columns => :ignore
-#   :on_duplicate_columns => proc { |columns| arbitrary_condition? ? :raise : :warn }
+#   on_duplicate_columns: :raise
+#   on_duplicate_columns: :warn
+#   on_duplicate_columns: :ignore
+#   on_duplicate_columns: lambda{|columns| arbitrary_condition? ? :raise : :warn}
 #
 # You may also configure duplicate columns handling for a specific dataset:
 #
 #   ds.on_duplicate_columns(:warn)
 #   ds.on_duplicate_columns(:raise)
 #   ds.on_duplicate_columns(:ignore)
-#   ds.on_duplicate_columns { |columns| arbitrary_condition? ? :raise : :warn }
-#   ds.on_duplicate_columns(proc { |columns| arbitrary_condition? ? :raise : :warn })
+#   ds.on_duplicate_columns{|columns| arbitrary_condition? ? :raise : :warn}
+#   ds.on_duplicate_columns(lambda{|columns| arbitrary_condition? ? :raise : :warn})
 #
 # If :raise is specified, a Sequel::DuplicateColumnError is raised.
-# If :warn is specified, you will receive a warning via `warn`.
+# If :warn is specified, you will receive a warning via +warn+.
 # If a callable is specified, it will be called.
 # If no on_duplicate_columns is specified, the default is :warn.
 #
@@ -45,8 +49,7 @@ module Sequel
 
     private
 
-    # Override the attr_writer to check for duplicate columns, and call
-    # handle_duplicate_columns if necessary.
+    # Call handle_duplicate_columns if there are duplicate columns.
     def columns=(cols)
       if cols && cols.uniq.size != cols.size
         handle_duplicate_columns(cols)

data/lib/sequel/extensions/empty_array_consider_nulls.rb

@@ -4,9 +4,9 @@
 # array value to consider NULL values if one of the referenced
 # columns is NULL:
 #
-#   DB[:test].where(:name=>[])
+#   DB[:test].where(name: [])
 #   # SELECT * FROM test WHERE (name != name)
-#   DB[:test].exclude(:name=>[])
+#   DB[:test].exclude(name: [])
 #   # SELECT * FROM test WHERE (name = name)
 #
 # The default Sequel behavior is to ignore NULLs, as the above

data/lib/sequel/extensions/eval_inspect.rb

@@ -36,16 +36,7 @@ module Sequel
         "{#{obj.map{|k, v| "#{eval_inspect(k)} => #{eval_inspect(v)}"}.join(', ')}}"
       when Time
         datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
-        if RUBY_VERSION < '1.9'
-        # :nocov:
-          # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
-          hours, mins = obj.utc_offset.divmod(3600)
-          mins /= 60
-          "#{obj.class}.parse(#{obj.strftime("#{datepart}%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
-        # :nocov:
-        else
-          "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
-        end
+        "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
       when DateTime
         # Ignore date of calendar reform
         "DateTime.parse(#{obj.strftime('%FT%T.%N%z').inspect})"
@@ -73,9 +64,11 @@ module Sequel
         args = inspect_args.map do |arg|
           if arg.is_a?(String) && arg =~ /\A\*/
             # Special case string arguments starting with *, indicating that
-            # they should return an array to be splatted as the remaining arguments
+            # they should return an array to be splatted as the remaining arguments.
+            # Allow calling private methods to get inspect output.
             send(arg.sub('*', '')).map{|a| Sequel.eval_inspect(a)}.join(', ')
           else
+            # Allow calling private methods to get inspect output.
             Sequel.eval_inspect(send(arg))
           end
         end