sequel 4.37.0 → 4.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e32a73f763f4abf6ea2b3e2833cd0d0a85356842
-  data.tar.gz: 9856a7e6a4c175f16c745339609b8b4d3d6b4d61
+  metadata.gz: fbbe9aec719ae1c6ace4c686bf0e02f352b1283a
+  data.tar.gz: 347e71c258109c785c11b55e354fd4f616060cdc
 SHA512:
-  metadata.gz: 5286ffd2c900e56b4d07598dd6ecb4fcdf7bfd5694a56537ba4ca29a55f1801055e42d6ccd2b49c2aa655065f63380d8f068ef55602bb81c768947540788afa4
-  data.tar.gz: 842a025e1ecdcbe2990dbfd5f40ebcf2d9db9408d73e62e73ef4c36e0a56c27affa76a60d780845abb34d23e3108d6783fb3f206f7a13f304daad868d62b2667
+  metadata.gz: 3e8ef32de9f9efb9ae6b03598ca6a2809409b51a60fe2759fcd2c1556d8376c08fe31366db86f7016ea25745b16f6323428838f6ebd72c96ef4a7036514cf8ce
+  data.tar.gz: 986105b21db0f6ffa3455e4cb8972a0b4af165026455d888bdec4054d3b31c71b8118e036c8f201934e99070ce11b3b88b32908a4d405225a11d97383fa0fd3b

data/CHANGELOG

@@ -1,3 +1,15 @@
+=== 4.38.0 (2016-09-01)
+
+* Support :driver_options option when using the postgres adapter with pg driver (jeremyevans)
+
+* Don't use after commit/rollback database hooks if the model instance methods are not overridden (jeremyevans)
+
+* Add SQL::NumericMethods#coerce, allowing code such as Sequel.expr{1 - x} (jeremyevans)
+
+* Support ** operator for exponentiation on expressions, similar to +, -, *, and / (jeremyevans)
+
+* Add Sequel::SQLTime.date= to set the date used for SQLTime instances (jeremyevans)
+
 === 4.37.0 (2016-08-01)
 
 * Add support for regular expression matching on Oracle 10g+ using REGEXP_LIKE (johndcaldwell) (#1221)

data/doc/core_extensions.rdoc

@@ -40,6 +40,16 @@ All of Sequel's extensions to the core classes are stored in Sequel's core_exten
 
 Sequel has no internal dependency on the core extensions.  This includes Sequel's core, Sequel::Model, and all plugins and extensions that ship with Sequel.  However, it is possible that external plugins and extensions will depend on the core extensions.  Such plugins and extensions should be updated so that they no longer depend on the core extensions.
 
+== Refinements
+
+Most of the these extensions can be added on a per-file basis using refinements (if you are using Ruby 2.0+).  To use refinements, first load them:
+
+  Sequel.extension :core_refinements
+
+Then for each file where you want to use the refinements:
+
+  using Sequel::CoreRefinements
+
 == Core Extension Methods
 
 This section will briefly describe all of the methods added to the core classes, and what the alternative method is that doesn't require the core extensions.
@@ -130,6 +140,11 @@ The standard mathematical operators are defined on Symbol, and return a Sequel n
     :a - :b # SQL: a - b
     :a * :b # SQL: a * b
     :a / :b # SQL: a / b 
+    :a ** :b # SQL: power(a, b)
+
+Sequel also supports ruby's coercion protocols on symbols (note that this does not work when using refinements):
+
+    1 + :b # SQL: 1 + b
 
 Alternatives:
 
@@ -137,6 +152,7 @@ Alternatives:
     Sequel.-(:a, :b)
     Sequel.*(:a, :b)
     Sequel./(:a, :b)
+    Sequel.**(:a, :b)
 
 ==== *
 

data/doc/dataset_filtering.rdoc

@@ -92,6 +92,9 @@ This works for the standard inequality and arithmetic operators:
   items.where{price / 100 >= 200}.sql
   #=> "SELECT * FROM items WHERE ((price / 100) >= 200)
 
+  items.where{price ** 2 >= 200}.sql
+  #=> "SELECT * FROM items WHERE (power(price, 2) >= 200)
+
 You use the overloaded bitwise and (&) and or (|) operators to combine expressions:
 
   items.where{(price + 100 < 200) & (price * 100 <= 200)}.sql

data/doc/opening_databases.rdoc

@@ -331,6 +331,7 @@ The following additional options are supported:
                                 as a string, or :float to convert to an infinite float.
 :connect_timeout :: Set the number of seconds to wait for a connection (default 20, only respected
                     if using the pg library).
+:driver_options :: A hash of options to pass to the underlying driver (only respected if using the pg library)
 :encoding :: Set the client_encoding to the given string
 :notice_receiver :: A proc that be called with the PGresult objects that have notice or warning messages.
                     The default notice receiver just prints the messages to stderr, but this can be used

data/doc/release_notes/4.38.0.txt

@@ -0,0 +1,67 @@
+= New Features
+
+* Sequel::SQL::NumericMethods#coerce has been added, which adds
+  support for ruby's coercion protocol when performing numeric
+  operations.  Previously, Sequel supported code like:
+
+    Sequel.expr{a - 1}
+
+  This is because a in this case returns a Sequel::SQL::Indentifier,
+  which defines #- to return a Sequel::SQL::NumericExpression.  By
+  supporting #coerce, the following code now also works:
+
+    Sequel.expr{1 - a}
+
+  This is because Integer#- calls #coerce on the argument if it is
+  defined (ruby's coercion protocol).  Previously, you had to handle
+  this differently, using something like:
+
+    Sequel.expr(1) - a
+    # or
+    Sequel.-(1, a)
+
+* Sequel now supports the ** operator for exponentiation on
+  expressions, similar to the +, -, *, and / operators.  Sequel uses
+  the database power function to implement this by default on the
+  databases that support it (most of them).  On Access, it uses the ^
+  operator, on Derby it is emulated using a combination of exp/ln
+  (with some loss of precision).  SQLite doesn't support a power
+  function at all, but Sequel emulates it using multiplication for
+  known integer exponents.
+
+* Sequel::SQLTime.date= has been added, which allows you to set the
+  date used for Sequel::SQLTime instances.  Sequel::SQLTime is a
+  subclass of Time that is literalized using only the time components,
+  and is the ruby class used to store values of database time columns
+  on most adapters.  Sequel::SQLTime defaults to using the current
+  date, but you can now set a specific date, for more consistency with
+  some drivers (Mysql2 uses 2000-01-01, tiny_tds uses 1900-01-01).
+
+* The postgres adapter now supports a :driver_options option when
+  using the pg driver, which is passed directly to pg.  This can be
+  used to specify a client SSL certificate or to specify the
+  certificate authority root certificate when using
+  :sslmode=>'verify-full'.
+
+= Other Improvements
+
+* Sequel no longer uses after_commit/rollback database hooks by
+  default if the after_commit/after_rollback model methods are not
+  overridden. This provides a performance speedup, but the main
+  benefit is that it no longer causes memory issues when saving a
+  large number of model instances in a single transaction, and it
+  also works with prepared transactions/2 phase commit.  You can
+  still set use_after_commit_rollback= manually to force the
+  after_commit/rollback setting.
+
+  Note that Sequel 5 will move after_commit/rollback model hooks to
+  a plugin, and the default and recommended approach will be to use
+  the database after_commit/rollback hooks in the after_save or
+  similar model hooks.
+
+= Backwards Compatibility
+
+* The Sequel::Model use_after_commit_rollback class and instance
+  methods now return nil by default instead of true.  nil now
+  indicates the default behavior of checking whether the appropriate
+  model hook has been defined, and only adding a database hook if so.

data/doc/sql.rdoc

@@ -368,6 +368,7 @@ The standard mathematical operates are defined on most Sequel-specific expressio
   Sequel.expr(:table__column) - 1 # "table"."column" - 1
   Sequel.qualify(:table, :column) * 1 # "table"."column" * 1
   Sequel.expr(:column) / 1 # "column" / 1
+  Sequel.expr(:column) ** 1 # power("column", 1)
 
 You can also call the operator methods directly on the Sequel module:
 
@@ -375,15 +376,12 @@ You can also call the operator methods directly on the Sequel module:
   Sequel.-(:table__column, 1) # "table"."column" - 1
   Sequel.*(Sequel.qualify(:table, :column), 1) # "table"."column" * 1
   Sequel./(:column, 1) # "column" / 1
+  Sequel.**(:column, 1) # power("column", 1)
 
-Note that the following does not work:
+Note that since Sequel implements support for ruby's coercion protocol, the following also works:
 
-  1 + Sequel.expr(:column) # raises TypeError
-
-For commutative operates such as + and *, this isn't a problem as you can just reorder, but non-commutative operators such as - and / cannot be expressed directly.  The solution is to use one of the methods on the Sequel module:
-
-  Sequel.expr(1) / :column # (1 / "column")
-  Sequel./(1, :column) # (1 / "column")
+  1 + Sequel.expr(:column)
+  1 - Sequel.qualify(:table__column)
 
 === Boolean Operators (AND OR)
 

data/lib/sequel/adapters/jdbc/derby.rb

@@ -224,6 +224,12 @@ module Sequel
             complex_expression_emulate_append(sql, op, args)
           when :&, :|, :^, :<<, :>>
             raise Error, "Derby doesn't support the #{op} operator"
+          when :**
+            sql << 'exp('
+            literal_append(sql, args[1])
+            sql << ' * ln('
+            literal_append(sql, args[0])
+            sql << "))"
           when :extract
             sql << args.at(0).to_s << PAREN_OPEN
             literal_append(sql, args.at(1))

data/lib/sequel/adapters/postgres.rb

@@ -227,8 +227,8 @@ module Sequel
       # client encoding for the connection, :connect_timeout is a
       # connection timeout in seconds, :sslmode sets whether postgres's
       # sslmode, and :notice_receiver handles server notices in a proc.
-      # :connect_timeout, :ssl_mode, and :notice_receiver are only supported
-      # if the pg driver is used.
+      # :connect_timeout, :driver_options, :sslmode, and :notice_receiver
+      # are only supported if the pg driver is used.
       def connect(server)
         opts = server_opts(server)
         if SEQUEL_POSTGRES_USES_PG
@@ -241,6 +241,7 @@ module Sequel
             :connect_timeout => opts[:connect_timeout] || 20,
             :sslmode => opts[:sslmode]
           }.delete_if { |key, value| blank_object?(value) }
+          connection_params.merge!(opts[:driver_options]) if opts[:driver_options]
           conn = Adapter.connect(connection_params)
 
           conn.instance_variable_set(:@prepared_statements, {})

data/lib/sequel/adapters/shared/access.rb

@@ -157,6 +157,12 @@ module Sequel
             c ||= true
           end
           sql << PAREN_CLOSE
+        when :**
+          sql << PAREN_OPEN
+          literal_append(sql, args[0])
+          sql << ' ^ '
+          literal_append(sql, args[1])
+          sql << PAREN_CLOSE
         when :extract
           part = args.at(0)
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]

data/lib/sequel/adapters/shared/sqlite.rb

@@ -555,6 +555,31 @@ module Sequel
           complex_expression_sql_append(sql, (op == :"NOT ILIKE" ? :ILIKE : :LIKE), args)
         when :^
           complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.lit(["((~(", " & ", ")) & (", " | ", "))"], a, b, a, b)}
+        when :**
+          unless (exp = args[1]).is_a?(Integer)
+            raise(Sequel::Error, "can only emulate exponentiation on SQLite if exponent is an integer, given #{exp.inspect}")
+          end
+          case exp
+          when 0
+            sql << '1'
+          else
+            sql << '('
+            arg = args.at(0)
+            if exp < 0
+              invert = true
+              exp = exp.abs
+              sql << '(1.0 / ('
+            end
+            (exp - 1).times do 
+              literal_append(sql, arg)
+              sql << " * "
+            end
+            literal_append(sql, arg)
+            sql << PAREN_CLOSE
+            if invert
+              sql << "))"
+            end
+          end
         when :extract
           part = args.at(0)
           raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]

data/lib/sequel/dataset/sql.rb

@@ -476,6 +476,8 @@ module Sequel
         sql << PAREN_CLOSE
       when :ILIKE, :'NOT ILIKE'
         complex_expression_sql_append(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|v| Sequel.function(:UPPER, v)})
+      when :**
+        function_sql_append(sql, Sequel.function(:power, *args))
       when *TWO_ARITY_OPERATORS
         if REGEXP_OPERATORS.include?(op) && !supports_regexp?
           raise InvalidOperation, "Pattern matching via regular expressions is not supported on #{db.database_type}"

data/lib/sequel/extensions/connection_expiration.rb

@@ -10,6 +10,11 @@
 #
 #   DB.extension(:connection_expiration)
 #
+# The default connection timeout is 14400 seconds (4 hours).
+# To override it:
+#
+#   DB.pool.connection_expiration_timeout = 3600 # 1 hour
+#
 # Note that this extension only affects the default threaded
 # and the sharded threaded connection pool.  The single
 # threaded and sharded single threaded connection pools are

data/lib/sequel/model.rb

@@ -117,7 +117,7 @@ module Sequel
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
-    @use_after_commit_rollback = true
+    @use_after_commit_rollback = nil
     @use_transactions = true
 
     Sequel.require %w"default_inflections inflections plugins dataset_module base exceptions errors", "model"

data/lib/sequel/model/base.rb

@@ -1946,7 +1946,8 @@ module Sequel
       # allow running inside a transaction
       def _destroy(opts)
         sh = {:server=>this_server}
-        db.after_rollback(sh){after_destroy_rollback} if uacr = use_after_commit_rollback
+        uacr = use_after_commit_rollback
+        db.after_rollback(sh){after_destroy_rollback} if uacr.nil? ? (method(:after_destroy_rollback).owner != InstanceMethods) : uacr
         called = false
         around_destroy do
           called = true
@@ -1956,7 +1957,7 @@ module Sequel
           true
         end
         raise_hook_failure(:around_destroy) unless called
-        db.after_commit(sh){after_destroy_commit} if uacr
+        db.after_commit(sh){after_destroy_commit} if uacr.nil? ? (method(:after_destroy_commit).owner != InstanceMethods) : uacr
         self
       end
       
@@ -2025,7 +2026,8 @@ module Sequel
       # it's own transaction.
       def _save(opts)
         sh = {:server=>this_server}
-        db.after_rollback(sh){after_rollback} if uacr = use_after_commit_rollback
+        uacr = use_after_commit_rollback
+        db.after_rollback(sh){after_rollback} if uacr.nil? ? (method(:after_rollback).owner != InstanceMethods) : uacr
         pk = nil
         called_save = false
         called_cu = false
@@ -2071,7 +2073,7 @@ module Sequel
         end
         raise_hook_failure(:around_save) unless called_save
         _after_save(pk)
-        db.after_commit(sh){after_commit} if uacr
+        db.after_commit(sh){after_commit} if uacr.nil? ? (method(:after_commit).owner != InstanceMethods) : uacr
         self
       end
       

data/lib/sequel/sql.rb

@@ -45,10 +45,21 @@ module Sequel
   # Time subclass that gets literalized with only the time value, so it operates
   # like a standard SQL time type.
   class SQLTime < ::Time
-    # Create a new SQLTime instance given an hour, minute, and second.
-    def self.create(hour, minute, second, usec = 0)
-      t = now
-      local(t.year, t.month, t.day, hour, minute, second, usec)
+    @date = nil
+
+    class << self
+      # Set the date used for SQLTime instances.
+      attr_writer :date
+
+      def date
+        @date || now
+      end
+
+      # Create a new SQLTime instance given an hour, minute, and second.
+      def create(hour, minute, second, usec = 0)
+        t = date
+        local(t.year, t.month, t.day, hour, minute, second, usec)
+      end
     end
 
     # Return a string in HH:MM:SS format representing the time.
@@ -163,9 +174,9 @@ module Sequel
         :'NOT ILIKE'=>:ILIKE}
 
       # Standard mathematical operators used in +NumericMethods+
-      MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
+      MATHEMATICAL_OPERATORS = [:+, :-, :/, :*, :**]
 
-      # Bitwise mathematical operators used in +NumericMethods+
+      # Bitwise mathematical operators used in +BitwiseMethods+
       BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%]
 
       # Operators that check for equality
@@ -190,10 +201,10 @@ module Sequel
       LIKE_OPERATORS = [:LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE']
 
       # Operator symbols that take exactly two arguments
-      TWO_ARITY_OPERATORS = EQUALITY_OPERATORS + INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS + REGEXP_OPERATORS + LIKE_OPERATORS
+      TWO_ARITY_OPERATORS = EQUALITY_OPERATORS + INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS + REGEXP_OPERATORS + LIKE_OPERATORS + [:**]
 
       # Operator symbols that take one or more arguments
-      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS
+      N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS - [:**]
 
       # Operator symbols that take only a single argument
       ONE_ARITY_OPERATORS = [:NOT, :NOOP, :'B~']
@@ -775,8 +786,21 @@ module Sequel
     #
     #   :a + 'b' # "a" || 'b'
     module NumericMethods
-      ComplexExpression::MATHEMATICAL_OPERATORS.each do |o|
-        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__) unless o == :+
+      (ComplexExpression::MATHEMATICAL_OPERATORS - [:+]).each do |o|
+        module_eval("def #{o}(o) NumericExpression.new(#{o.inspect}, self, o) end", __FILE__, __LINE__)
+      end
+
+      # If the argument given is Numeric, treat it as a NumericExpression,
+      # allowing code such as:
+      #
+      #   1 + Sequel.expr(:x) # SQL: (1 + x)
+      #   Sequel.expr{1 - x(y)} # SQL: (1 - x(y))
+      def coerce(other)
+        if other.is_a?(Numeric)
+          [SQL::NumericExpression.new(:NOOP, other), self]
+        else
+          super 
+        end
       end
 
       # Use || as the operator when called with StringExpression and String instances,
@@ -852,6 +876,13 @@ module Sequel
           END
         end
       end
+
+      # Return NumericExpression for the exponentiation:
+      #
+      #   Sequel.**(2, 3) # SQL: power(2, 3)
+      def **(a, b)
+        SQL::NumericExpression.new(:**, a, b)
+      end
       
       # Invert the given expression.  Returns a <tt>Sequel::SQL::BooleanExpression</tt>
       # created from this argument, not matching all of the conditions.

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

data/spec/core/expression_filters_spec.rb

@@ -134,6 +134,7 @@ describe "Blockless Ruby Filters" do
     @d.lit(Sequel.expr(:x) - true).must_equal "(x - 't')"
     @d.lit(Sequel.expr(:x) / false).must_equal "(x / 'f')"
     @d.lit(Sequel.expr(:x) * nil).must_equal '(x * NULL)'
+    @d.lit(Sequel.expr(:x) ** 1).must_equal 'power(x, 1)'
     @d.lit(Sequel.join([:x, nil])).must_equal '(x || NULL)'
   end
 
@@ -145,6 +146,17 @@ describe "Blockless Ruby Filters" do
     @d.lit(Sequel.expr(:x) + Sequel.expr(:y).like('a')).must_equal "(x + (y LIKE 'a' ESCAPE '\\'))"
     @d.lit(Sequel.expr(:x) - ~Sequel.expr(:y).like('a')).must_equal "(x - (y NOT LIKE 'a' ESCAPE '\\'))"
     @d.lit(Sequel.join([:x, ~Sequel.expr(:y).like('a')])).must_equal "(x || (y NOT LIKE 'a' ESCAPE '\\'))"
+    @d.lit(Sequel.expr(:x) ** (Sequel.expr(:y) + 1)).must_equal 'power(x, (y + 1))'
+  end
+
+  it "should allow mathematical or string operations on numerics when argument is a generic or numeric expressions" do
+    @d.lit(1 + Sequel.expr(:x)).must_equal '(1 + x)'
+    @d.lit(2**65 - Sequel.+(:x, 1)).must_equal "(#{2**65} - (x + 1))"
+    @d.lit(1.0 / Sequel.function(:x)).must_equal '(1.0 / x())'
+    @d.lit(BigDecimal.new('1.0') * Sequel.expr(:a__y)).must_equal '(1.0 * a.y)'
+    @d.lit(2 ** Sequel.cast(:x, Integer)).must_equal 'power(2, CAST(x AS integer))'
+    @d.lit(1 + Sequel.lit('x')).must_equal '(1 + x)'
+    @d.lit(1 + Sequel.lit('?', :x)).must_equal '(1 + x)'
   end
 
   it "should support AND conditions via &" do
@@ -192,6 +204,7 @@ describe "Blockless Ruby Filters" do
     @d.l(Sequel.lit('x').like('a')).must_equal '(x LIKE \'a\' ESCAPE \'\\\')'
     @d.l(Sequel.lit('x') + 1 > 100).must_equal '((x + 1) > 100)'
     @d.l((Sequel.lit('x') * :y) < 100.01).must_equal '((x * y) < 100.01)'
+    @d.l((Sequel.lit('x') ** :y) < 100.01).must_equal '(power(x, y) < 100.01)'
     @d.l((Sequel.lit('x') - Sequel.expr(:y)/2) >= 100000000000000000000000000000000000).must_equal '((x - (y / 2)) >= 100000000000000000000000000000000000)'
     @d.l((Sequel.lit('z') * ((Sequel.lit('x') / :y)/(Sequel.expr(:x) + :y))) <= 100).must_equal '((z * (x / y / (x + y))) <= 100)'
     @d.l(~((((Sequel.lit('x') - :y)/(Sequel.expr(:x) + :y))*:z) <= 100)).must_equal '((((x - y) / (x + y)) * z) > 100)'
@@ -397,6 +410,7 @@ describe "Blockless Ruby Filters" do
     @d.lit(d - 1).must_equal '((SELECT a FROM items) - 1)'
     @d.lit(d * 1).must_equal '((SELECT a FROM items) * 1)'
     @d.lit(d / 1).must_equal '((SELECT a FROM items) / 1)'
+    @d.lit(d ** 1).must_equal 'power((SELECT a FROM items), 1)'
 
     @d.lit(d => 1).must_equal '((SELECT a FROM items) = 1)'
     @d.lit(Sequel.~(d => 1)).must_equal '((SELECT a FROM items) != 1)'
@@ -665,6 +679,7 @@ describe Sequel::SQL::VirtualRow do
     @d.l{|o| o.+(1, :b) > 2}.must_equal '((1 + "b") > 2)'
     @d.l{|o| o.-(1, :b) < 2}.must_equal '((1 - "b") < 2)'
     @d.l{|o| o.*(1, :b) >= 2}.must_equal '((1 * "b") >= 2)'
+    @d.l{|o| o.**(1, :b) >= 2}.must_equal '(power(1, "b") >= 2)'
     @d.l{|o| o./(1, :b) <= 2}.must_equal '((1 / "b") <= 2)'
     @d.l{|o| o.~(:a=>1)}.must_equal '("a" != 1)'
     @d.l{|o| o.~([[:a, 1], [:b, 2]])}.must_equal '(("a" != 1) OR ("b" != 2))'
@@ -934,6 +949,16 @@ describe "Sequel core extension replacements" do
     end
   end
 
+  it "Sequel.** should use power function if given 2 arguments" do
+    l(Sequel.**(1, 2), 'power(1, 2)')
+  end
+
+  it "Sequel.** should raise if not given 2 arguments" do
+    proc{Sequel.**}.must_raise(ArgumentError)
+    proc{Sequel.**(1)}.must_raise(ArgumentError)
+    proc{Sequel.**(1, 2, 3)}.must_raise(ArgumentError)
+  end
+
   it "Sequel.like should use a LIKE expression" do
     l(Sequel.like('a', 'b'), "('a' LIKE 'b' ESCAPE '\\')")
     l(Sequel.like(:a, :b), "(a LIKE b ESCAPE '\\')")
@@ -1048,12 +1073,24 @@ describe "Sequel::SQLTime" do
   before do
     @db = Sequel.mock
   end
+  after do
+    Sequel::SQLTime.date = nil
+  end
 
   it ".create should create from hour, minutes, seconds and optional microseconds" do
     @db.literal(Sequel::SQLTime.create(1, 2, 3)).must_equal "'01:02:03.000000'"
     @db.literal(Sequel::SQLTime.create(1, 2, 3, 500000)).must_equal "'01:02:03.500000'"
   end
 
+  it ".create should use today's date by default" do
+    Sequel::SQLTime.create(1, 2, 3).strftime('%Y-%m-%d').must_equal Date.today.strftime('%Y-%m-%d')
+  end
+
+  it ".create should use specific date if set" do
+    Sequel::SQLTime.date = Date.new(2000)
+    Sequel::SQLTime.create(1, 2, 3).strftime('%Y-%m-%d').must_equal Date.new(2000).strftime('%Y-%m-%d')
+  end
+
   it "#to_s should include hour, minute, and second by default" do
     Sequel::SQLTime.create(1, 2, 3).to_s.must_equal "01:02:03"
     Sequel::SQLTime.create(1, 2, 3, 500000).to_s.must_equal "01:02:03"
@@ -1082,6 +1119,7 @@ describe "Sequel::SQL::Wrapper" do
     s = Sequel::SQL::Wrapper.new(o)
     @ds.literal(s).must_equal "foo"
     @ds.literal(s+1).must_equal "(foo + 1)"
+    @ds.literal(s**1).must_equal "power(foo, 1)"
     @ds.literal(s & true).must_equal "(foo AND 't')"
     @ds.literal(s < 1).must_equal "(foo < 1)"
     @ds.literal(s.sql_subscript(1)).must_equal "foo[1]"

data/spec/core_extensions_spec.rb

@@ -87,12 +87,17 @@ describe "Core extensions" do
     @d.l(~:x__y).must_equal 'NOT x.y'
   end
   
-  it "should support + - * / via Symbol#+,-,*,/" do
+  it "should support + - * / power via Symbol#+,-,*,/,**" do
     @d.l(:x + 1 > 100).must_equal '((x + 1) > 100)'
     @d.l((:x * :y) < 100.01).must_equal '((x * y) < 100.01)'
     @d.l((:x - :y/2) >= 100000000000000000000000000000000000).must_equal '((x - (y / 2)) >= 100000000000000000000000000000000000)'
     @d.l((((:x - :y)/(:x + :y))*:z) <= 100).must_equal '((((x - y) / (x + y)) * z) <= 100)'
     @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).must_equal '((((x - y) / (x + y)) * z) > 100)'
+    @d.l(~((((:x ** :y)/(:x + :y))*:z) <= 100)).must_equal '(((power(x, y) / (x + y)) * z) > 100)'
+  end
+
+  it "should support coercion for symbols" do
+    @d.l(1 + :x > 2).must_equal '((1 + x) > 2)'
   end
   
   it "should support LIKE via Symbol#like" do

data/spec/extensions/core_refinements_spec.rb

@@ -22,12 +22,13 @@ describe "Core refinements" do
     @d.l(~:x__y).must_equal 'NOT x.y'
   end
   
-  it "should support + - * / via Symbol#+,-,*,/" do
+  it "should support + - * / power via Symbol#+,-,*,/,**" do
     @d.l(:x + 1 > 100).must_equal '((x + 1) > 100)'
     @d.l((:x * :y) < 100.01).must_equal '((x * y) < 100.01)'
     @d.l((:x - :y/2) >= 100000000000000000000000000000000000).must_equal '((x - (y / 2)) >= 100000000000000000000000000000000000)'
     @d.l((((:x - :y)/(:x + :y))*:z) <= 100).must_equal '((((x - y) / (x + y)) * z) <= 100)'
     @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).must_equal '((((x - y) / (x + y)) * z) > 100)'
+    @d.l(~((((:x ** :y)/(:x + :y))*:z) <= 100)).must_equal '(((power(x, y) / (x + y)) * z) > 100)'
   end
   
   it "should support LIKE via Symbol#like" do

data/spec/integration/dataset_test.rb

@@ -1297,6 +1297,14 @@ describe "Sequel::Dataset DSL support" do
     @ds.get{a * b}.to_i.must_equal 200
     @ds.get{a / b}.to_i.must_equal 2
   end
+
+  it "should work with exponentiation operator" do
+    @ds.insert(:a=>2)
+    (-4..4).each do |i|
+      # Allow minor differences due to emulation issues on some adapters
+      @ds.get{(a / 1.0) ** i}.to_f.must_be_close_to((2**i).to_f)
+    end
+  end
   
   cspecify "should work with bitwise shift operators", :derby do
     @ds.insert(3, 2)

data/spec/model/hooks_spec.rb

@@ -601,4 +601,44 @@ describe "Model#after_commit and #after_rollback" do
     o.save
     @db.sqls.must_equal ['BEGIN', 'as', 'COMMIT']
   end
+
+  it "should handle use_after_commit_rollback when subclassing after loading" do
+    @m = Class.new(Sequel::Model(@db[:items]))
+    @m.use_transactions = true
+    o = @m.load({})
+    @db.sqls
+    o.save
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+
+    c = Class.new(@m)
+    o = c.load({})
+    def o.after_commit; db.execute 'ac' end
+    @db.sqls
+    o.save
+    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'ac']
+
+    o = c.load({})
+    @db.sqls
+    o.save
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+
+    c.send(:define_method, :after_commit){db.execute 'ac'}
+    o = c.load({})
+    @db.sqls
+    o.save
+    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'ac']
+
+    c = Class.new(@m)
+    c.send(:include, Module.new{def after_commit; db.execute 'ac'; end})
+    o = c.load({})
+    @db.sqls
+    o.save
+    @db.sqls.must_equal ['BEGIN', 'COMMIT', 'ac']
+
+    c.use_after_commit_rollback = false
+    o = c.load({})
+    @db.sqls
+    o.save
+    @db.sqls.must_equal ['BEGIN', 'COMMIT']
+  end
 end

data/spec/model/record_spec.rb

@@ -1304,8 +1304,9 @@ describe Sequel::Model, "#(set|update)_(all|only)" do
   end
 
   it "#set_all should set not set restricted fields" do
-    @o1.set_all(:x => 1, :use_after_commit_rollback => false)
-    @o1.use_after_commit_rollback.must_equal true
+    @o1.use_after_commit_rollback.must_equal nil
+    @o1.set_all(:x => 1, :use_after_commit_rollback => true)
+    @o1.use_after_commit_rollback.must_equal nil
     @o1.values.must_equal(:x => 1)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.37.0
+  version: 4.38.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-01 00:00:00.000000000 Z
+date: 2016-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -238,6 +238,7 @@ extra_rdoc_files:
 - doc/release_notes/4.35.0.txt
 - doc/release_notes/4.36.0.txt
 - doc/release_notes/4.37.0.txt
+- doc/release_notes/4.38.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -364,6 +365,7 @@ files:
 - doc/release_notes/4.35.0.txt
 - doc/release_notes/4.36.0.txt
 - doc/release_notes/4.37.0.txt
+- doc/release_notes/4.38.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt
 - doc/release_notes/4.6.0.txt