sequel 4.38.0 → 4.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbbe9aec719ae1c6ace4c686bf0e02f352b1283a
-  data.tar.gz: 347e71c258109c785c11b55e354fd4f616060cdc
+  metadata.gz: faeae955d80275ae969500515f7a62f6db3ee1d2
+  data.tar.gz: 69e8bed296f9a6044bdbecfb29317562f2890bb8
 SHA512:
-  metadata.gz: 3e8ef32de9f9efb9ae6b03598ca6a2809409b51a60fe2759fcd2c1556d8376c08fe31366db86f7016ea25745b16f6323428838f6ebd72c96ef4a7036514cf8ce
-  data.tar.gz: 986105b21db0f6ffa3455e4cb8972a0b4af165026455d888bdec4054d3b31c71b8118e036c8f201934e99070ce11b3b88b32908a4d405225a11d97383fa0fd3b
+  metadata.gz: 6f87b9f699854635a13c664b49e0a9be073a6f1daf1dc00ccfa7c352d211939d514a39b5a057f4fd90a5f8ed7737ea8afc2f54afcbd68d0b8ca07babeed88e22
+  data.tar.gz: 9ff3136d2113273d89d4dd1552aa5ba30bea4e39edbfc4535f2762d35e6c21badfd5131e1f726be4d534b9f2f5960e498f9d7e3944e858716b7180c2a23c06ba

data/CHANGELOG

@@ -1,3 +1,31 @@
+=== 4.39.0 (2016-10-01)
+
+* Make active_model plugin use rollback_checker instead of after_rollback hook (jeremyevans)
+
+* Add Database#rollback_checker, which returns a proc that returns whether the in progress transaction is rolled back (jeremyevans)
+
+* Add Sequel::Database.set_shared_adapter_scheme to allow external adapters to support the mock adapter (jeremyevans)
+
+* Make hook_class_methods plugin not use after commit/rollback model hooks (jeremyevans)
+
+* Support add_column :after and :first options on MySQL (AnthonyBobsin, jeremyevans) (#1234)
+
+* Support ActiveSupport 5 in pg_interval extension when weeks/hours are used in ActiveSupport::Duration objects (chanks) (#1233)
+
+* Support IntegerMigrator :relative option, for running only the specified number of migrations up or down (jeremyevans)
+
+* Make the touch plugin also touch associations on create in addition to update and delete (jeremyevans)
+
+* Add :allow_manual_update timestamps plugin option for not overriding a manually set update timestamp (jeremyevans)
+
+* Add Sequel.[] as an alias to Sequel.expr, for easier expression creation (jeremyevans)
+
+* Add PostgreSQL full_text_search :to_tsquery=>:phrase option, for using PostgreSQL 9.6+ full text search phrase searching (jeremyevans)
+
+* Add JSONBOp#insert in pg_json_ops extension, for jsonb_insert support on PostgreSQL 9.6+ (jeremyevans)
+
+* Support add_column :if_not_exists option on PostgreSQL 9.6+ (jeremyevans)
+
 === 4.38.0 (2016-09-01)
 
 * Support :driver_options option when using the postgres adapter with pg driver (jeremyevans)

data/doc/association_basics.rdoc

@@ -993,7 +993,7 @@ columns that have the same name in both the join table and the associated
 table.  Example:
 
   Artist.one_to_many :albums, :select=>[:id, :name]
-  Album.many_to_many :tags, :select=>[Sequel.expr(:tags).*, :albums_tags__number]
+  Album.many_to_many :tags, :select=>[Sequel[:tags].*, :albums_tags__number]
 
 ==== :limit
 

data/doc/core_extensions.rdoc

@@ -160,9 +160,9 @@ The * operator is overloaded on Symbol such that if it is called with no argumen
 
   :a.* # SQL: a.*
 
-Alternative: Sequel.expr.*:
+Alternative: Sequel.[].*:
 
-  Sequel.expr(:a).*
+  Sequel[:a].*
 
 ==== qualify
 
@@ -226,11 +226,11 @@ These Symbol methods are used to force the treating of the object as a specific
   :a.sql_number << 1  # SQL: a << 1
   :a.sql_string + 'a' # SQL: a || 'a'
 
-Alternative: Sequel.expr:
+Alternative: Sequel.[]:
 
-  Sequel.expr(:a).sql_boolean
-  Sequel.expr(:a).sql_number
-  Sequel.expr(:a).sql_string
+  Sequel[:a].sql_boolean
+  Sequel[:a].sql_number
+  Sequel[:a].sql_string
 
 ==== sql_function
 
@@ -300,9 +300,9 @@ Array#sql_expr and Hash#sql_expr treat the receiver as a conditions specifier, m
   {:a=>1, :b=>[2, 3]}.sql_expr     # SQL: a = 1 AND b IN (2, 3)
   [[:a, 1], [:b, [2, 3]]].sql_expr # SQL: a = 1 AND b IN (2, 3)
 
-Alternative: Sequel.expr:
+Alternative: Sequel.[]:
 
-  Sequel.expr(:a=>1, :b=>[2, 3])
+  Sequel[:a=>1, :b=>[2, 3]]
 
 ==== sql_negate
 

data/doc/object_model.rdoc

@@ -160,7 +160,7 @@ Sequel generally uses hash objects to represent equality:
 
   {:column => 1} # ("column" = 1)
 
-However, if you use in array as the hash value, it will usually be used to represent inclusion:
+However, if you use an array as the hash value, it will usually be used to represent inclusion:
 
   {:column => [1, 2, 3]} # ("column" IN (1, 2, 3))
 
@@ -270,7 +270,7 @@ automatic qualification or aliasing happens for them:
 
 The following shortcuts exist for creating Sequel::SQL::Identifier objects:
 
-  Sequel.expr(:column)
+  Sequel[:column]
   Sequel.identifier(:col__umn)
   :col__umn.identifier # core_extensions extension
 
@@ -282,7 +282,7 @@ Sequel::SQL::QualifiedIdentifier objects represent qualified identifiers:
 
 The following shortcuts exist for creating Sequel::SQL::QualifiedIdentifier objects:
 
-  Sequel.expr(:table__column)
+  Sequel[:table__column]
   Sequel.qualify(:table, :column)
   :column.qualify(:table) # core_extensions extension
 
@@ -299,7 +299,7 @@ is treated as an identifier, but the expression can be an arbitrary Sequel expre
 
 The following shortcuts exist for creating Sequel::SQL::AliasedExpression objects:
 
-  Sequel.expr(:column___alias)
+  Sequel[:column___alias]
   Sequel.as(:column, :alias)
   Sequel.as(:column, :alias, [:column_alias1, :column_alias2])
   :column.as(:alias) # core_extensions extension
@@ -384,7 +384,7 @@ take arguments.  Still, it's possible they are still useful in some code:
 
 The following shortcut exists for creating Sequel::SQL::ColumnAll objects:
 
-  Sequel.expr(:table).*
+  Sequel[:table].*
   :table.* # core_extensions extension
 
 === Sequel::SQL::Constant
@@ -563,11 +563,10 @@ on the wrapper that would not be defined on the object itself:
 
   Sequel::SQL::Wrapper.new(o) + 1 # (foo + 1)
 
-You can use the Sequel.expr method to wrap any object:
+You can use the Sequel.[] method to wrap any object:
 
-  Sequel.expr(o)
+  Sequel[o]
 
 However, note that that does not necessarily return a Sequel::SQL::Wrapper
 object, it may return a different class of object, such as a
 Sequel::SQL::ComplexExpression subclass object.
-  

data/doc/querying.rdoc

@@ -416,11 +416,11 @@ which is used directly in the filter.
 
 You can use the DSL to create arbitrarily complex expressions.  SQL::Expression
 objects can be created via singleton methods on the Sequel module.  The most common
-method is Sequel.expr, which takes any object and wraps it in a SQL::Expression
+method is Sequel.[], which takes any object and wraps it in a SQL::Expression
 object.  In most cases, the SQL::Expression returned supports the & operator for
 +AND+, the | operator for +OR+, and the ~ operator for inversion:
 
-  Artist.where(Sequel.like(:name, 'Y%') & (Sequel.expr(:b=>1) | Sequel.~(:c=>3)))
+  Artist.where(Sequel.like(:name, 'Y%') & (Sequel[:b=>1] | Sequel.~(:c=>3)))
   # SELECT * FROM artists WHERE name LIKE 'Y%' ESCAPE '\' AND (b = 1 OR c != 3)
 
 You can combine these expression operators with the virtual row support:

data/doc/release_notes/4.39.0.txt

@@ -0,0 +1,127 @@
+= New Features
+
+* Sequel.[] has been added as an alias to Sequel.expr. This makes it
+  a little easier to get Sequel-specific objects:
+
+    Sequel[:table].*                  # "table".*
+    Sequel[:table__column].as(:alias) # "table"."column" AS "alias"
+    Sequel[:column] + 1               # ("column" + 1)
+
+* The timestamps plugin now supports an :allow_manual_update option.
+  If this option is used, the timestamps plugin will not override the 
+  update timestamp when saving if the user has modified it since
+  retrieving the object.
+
+* The touch plugin now also touches associations on create in addition
+  to update and delete.
+
+* The IntegerMigrator now supports a :relative option, which will
+  migrate that many migrations up (for positive numbers) or down (for
+  negative numbers).
+
+* Database#rollback_checker has been added, which returns a callable
+  that can be called later to determine whether the transaction ended
+  up committing or rolling back.  So if you may need to check
+  transaction status at some future point, and don't need immediate
+  action on rollback/commit, it is better to use a rollback checker
+  than to add an after commit/rollback hook.
+
+    rbc = nil
+    DB.transaction do
+      rbc = DB.rollback_checker
+      rbc.call #=> nil
+    end
+    rbc.call # => false
+
+    DB.transaction(:rollback=>:always) do
+      rbc = DB.rollback_checker
+    end
+    rbc.call # => true
+
+* The add_column schema method now supports an :if_not_exists option
+  on PostgreSQL 9.6+, which will only add the column if it does not
+  already exist:
+
+    DB.add_column :t, :c, Integer, :if_not_exists=>true
+    # ALTER TABLE "t" ADD COLUMN IF NOT EXISTS "c" integer
+
+* The add_column schema method now supports an :after and :first
+  option on MySQL to add the column after an existing column or as
+  the first column:
+
+    DB.add_column :t, :c, Integer, :first=>true
+    # ALTER TABLE `t` ADD COLUMN `c` integer FIRST
+    DB.add_column :t, :c1, Integer, :after=>:c2
+    # ALTER TABLE `t` ADD COLUMN `c1` integer AFTER `c2`
+
+* JSONBOp#insert has been added to the pg_json_ops extension, which
+  supports the new jsonb_insert function added in PostgreSQL 9.6+:
+
+    Sequel.pg_jsonb_op(:c).insert(%w'0 a', 'a'=>1)
+    # jsonb_insert("c", ARRAY['0','a'], '{"a":1}'::jsonb, false)
+
+* Dataset#full_text_search on PostgreSQL now supports a
+  :to_tsquery=>:phrase option, to enable the native phrase searching
+  added in PostgreSQL 9.6+:
+
+    DB[:t].full_text_search(:c, 'foo bar', :to_tsquery=>:phrase)
+    # SELECT * FROM "t"
+    # WHERE
+    #   (to_tsvector(CAST('simple' AS regconfig), (COALESCE("c", '')))
+    #   @@ phraseto_tsquery(CAST('simple' AS regconfig), 'foo bar'))
+
+* Sequel::Database.set_shared_adapter_scheme has been added, allowing
+  external adapters to add support for Sequel's mock adapter.
+  External adapters should have a shared adapter requirable at
+  sequel/adapters/shared/adapter_name, that uses the following
+  format:
+
+    # in sequel/adapters/shared/mydb
+    module Sequel::MyDB
+      Sequel::Database.set_shared_adapter_scheme :mydb, self
+
+      def self.mock_adapter_setup(db)
+        # Any mock-adapter specific setup to perform on the
+        # given Database instance
+      end
+
+      module DatabaseMethods
+        # methods for all Database objects using this adapter
+      end
+
+      module DatasetMethods
+        # methods for all Dataset objects using this adapter
+      end
+    end
+
+
+= Other Improvements
+
+* The hook_class_methods plugin only adds a Database transaction
+  hook if one of the after commit/rollback hook class methods is
+  actually used.  This means that loading the plugin no longer
+  keeps all saved/deleted objects in memory until transaction
+  commit.
+
+* The active_model plugin now uses a rollback checker instead of
+  an after_rollback hook, so models that use the active_model plugin
+  no longer store all saved model instances in memory until
+  transaction commit.
+
+* When using the IntegerMigrator, attempting to migrate to a
+  migration number above the maximum will now migrate to the lastest
+  version, and attempting to migrate to a migration number below 0
+  will now migrate all the way down.
+
+* The pg_interval extension now supports ActiveSupport::Duration
+  objects that use week and hour parts (new in ActiveSupport 5).
+
+= Backwards Compatibility
+
+* The change to the touch plugin to touch associations on create could
+  possibly affect existing behavior, so if you are using this plugin,
+  you should test that this does not cause any problems.
+
+* External adapters that tried to add support for the mock adapter
+  now need to update their code to use the new
+  Sequel::Database.set_shared_adapter_scheme method.

data/doc/sql.rdoc

@@ -352,9 +352,9 @@ Sequel defines the inequality operators directly on most Sequel-specific express
   Sequel.function(:func) >= 1 # (func() >= 1)
   Sequel.function(:func, :column) <= 1 # (func("column") <= 1)
 
-If you want to use them on a symbol, you should call <tt>Sequel.expr</tt> with the symbol:
+If you want to use them on a symbol, you should call <tt>Sequel.[]</tt> with the symbol:
 
-  Sequel.expr(:column) > 1 # ("column" > 1)
+  Sequel[:column] > 1 # ("column" > 1)
 
 A common use of virtual rows is to handle inequality operators:
 
@@ -364,11 +364,11 @@ A common use of virtual rows is to handle inequality operators:
 
 The standard mathematical operates are defined on most Sequel-specific expression objects:
 
-  Sequel.expr(:column) + 1 # "column" + 1
-  Sequel.expr(:table__column) - 1 # "table"."column" - 1
+  Sequel[:column] + 1 # "column" + 1
+  Sequel[: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)
+  Sequel[:column] / 1 # "column" / 1
+  Sequel[:column] ** 1 # power("column", 1)
 
 You can also call the operator methods directly on the Sequel module:
 
@@ -380,15 +380,15 @@ You can also call the operator methods directly on the Sequel module:
 
 Note that since Sequel implements support for ruby's coercion protocol, the following also works:
 
-  1 + Sequel.expr(:column)
+  1 + Sequel[:column]
   1 - Sequel.qualify(:table__column)
 
 === Boolean Operators (AND OR)
 
 Sequel defines the & and | methods on most Sequel-specific expression objects to handle AND and OR:
 
-  Sequel.expr(:column1) & :column2 # ("column1" AND "column2")
-  Sequel.expr(:column1=>1) | {:column2=>2} # (("column1" = 1) OR ("column2" = 2))
+  Sequel[:column1] & :column2 # ("column1" AND "column2")
+  Sequel[:column1=>1] | {:column2=>2} # (("column1" = 1) OR ("column2" = 2))
   (Sequel.function(:func) > 1) & :column3 # ((func() > 1) AND "column3")
 
 Note the use of parentheses in the last statement.  If you omit them, you won't get what you expect.
@@ -430,8 +430,8 @@ Note again that <tt>Dataset#exclude</tt> uses ~, not +negate+:
 
 Casting in Sequel is done with the +cast+ method, which is available on most of the Sequel-specific expression objects:
 
-  Sequel.expr(:name).cast(:text) # CAST("name" AS text)
-  Sequel.expr('1').cast(:integer) # CAST('1' AS integer)
+  Sequel[:name].cast(:text) # CAST("name" AS text)
+  Sequel['1'].cast(:integer) # CAST('1' AS integer)
   Sequel.qualify(:table, :column).cast(:date) # CAST("table"."column" AS date)
 
 You can also use the <tt>Sequel.cast</tt> method:
@@ -442,41 +442,41 @@ You can also use the <tt>Sequel.cast</tt> method:
 
 Sequel allows the use of bitwise mathematical operators on Sequel::SQL::NumericExpression objects:
 
-  Sequel.expr(:number) + 1 # => #<Sequel::SQL::NumericExpression ...>
-  (Sequel.expr(:number) + 1) & 5 # (("number" + 1) & 5)
+  Sequel[:number] + 1 # => #<Sequel::SQL::NumericExpression ...>
+  (Sequel[:number] + 1) & 5 # (("number" + 1) & 5)
 
 As you can see, when you use the + operator on a symbol, you get a NumericExpression.  You can turn an expression a NumericExpression using +sql_number+:
 
-  Sequel.expr(:number).sql_number | 5 # ("number" | 5)
+  Sequel[:number].sql_number | 5 # ("number" | 5)
   Sequel.function(:func).sql_number << 7 # (func() << 7)
   Sequel.cast(:name, :integer).sql_number >> 8 # (CAST("name" AS integer) >> 8)
 
 Sequel allows you to do the cast and conversion at the same time via +cast_numeric+:
 
-  Sequel.expr(:name).cast_numeric ^ 9 # (CAST("name" AS integer) ^ 9)
+  Sequel[:name].cast_numeric ^ 9 # (CAST("name" AS integer) ^ 9)
 
 Note that &, |, and ~ are already defined to do AND, OR, and NOT on most expressions, so if you want to use the bitwise operators, you need to make sure that they are converted first:
 
-  ~Sequel.expr(:name) # NOT "name"
-  ~Sequel.expr(:name).sql_number # ~"name"
+  ~Sequel[:name] # NOT "name"
+  ~Sequel[:name].sql_number # ~"name"
 
 === String Operators (||, LIKE, Regexp)
 
 Sequel allows the use of the string concatenation operator on Sequel::SQL::StringExpression objects, which can be created using the +sql_string+ method on an expression:
 
-  Sequel.expr(:name).sql_string + ' - Name' # ("name" || ' - Name')
+  Sequel[:name].sql_string + ' - Name' # ("name" || ' - Name')
 
 Just like for the bitwise operators, Sequel allows you do do the cast and conversion at the same time via +cast_string+:
 
-  Sequel.expr(:number).cast_string + ' - Number' # (CAST(number AS varchar(255)) || ' - Number')
+  Sequel[:number].cast_string + ' - Number' # (CAST(number AS varchar(255)) || ' - Number')
 
 Note that similar to the mathematical operators, you cannot switch the order the expression and have it work:
 
-  'Name - ' + Sequel.expr(:name).sql_string # raises TypeError
+  'Name - ' + Sequel[:name].sql_string # raises TypeError
 
-Just like for the mathematical operators, you can use <tt>Sequel.expr</tt> to wrap the object:
+Just like for the mathematical operators, you can use <tt>Sequel.[]</tt> to wrap the object:
 
-  Sequel.expr('Name - ') + :name # ('Name - ' || "name")
+  Sequel['Name - '] + :name # ('Name - ' || "name")
   
 The <tt>Sequel.join</tt> method concatenates all of the elements in the array:
 
@@ -488,8 +488,8 @@ Just like ruby's <tt>String#join</tt>, you can provide an argument for a string
 
 For the LIKE operator, Sequel defines the +like+ and +ilike+ methods on most Sequel-specific expression objects:
 
-  Sequel.expr(:name).like('A%') # ("name" LIKE 'A%' ESCAPE '\') 
-  Sequel.expr(:name).ilike('A%') # ("name" ILIKE 'A%' ESCAPE '\') 
+  Sequel[:name].like('A%') # ("name" LIKE 'A%' ESCAPE '\') 
+  Sequel[:name].ilike('A%') # ("name" ILIKE 'A%' ESCAPE '\') 
 
 You can also use the <tt>Sequel.like</tt> and <tt>Sequel.ilike</tt> methods:
 
@@ -515,24 +515,24 @@ Note that using +ilike+ with a regular expression will always make the regexp ca
 
 Sequel supports specifying ascending or descending order using the +asc+ and +desc+ method on most Sequel-specific expression objects:
 
-  Sequel.expr(:column).asc # "column" ASC
-  Sequel.expr(:column).qualify(:table).desc # "table"."column" DESC
+  Sequel[:column].asc # "column" ASC
+  Sequel[:column].qualify(:table).desc # "table"."column" DESC
 
 You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
 
   Sequel.asc(:column) # "column" ASC
-  Sequel.desc(Sequel.expr(:column).qualify(:table)) # "table"."column" DESC
+  Sequel.desc(Sequel[:column].qualify(:table)) # "table"."column" DESC
 
 On some databases, you can specify null ordering:
 
   Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
-  Sequel.desc(Sequel.expr(:column).qualify(:table), :nulls=>:last) # "table"."column" DESC NULLS LAST
+  Sequel.desc(Sequel[:column].qualify(:table), :nulls=>:last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
 To select all columns in a table, Sequel supports the * method on identifiers without an argument:
 
-  Sequel.expr(:table).* # "table".*
+  Sequel[:table].* # "table".*
 
 === CASE statements
 
@@ -555,8 +555,8 @@ If you provide a 3rd argument to <tt>Sequel.case</tt>, it goes between CASE and
 
 Sequel supports SQL subscripts using the +sql_subscript+ method on most Sequel-specific expression objects:
 
-  Sequel.expr(:column).sql_subscript(3) # column[3]
-  Sequel.expr(:column).qualify(:table).sql_subscript(3) # table.column[3]
+  Sequel[:column].sql_subscript(3) # column[3]
+  Sequel[:column].qualify(:table).sql_subscript(3) # table.column[3]
 
 You can also use the <tt>Sequel.subscript</tt> method: