sequel 4.20.0 → 4.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6daa0c1ef4f76e1d9bfdeedbf9208bf32646ab20
-  data.tar.gz: f2cf0e139a84f465fe1146de98b767fad029fca9
+  metadata.gz: bd1a779cad72f3c5831e46f1cb9ee5c5fa0cb75a
+  data.tar.gz: 561c34f1d23f0eb77d59e483b2beab3ebed21172
 SHA512:
-  metadata.gz: 28f1f4b25bd2c5db83ce6630ebd9310524dafb59a60ce9e72e3c8e6d12f0a9ea9eff9e1e2ec492fa3f7f655b76ee51b6f5a8e233a36b80370d51922d3024f504
-  data.tar.gz: 7309df3435d53878e8aa1945fc728fedad302727d503af24c399285fbf511b70571ca7cbef4f9c1b5c615aac689d9971f8072b0c9e2fb77f89491410384be665
+  metadata.gz: c3a11392dd6ab72a6af845fe59b85a1bbde7827d27aa255b434129b76034ad1be980a5e45a37a0ea82b0849c1ab4cd2013c108c22f13e898c3d9c6da345d32f6
+  data.tar.gz: 327de977bc6020cd9413bc50d0df32a8432784ee99e9fa277dd74a89f7b6f3e3ef7a89159534bafeeb5b42c99d38f3881d5aee67e5bcb832354f94e8ed7391ef

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 4.21.0 (2015-04-01)
+
+* Support :tsquery and :tsvector options in Dataset#full_text_search on PostgreSQL, for using existing tsquery/tsvector expressions (jeremyevans)
+
+* Fix TinyTds::Error being raised when trying to cancel a query on a closed connection in the tinytds adapter (jeremyevans)
+
+* Add GenericExpression#!~ for inverting =~ on ruby 1.9 (similar to inverting a hash) (jeremyevans) (#979)
+
+* Add GenericExpression#=~ for equality, inclusion, and pattern matching (similar to using a hash) (jeremyevans) (#979)
+
+* Add Database#add_named_conversion_proc on PostgreSQL to make it easier to add conversion procs for types by name (jeremyevans)
+
+* Make Sequel.pg_jsonb return JSONBOp instances instead of JSONOp instances when passed other than Array or Hash (jeremyevans) (#977)
+
+* Demodulize default root name in json_serializer plugin (janko-m) (#968)
+
+* Make Database#transaction work in after_commit/after_rollback blocks (jeremyevans)
+
 === 4.20.0 (2015-03-03)
 
 * Restore the use of AUTOINCREMENT on SQLite (jeremyevans) (#965)

data/README.rdoc

@@ -223,6 +223,8 @@ Sequel also accepts expressions:
   
   my_posts = posts.where{stamp > Date.today << 1}
   # WHERE stamp > '2010-06-14'
+  my_posts = posts.where{stamp =~ Date.today}
+  # WHERE stamp = '2010-07-14'
   
 Some adapters will also let you specify Regexps:
 

data/Rakefile

@@ -84,17 +84,18 @@ end
 
 begin
   begin
-    # RSpec 1
-    require "spec/rake/spectask"
-    spec_class = Spec::Rake::SpecTask
-    spec_files_meth = :spec_files=
-    spec_opts_meth = :spec_opts=
-  rescue LoadError
+    raise LoadError if ENV['RSPEC1']
     # RSpec 2
     require "rspec/core/rake_task"
     spec_class = RSpec::Core::RakeTask
     spec_files_meth = :pattern=
     spec_opts_meth = :rspec_opts=
+  rescue LoadError
+    # RSpec 1
+    require "spec/rake/spectask"
+    spec_class = Spec::Rake::SpecTask
+    spec_files_meth = :spec_files=
+    spec_opts_meth = :spec_opts=
   end
 
   spec = lambda do |name, files, d|

data/doc/dataset_filtering.rdoc

@@ -105,17 +105,22 @@ To filter by equality, you use the standard hash, which can be combined with oth
   items.where{Sequel.&({:category => 'ruby'}, (price + 100 < 200))}.sql
   #=> "SELECT * FROM items WHERE ((category = 'ruby') AND ((price + 100) < 200))"
 
+You can also use the =~ operator:
+
+  items.where{(category =~ 'ruby') & (price + 100 < 200)}.sql
+  #=> "SELECT * FROM items WHERE ((category = 'ruby') AND ((price + 100) < 200))"
+
 This works with other hash values, such as arrays and ranges:
 
-  items.where{Sequel.|({:category => ['ruby', 'other']}, (:price - 100 > 200))}.sql
+  items.where{Sequel.|({:category => ['ruby', 'other']}, (price - 100 > 200))}.sql
   #=> "SELECT * FROM items WHERE ((category IN ('ruby', 'other')) OR ((price - 100) <= 200))"
 
-  items.where{Sequel.&({:price => (100..200)}, :active)}.sql
+  items.where{(price =~ (100..200)) & :active}.sql
   #=> "SELECT * FROM items WHERE ((price >= 100 AND price <= 200) AND active)"
 
 === Negating conditions
 
-You can use the exclude method to exclude conditions:
+You can use the exclude method to exclude whole conditions:
 
   items.exclude(:category => 'ruby').sql
   #=> "SELECT * FROM items WHERE (category != 'ruby')"
@@ -126,6 +131,19 @@ You can use the exclude method to exclude conditions:
   items.exclude{price / 100 >= 200}.sql
   #=> "SELECT * FROM items WHERE ((price / 100) < 200)
 
+To exclude only parts of conditions, you can use when in combination with Sequel.~ or the ~ method on Sequel expressions:
+
+  items.where{Sequel.&(Sequel.~(:category => 'ruby'), (price + 100 < 200))}.sql
+  #=> "SELECT * FROM items WHERE ((category != 'ruby') AND ((price + 100) < 200))"
+
+  items.where{~(category =~ 'ruby') & (price + 100 < 200)}.sql
+  #=> "SELECT * FROM items WHERE ((category != 'ruby') AND ((price + 100) < 200))"
+
+On Ruby 1.9+, you can also use the !~ method:
+
+  items.where{(category !~ 'ruby') & (price + 100 < 200)}.sql
+  #=> "SELECT * FROM items WHERE ((category != 'ruby') AND ((price + 100) < 200))"
+
 === Comparing against column references
 
 You can also compare against other columns:

data/doc/querying.rdoc

@@ -388,6 +388,12 @@ will be ANDed together:
   Artist.where(:name=>'A'...'M'){id > 5}
   # SELECT * FROM artists WHERE name >= 'A' AND name < 'M' AND id > 5
 
+Using virtual row blocks, what you can do with single entry hash or an array with
+a single two element array can also be done using the =~ method:
+
+  Artist.where{id =~ 5}
+  # SELECT * FROM artists WHERE id = 5
+
 === Symbols
 
 If you have a boolean column in the database, and you want only true
@@ -494,7 +500,22 @@ Or to use the NOT LIKE operator:
 
   Artist.exclude(Sequel.like(:name, '%J%'))
   # SELECT * FROM artists WHERE name NOT LIKE '%J%' ESCAPE '\'
+
+You can use Sequel.~ to negate expressions:
+
+  Artist.where(Sequel.~(:id=>5))
+  # SELECT * FROM artists WHERE id != 5
+
+On Sequel expression objects, you can use ~ to negate them:
  
+  Artist.where(~Sequel.like(:name, '%J%'))
+  # SELECT * FROM artists WHERE name NOT LIKE '%J%' ESCAPE '\'
+
+On Ruby 1.9+, you can use !~ on Sequel expressions to create negated expressions:
+
+  Artist.where{ id !~ 5}
+  # SELECT * FROM artists WHERE id != 5
+
 === Removing
 
 To remove all existing filters, use +unfiltered+:

data/doc/release_notes/4.21.0.txt

@@ -0,0 +1,94 @@
+= New Features
+
+* SQL::GenericExpression#=~ has been added as an alternative method
+  of specifying equality/inclusion/identity.  Previously, you had to
+  use a hash.  This led to some slightly weird looking syntax when
+  used inside virtual rows:
+
+    DB[:items].where{{function(:column)=>0}}
+    # SELECT FROM items WHERE function(column) = 0
+
+  You can now use =~ as an equivalent:
+
+    DB[:items].where{function(:column) =~ 0}
+    # SELECT FROM items WHERE function(column) = 0
+
+  Like when using a hash, this works also for inclusion:
+
+    DB[:items].where{function(:column) =~ [1,2,3]}
+    # SELECT FROM items WHERE function(column) IN (1, 2, 3)
+
+  for identity:
+
+    DB[:items].where{function(:column) =~ nil}
+    # SELECT FROM items WHERE function(column) IS NULL
+
+  and for matching (on MySQL/PostgreSQL):
+
+    DB[:items].where{function(:column) =~ /foo/i}
+    # SELECT FROM items WHERE function(column) ~* 'foo'
+
+  This new syntax makes more complex conditions simpler to express:
+
+    DB[:items].where{(function(:column) =~ 0) | (column =~ 1)}
+    # SELECT FROM items WHERE function(column) = 0 OR column = 1
+
+  compared to previous versions of Sequel:
+
+    DB[:items].where{Sequel.|({function(:column) => 0}, {:column => 1})}
+
+  On ruby 1.9+, you can also use SQL::GenericExpression#!~ to invert
+  the condition:
+    
+    DB[:items].where{function(:column) !~ 0}
+    # SELECT FROM items WHERE function(column) != 0
+
+    DB[:items].where{function(:column) !~ [1,2,3]}
+    # SELECT FROM items WHERE function(column) NOT IN (1, 2, 3)
+
+    DB[:items].where{function(:column) !~ nil}
+    # SELECT FROM items WHERE function(column) IS NOT NULL
+
+    DB[:items].where{function(:column) !~ /foo/i}
+    # SELECT FROM items WHERE function(column) !~* 'foo'
+
+  This makes it simpler to write inverted conditions.  Ruby 1.8
+  doesn't support overriding the !~ method, but you can still use the
+  unary ~ method to invert:
+
+    DB[:items].where{~(function(:column) =~ 0)}
+
+* Database#add_named_conversion_proc has been added on PostgreSQL to
+  make it easier to add conversion procs by name instead of by OID:
+
+    DB.add_named_conversion_proc(:citext){|s| s}
+
+* Database#full_text_search on PostgreSQL now supports :tsquery and
+  :tsvector options for using existing tsquery and/or tsvector
+  arguments, instead of assuming the arguments are query terms or
+  the text to be search.
+
+= Other Improvements
+
+* Database#transaction now works inside after_commit and
+  after_rollback hooks.  Previously, it didn't work correctly as it
+  thought it was already inside the previously committed/rolled back
+  transaction.
+
+* Sequel.pg_jsonb now returns JSONBOp instances instead of JSONOp
+  instances when passed other than Array or Hash.
+
+* The tinytds adapter no longer tries to cancel a query on a closed
+  connection, which was causing an exception to be raised.
+
+= Backwards Compatibility
+
+* The default root name used in the JSON serializer is now demodulized
+  before being underscored.  This changes the behavior when the model
+  is namespaced.  For example, if the model class name is Mod::Model,
+  the previous default root name would be "mod/model", the new default
+  root name is "model".
+
+* If you were calling =~ or !~ on SQL::GenericExpression objects and
+  expecting the default ruby behavior of returning nil for =~ and
+  true for !~, you'll have to update your code.

data/doc/sql.rdoc

@@ -247,6 +247,10 @@ You can also specify this as an array of two element arrays:
 
   [[:column, 1]] # ("column" = 1)
 
+For expression objects, you can also use the =~ method:
+
+  where{column =~ 1} # ("column" = 1)
+
 === Not Equal Operator (!=)
 
 You can specify a not equals condition by inverting the hash or array of two element arrays using <tt>Sequel.negate</tt> or <tt>Sequel.~</tt>:
@@ -256,11 +260,19 @@ You can specify a not equals condition by inverting the hash or array of two ele
   Sequel.~(:column => 1)        # ("column" != 1)
   Sequel.~([[:column, 1]])      # ("column" != 1)
 
-The difference between the two is that negate only works on hashes and arrays of element arrays, and it negates all entries in the, while ~ does a general inversion.  This is best shown by an example with multiple entries:
+The difference between the two is that negate only works on hashes and arrays of element arrays, and it negates all entries in the hash or array, while ~ does a general inversion.  This is best shown by an example with multiple entries:
 
   Sequel.negate(:column => 1, :foo => 2)   # (("column" != 1) AND (foo != 2))
   Sequel.~(:column => 1, :foo => 2)        # (("column" != 1) OR (foo != 2))
 
+You can also use the ~ method on an equality expression:
+
+  where{~(column =~ 1)} # ("column" != 1)
+
+On Ruby 1.9+, you can use the !~ method:
+
+  where{column !~ 1} # ("column" != 1)
+
 The most common need for not equals is in filters, in which case you can use the +exclude+ method:
 
   DB[:albums].exclude(:column=>1) # SELECT * FROM "albums" WHERE ("column" != 1)
@@ -279,6 +291,14 @@ As you may have guessed, Sequel switches from an = to an IN when the hash value
   {:column=>DB[:albums].select(:id)} # ("column" IN (SELECT "id" FROM "albums"))
   Sequel.~(:column=>DB[:albums].select(:id)) # ("column" NOT IN (SELECT "id" FROM "albums"))
 
+Similar to =, you can also use =~ with expressions for inclusion:
+
+  where{column =~ [1, 2, 3]} # ("column" IN (1, 2, 3))
+
+and on Ruby 1.9, !~ for exclusion:
+
+  where{column !~ [1, 2, 3]} # ("column" NOT IN (1, 2, 3))
+
 Sequel also supports the SQL EXISTS operator using <tt>Dataset#exists</tt>:
 
   DB[:albums].exists # EXISTS (SELECT * FROM albums)
@@ -297,6 +317,11 @@ Negation works the same way as it does for equality and inclusion:
   Sequel.~(:column=>true) # ("column" IS NOT TRUE)
   Sequel.~(:column=>false) # ("column" IS NOT FALSE)
 
+Likewise, =~ works for identity (and Ruby 1.9, !~ for negative identity):
+
+  where{column =~ nil} # ("column" IS NULL)
+  where{column !~ nil} # ("column" IS NOT NULL)
+
 === Inversion Operator (NOT)
 
 Sequel's general inversion operator is ~, which works on symbols and most Sequel-specific expression objects:

data/doc/testing.rdoc

@@ -166,6 +166,7 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 === Other
 
+RSPEC1 :: Use RSpec 1 to run the tests even if a newer version is installed
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs

data/doc/validations.rdoc

@@ -226,6 +226,7 @@ These methods check that the specified attributes can be valid integers or valid
 
   class Album < Sequel::Model
     def validate
+      super
       validates_includes [1, 2, 3, 4, 5], :rating
     end
   end

data/doc/virtual_rows.rdoc

@@ -185,9 +185,21 @@ object returned, with the options for the window:
 
 == Operators
 
-VirtualRows use method_missing to handle almost all method calls.  However, they
-have special handling of some operator methods to make certain things easier. The
-operators all use a prefix form.
+VirtualRows use method_missing to handle almost all method calls.  Since the
+objects given by method_missing are SQL::Identifiers, SQL::QualifiedIdentifiers
+or SQL::Functions, you can use all operators that they provide (see
+DatasetFiltering[http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html#label-Filtering+using+expressions]):
+
+  ds.select{|o| o.price - 100}
+  ds.select{o.price - 100}
+  # SELECT (price - 100)
+
+  ds.where{|o| (o.price < 200) & (o.tax * 100 >= 23)}
+  ds.where{(price < 200) & (tax * 100 >= 0.23)}
+  # WHERE ((price < 200) AND ((tax * 100) >= 0.23))
+
+However, VirtualRows have special handling of some operator methods to make
+certain things easier.  The operators all use a prefix form.
 
 === Math Operators
 

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

@@ -154,6 +154,15 @@ module Sequel
       # having callable values for the conversion proc for that type.
       attr_reader :conversion_procs
 
+      # Add a conversion proc for a named type.  This should be used 
+      # for types without fixed OIDs, which includes all types that
+      # are not included in a default PostgreSQL installation.  If 
+      # a block is given, it is used as the conversion proc, otherwise
+      # the conversion proc is looked up in the PG_NAMED_TYPES hash.
+      def add_named_conversion_proc(name, &block)
+        add_named_conversion_procs(conversion_procs, name=>(block || PG_NAMED_TYPES[name]))
+      end
+
       # Commit an existing prepared transaction with the given transaction
       # identifier string.
       def commit_prepared_transaction(transaction_id, opts=OPTS)
@@ -1284,22 +1293,33 @@ module Sequel
       # :phrase :: Similar to :plain, but also adding an ILIKE filter to ensure that
       #            returned rows also include the exact phrase used.
       # :rank :: Set to true to order by the rank, so that closer matches are returned first.
+      # :tsquery :: Specifies the terms argument is already a valid SQL expression returning a
+      #            tsquery, and can be used directly in the query.
+      # :tsvector :: Specifies the cols argument is already a valid SQL expression returning a
+      #            tsvector, and can be used directly in the query.
       def full_text_search(cols, terms, opts = OPTS)
         lang = Sequel.cast(opts[:language] || 'simple', :regconfig)
-        terms = terms.join(' | ') if terms.is_a?(Array)
-        columns = full_text_string_join(cols)
-        query_func = (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
-        vector = Sequel.function(:to_tsvector, lang, columns)
-        query = Sequel.function(query_func, lang, terms)
 
-        ds = where(Sequel.lit(["(", " @@ ", ")"], vector, query))
+        unless opts[:tsvector]
+          phrase_cols = full_text_string_join(cols)
+          cols = Sequel.function(:to_tsvector, lang, phrase_cols)
+        end
+
+        unless opts[:tsquery]
+          phrase_terms = terms.is_a?(Array) ? terms.join(' | ') : terms
+          query_func = (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
+          terms = Sequel.function(query_func, lang, phrase_terms)
+        end
+
+        ds = where(Sequel.lit(["(", " @@ ", ")"], cols, terms))
 
         if opts[:phrase]
-          ds = ds.grep(cols, "%#{escape_like(terms)}%", :case_insensitive=>true)
+          raise Error, "can't use :phrase with either :tsvector or :tsquery arguments to full_text_search together" if opts[:tsvector] || opts[:tsquery]
+          ds = ds.grep(phrase_cols, "%#{escape_like(phrase_terms)}%", :case_insensitive=>true)
         end
 
         if opts[:rank]
-          ds = ds.order{ts_rank_cd(vector, query)}
+          ds = ds.order{ts_rank_cd(cols, terms)}
         end
 
         ds

data/lib/sequel/adapters/tinytds.rb

@@ -64,7 +64,7 @@ module Sequel
           rescue TinyTds::Error => e
             raise_error(e, :disconnect=>!c.active?)
           ensure
-           r.cancel if r && c.sqlsent?
+            r.cancel if r && c.sqlsent? && c.active?
           end
         end
       end

data/lib/sequel/database/misc.rb

@@ -199,7 +199,7 @@ module Sequel
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
           pr.call(self)
         else
-          raise(Error, "Extension #{ext} does not have specific support handling individual databases")
+          raise(Error, "Extension #{ext} does not have specific support handling individual databases (try: Sequel.extension #{ext.inspect})")
         end
       end
       self

data/lib/sequel/database/transactions.rb

@@ -187,20 +187,6 @@ module Sequel
       end
     end    
 
-    # Call all stored after_commit blocks for the given transaction
-    def after_transaction_commit(conn)
-      if ary = _trans(conn)[:after_commit]
-        ary.each{|b| b.call}
-      end
-    end
-
-    # Call all stored after_rollback blocks for the given transaction
-    def after_transaction_rollback(conn)
-      if ary = _trans(conn)[:after_rollback]
-        ary.each{|b| b.call}
-      end
-    end
-
     # Whether the current thread/connection is already inside a transaction
     def already_in_transaction?(conn, opts)
       _trans(conn) && (!supports_savepoints? || !opts[:savepoint])
@@ -288,14 +274,10 @@ module Sequel
     # Remove the current thread from the list of active transactions
     def remove_transaction(conn, committed)
       if transaction_finished?(conn)
-        begin
-          if committed
-            after_transaction_commit(conn)
-          else
-            after_transaction_rollback(conn)
-          end
-        ensure
-          Sequel.synchronize{@transactions.delete(conn)}
+        callbacks = _trans(conn)[committed ? :after_commit : :after_rollback]
+        Sequel.synchronize{@transactions.delete(conn)}
+        if callbacks
+          callbacks.each{|b| b.call}
         end
       end
     end

data/lib/sequel/dataset/mutation.rb

@@ -42,7 +42,7 @@ module Sequel
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
           pr.call(self)
         else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets")
+          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
         end
       end
       self

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -3,7 +3,7 @@ module Sequel
     # PlaceholderLiteralizer allows you to record the application of arbitrary changes
     # to a dataset with placeholder arguments, recording where those placeholder arguments
     # are used in the query.  When running the query, the literalization process is much
-    # faster as Sequel can skip most of the work it normal has to do when literalizing a
+    # faster as Sequel can skip most of the work it normally has to do when literalizing a
     # dataset.
     #
     # Basically, this enables optimizations that allow Sequel to cache the SQL produced
@@ -27,7 +27,7 @@ module Sequel
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
     #     ds.join(pl.arg, :item_id=>:id)
     #   end
-    #   loader(:cart_items)
+    #   loader.all(:cart_items)
     #  
     # Will not qualify the item_id column with cart_items.  In this type of situation it's
     # best to add a table alias when joining:
@@ -35,7 +35,7 @@ module Sequel
     #   loader = Sequel::Dataset::PlaceholderLiteralizer.loader(DB[:items]) do |pl, ds|
     #     ds.join(Sequel.as(pl.arg, :t), :item_id=>:id)
     #   end
-    #   loader(:cart_items)
+    #   loader.all(:cart_items)
     #
     # There are other similar cases that are not handled, mainly when Sequel changes the
     # SQL produced depending on the types of the arguments.

data/lib/sequel/extensions/dataset_source_alias.rb

@@ -41,7 +41,7 @@ module Sequel
   class Dataset
     module DatasetSourceAlias
       # Preprocess the list of sources and attempt to alias any
-      # datasets in the sources to the first source of the resepctive
+      # datasets in the sources to the first source of the respective
       # dataset.
       def from(*source, &block)
         virtual_row_columns(source, block)

data/lib/sequel/extensions/pg_hstore.rb

@@ -141,7 +141,7 @@ module Sequel
       module DatabaseMethods
         def self.extended(db)
           db.instance_eval do
-            add_named_conversion_procs(conversion_procs, :hstore=>PG_NAMED_TYPES[:hstore])
+            add_named_conversion_proc(:hstore)
             @schema_type_classes[:hstore] = HStore
           end
         end

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -52,6 +52,14 @@
 #   h.to_matrix      # hstore_to_matrix(hstore_column)
 #   h.values         # avals(hstore_column)
 #
+# Here are a couple examples for updating an existing hstore column:
+#
+#   # Add a key, or update an existing key with a new value
+#   DB[:tab].update(:h=>Sequel.hstore_op(:h).concat('c'=>3))
+# 
+#   # Delete a key
+#   DB[:tab].update(:h=>Sequel.hstore_op(:h).delete('k1'))
+#  
 # See the PostgreSQL hstore function and operator documentation for more
 # details on what these functions and operators do.
 #

data/lib/sequel/extensions/pg_json.rb

@@ -282,7 +282,7 @@ module Sequel
       end
     end
 
-    # Wrap the array or hash in a Postgres::JSONArray or Postgres::JSONHash.
+    # Wrap the array or hash in a Postgres::JSONBArray or Postgres::JSONBHash.
     def pg_jsonb(v)
       case v
       when Postgres::JSONBArray, Postgres::JSONBHash
@@ -296,7 +296,7 @@ module Sequel
       when Postgres::JSONHash
         Postgres::JSONBHash.new(v.to_hash)
       else
-        Sequel.pg_json_op(v)
+        Sequel.pg_jsonb_op(v)
       end
     end
   end

data/lib/sequel/plugins/json_serializer.rb

@@ -290,7 +290,9 @@ module Sequel
           end
 
           if root = opts[:root]
-            root = model.send(:underscore, model.to_s) unless root.is_a?(String)
+            unless root.is_a?(String)
+              root = model.send(:underscore, model.send(:demodulize, model.to_s))
+            end
             h = {root => h}
           end
 
@@ -330,7 +332,7 @@ module Sequel
               opts.delete(:root)
             end
             unless collection_root.is_a?(String)
-              collection_root = model.send(:pluralize, model.send(:underscore, model.to_s))
+              collection_root = model.send(:pluralize, model.send(:underscore, model.send(:demodulize, model.to_s)))
             end
           end
 

data/lib/sequel/sql.rb

@@ -791,6 +791,38 @@ module Sequel
       end
     end
 
+    # This module includes methods for overriding the =~ method for SQL equality,
+    # inclusion, and pattern matching.  It returns the same result that Sequel would
+    # return when using a hash with a single entry, where the receiver was the key
+    # and the argument was the value. Example:
+    #
+    #   Sequel.expr(:a) =~ 1 # (a = 1)
+    #   Sequel.expr(:a) =~ [1, 2] # (a IN [1, 2])
+    #   Sequel.expr(:a) =~ nil # (a IS NULL)
+    #
+    # On Ruby 1.9+, this also adds the !~ method, for easily setting up not equals,
+    # exclusion, and inverse pattern matching.  This is the same as as inverting the
+    # result of the =~ method
+    #
+    #   Sequel.expr(:a) !~ 1 # (a != 1)
+    #   Sequel.expr(:a) !~ [1, 2] # (a NOT IN [1, 2])
+    #   Sequel.expr(:a) !~ nil # (a IS NOT NULL)
+    module PatternMatchMethods
+      # Set up an equality, inclusion, or pattern match operation, based on the type
+      # of the argument.
+      def =~(other)
+        BooleanExpression.send(:from_value_pair, self, other)
+      end
+
+      if RUBY_VERSION >= '1.9'
+        module_eval(<<-END, __FILE__, __LINE__+1)
+          def !~(other)
+            ~(self =~ other)
+          end
+        END
+      end
+    end
+
     # These methods are designed as replacements for the core extension operator
     # methods, so that Sequel is still easy to use if the core extensions are not
     # enabled.
@@ -1358,6 +1390,7 @@ module Sequel
       include InequalityMethods
       include NumericMethods
       include OrderMethods
+      include PatternMatchMethods
       include StringMethods
       include SubscriptMethods
     end

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 20
+  MINOR = 21
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -924,6 +924,11 @@ describe "A PostgreSQL database" do
     @db[:posts].full_text_search(:title, 'rubinius ruby', :plain=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
     @db[:posts].full_text_search(:title, 'jruby maglev', :plain=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
 
+    @db[:posts].full_text_search(Sequel.function(:to_tsvector, 'simple', :title), 'rails', :tsvector=>true).all.should == [{:title=>'ruby rails', :body=>'yowsa'}]
+    @db[:posts].full_text_search(:title, Sequel.function(:to_tsquery, 'simple', 'rails'), :tsquery=>true).all.should == [{:title=>'ruby rails', :body=>'yowsa'}]
+    proc{@db[:posts].full_text_search(Sequel.function(:to_tsvector, 'simple', :title), 'rubinius ruby', :tsvector=>true, :phrase=>true)}.should raise_error(Sequel::Error)
+    proc{@db[:posts].full_text_search(:title, Sequel.function(:to_tsquery, 'simple', 'rails'), :tsquery=>true, :phrase=>true)}.should raise_error(Sequel::Error)
+
     @db[:posts].delete
     t1 = "bork " * 1000 + "ruby sequel"
     t2 = "ruby sequel " * 1000

data/spec/core/database_spec.rb

@@ -899,6 +899,16 @@ shared_examples_for "Database#transaction" do
     @db.sqls.should == ['BEGIN', 'COMMIT']
   end
 
+  specify "should have transaction inside after_commit work correctly" do
+    @db.transaction{@db.after_commit{@db.transaction{@db.execute('foo')}}}
+    @db.sqls.should == ['BEGIN', 'COMMIT', 'BEGIN', 'foo', 'COMMIT']
+  end
+
+  specify "should have transaction inside after_rollback work correctly" do
+    @db.transaction(:rollback=>:always){@db.after_rollback{@db.transaction{@db.execute('foo')}}}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'foo', 'COMMIT']
+  end
+
   specify "should not call after_commit if the transaction rolls back" do
     @db.transaction{@db.after_commit{@db.execute('foo')}; raise Sequel::Rollback}
     @db.sqls.should == ['BEGIN', 'ROLLBACK']

data/spec/core/expression_filters_spec.rb

@@ -59,6 +59,34 @@ describe "Blockless Ruby Filters" do
     @d.l(~Sequel.expr(:x => nil)).should == '(x IS NOT NULL)'
   end
   
+  it "should support = and similar operations via =~ method" do
+    @d.l{x =~ 100}.should == '(x = 100)'
+    @d.l{x =~ 'a'}.should == '(x = \'a\')'
+    @d.l{x =~ true}.should == '(x IS TRUE)'
+    @d.l{x =~ false}.should == '(x IS FALSE)'
+    @d.l{x =~ nil}.should == '(x IS NULL)'
+    @d.l{x =~ (1...5)}.should == '((x >= 1) AND (x < 5))'
+    @d.l{x =~ [1,2,3]}.should == '(x IN (1, 2, 3))'
+
+    def @d.supports_regexp?; true end
+    @d.l{x =~ /blah/}.should == '(x ~ \'blah\')'
+  end
+
+  if RUBY_VERSION >= '1.9'
+    it "should support != and similar inversions via !~ method" do
+      @d.l{x !~ 100}.should == '(x != 100)'
+      @d.l{x !~ 'a'}.should == '(x != \'a\')'
+      @d.l{x !~ true}.should == '(x IS NOT TRUE)'
+      @d.l{x !~ false}.should == '(x IS NOT FALSE)'
+      @d.l{x !~ nil}.should == '(x IS NOT NULL)'
+      @d.l{x !~ (1...5)}.should == '((x < 1) OR (x >= 5))'
+      @d.l{x !~ [1,2,3]}.should == '(x NOT IN (1, 2, 3))'
+
+      def @d.supports_regexp?; true end
+      @d.l{x !~ /blah/}.should == '(x !~ \'blah\')'
+    end
+  end
+  
   it "should support ~ via Hash and Regexp (if supported by database)" do
     def @d.supports_regexp?; true end
     @d.l(:x => /blah/).should == '(x ~ \'blah\')'

data/spec/extensions/json_serializer_spec.rb

@@ -206,6 +206,19 @@ describe "Sequel::Plugins::JsonSerializer" do
     @album.to_json(:root=>true, :except => [:name, :artist_id]).to_s.should == '{"album":{"id":1}}'
     @album.to_json(:root=>true, :only => :name).to_s.should == '{"album":{"name":"RF"}}'
   end
+
+  it "should handle the :root option to qualify single records of namespaced models" do
+    module ::Namespace
+      class Album < Sequel::Model
+        plugin :json_serializer, :naked=>true
+      end
+    end
+    Namespace::Album.new({}).to_json(:root=>true).to_s.should == '{"album":{}}'
+    Namespace::Album.dataset._fetch = [{}]
+    Namespace::Album.dataset.to_json(:root=>:collection).to_s.should == '{"albums":[{}]}'
+    Namespace::Album.dataset.to_json(:root=>:both).to_s.should == '{"albums":[{"album":{}}]}'
+    Object.send(:remove_const, :Namespace)
+  end
   
   it "should handle the :root option with a string to qualify single records using the string as the key" do
     @album.to_json(:root=>"foo", :except => [:name, :artist_id]).to_s.should == '{"foo":{"id":1}}'

data/spec/extensions/pg_json_ops_spec.rb

@@ -206,6 +206,7 @@ describe "Sequel::Postgres::JSONOp" do
   it "should be able to turn symbols into json ops using Sequel.pg_json" do
     @db.literal(Sequel.pg_json(:a)[1]).should == "(a -> 1)"
     @db.literal(Sequel.pg_jsonb(:a)[1]).should == "(a -> 1)"
+    @db.literal(Sequel.pg_jsonb(:a).contains('a'=>1)).should == "(a @> '{\"a\":1}'::jsonb)"
   end
 
   it "should allow transforming JSONArray instances into ArrayOp instances" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.20.0
+  version: 4.21.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -193,6 +193,7 @@ extra_rdoc_files:
 - doc/release_notes/4.18.0.txt
 - doc/release_notes/4.19.0.txt
 - doc/release_notes/4.20.0.txt
+- doc/release_notes/4.21.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -301,6 +302,7 @@ files:
 - doc/release_notes/4.19.0.txt
 - doc/release_notes/4.2.0.txt
 - doc/release_notes/4.20.0.txt
+- doc/release_notes/4.21.0.txt
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt