sequel 4.26.0 → 4.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf4997b7f0149580e9838f7a7c1d0802ce9fdd6b
-  data.tar.gz: 21d723dcf70b74e58a194e71c0d1fb31a6775917
+  metadata.gz: c8e0006e87c72a9cee83298b0fab32a7ccea74ef
+  data.tar.gz: 46a222bb7aa35ce30d2a931c56c0cc49d8fd1b3a
 SHA512:
-  metadata.gz: 851a0cbbd200cffc7280a35168450fcfdb690af48b21c5adf6864289df9fa8eb2b7e7999b396598d0bf3db371e1e721db896bdb869288aa79b8d5db36467b2ed
-  data.tar.gz: 806d66ebf5e196040b42bc023dc2ac13a374037df98e419cc1db69bc2a52c10cd4bae8e6e22c79681ed27256fbba81e109d3a0a593ae62831d3f0cd827c6e2f8
+  metadata.gz: db00224bfcada026d014fbe777cee84849e8786a33519258197a371e9f48970c8a37a1e45e05462f90e0c9e89fb638dcfd1c5442855f1d6b02e7a79b2a21901d
+  data.tar.gz: 79bbb7ad3a536b02bd7242c2fd2b6f08b2772a5b44ba5acdca66224fe93c009e093861ec9e61b877b8349d77ae3d2c5350edcae41cfd6f10827984be0e77ffde

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 4.27.0 (2015-10-01)
+
+* Don't stub Sequel.synchronize on MRI (YorickPeterse) (#1083)
+
+* Make bin/sequel warn if given arguments that it doesn't use (jeremyevans)
+
+* Fix the order of referenced composite keys returned by Database#foreign_key_list on PostgreSQL (jeremyevans) (#1081)
+
+* Recognize another disconnect error in the jdbc/postgresql adapter (jeremyevans)
+
+* In the active model plugin, make Model#persisted? return false if the transaction used for creation is rolled back (jeremyevans) (#1076)
+
+* Use primary_key :keep_order option in the schema dumper if the auto incrementing column is not the first column in the table (jeremyevans)
+
+* Set :auto_increment option correctly in the schema parser when the auto incrementing column is not the first column in the table (jeremyevans)
+
+* Support :keep_order option to primary_key in schema generator, to not automatically make the primary key the first column (jeremyevans)
+
+* Add new jsonb/json functions and operators supported in PostgreSQL 9.5+ (jeremyevans)
+
+* Add before_after_save plugin, for refreshing created objects and resetting modified flag before calling after_create/update/save hooks (jeremyevans)
+
+* Add Dataset#single_record! and #single_value! which don't require cloning the receiver (jeremyevans)
+
+* Dataset#with_sql_single_value now works correctly for model datasets (jeremyevans)
+
+* Optimize Dataset#single_value and #with_sql_single_value to not create an unnecessary array (jeremyevans)
+
+* Make postgres adapter work with postgres-pr 0.7.0 (jeremyevans) (#1074)
+
 === 4.26.0 (2015-09-01)
 
 * Make Dataset#== not consider frozen status in determining equality (jeremyevans)

data/bin/sequel

@@ -116,6 +116,9 @@ error_proc = lambda do |msg|
   $stderr.puts(msg)
   exit 1
 end
+extra_proc = lambda do
+  $stderr.puts("Warning: last #{ARGV.length} arguments ignored") unless ARGV.empty?
+end
 
 error_proc["Error: Must specify -m if using -M"] if migrate_ver && !migrate_dir
 error_proc["Error: Cannot specify #{exclusive_options.map{|v| "-#{v}"}.join(' and ')} together"] if exclusive_options.length > 1
@@ -151,16 +154,19 @@ begin
   DB = connect_proc[db]
   load_dirs.each{|d| d.is_a?(Array) ? require(d.first) : Dir["#{d}/**/*.rb"].each{|f| load(f)}}
   if migrate_dir
+    extra_proc.call
     Sequel.extension :migration, :core_extensions
     Sequel::Migrator.apply(DB, migrate_dir, migrate_ver)
     exit
   end
   if dump_migration
+    extra_proc.call
     DB.extension :schema_dumper
     puts DB.dump_schema_migration(:same_db=>dump_migration==:same_db)
     exit
   end
   if dump_schema
+    extra_proc.call
     DB.extension :schema_caching
     DB.tables.each{|t| DB.schema(Sequel::SQL::Identifier.new(t))}
     DB.dump_schema_cache(dump_schema)
@@ -172,6 +178,7 @@ begin
 
     db2 = ARGV.shift
     error_proc["Error: Must specify database connection string or path to yaml file as second argument for database you want to copy to"] if db2.nil? || db2.empty?
+    extra_proc.call
     start_time = Time.now
     TO_DB = connect_proc[db2]
     same_db = DB.database_type==TO_DB.database_type
@@ -225,6 +232,7 @@ begin
     exit
   end
   if code
+    extra_proc.call
     eval(code)
     exit
   end

data/doc/opening_databases.rdoc

@@ -309,7 +309,9 @@ The Sequel postgres adapter works with the pg, postgres, and postgres-pr ruby li
 The pg library is the best supported, as it supports real bound variables and prepared statements.
 If the pg library is being used, Sequel will also attempt to load the sequel_pg library, which is
 a C extension that optimizes performance when Sequel is used with pg.  All users of Sequel who
-use pg are encouraged to install sequel_pg.
+use pg are encouraged to install sequel_pg.  For users who want to use postgres-pr to avoid issues
+with C extensions, it is recommended to use jeremyevans-postgres-pr, which fixes many issues in
+the upstream postgres-pr gem, and is regularly tested with Sequel.
 
 The following additional options are supported:
 

data/doc/postgresql.rdoc

@@ -185,6 +185,19 @@ When returning is used, instead of returning the number of rows affected (for up
 or the serial primary key value (for insert), it will return an array of hashes with the
 returned results.
 
+=== VALUES Support
+
+Sequel offers support for the +VALUES+ statement using <tt>Database#values</tt>:
+
+  DB.values([[1,2],[2,3],[3,4]])
+  # VALUES (1, 2), (2, 3), (3, 4)
+
+  DB.values([[1,2],[2,3],[3,4]]).order(2, 1)
+  # VALUES (1, 2), (2, 3), (3, 4) ORDER BY 2, 1
+
+  DB.values([[1,2],[2,3],[3,4]]).order(2, 1).limit(1,2)
+  # VALUES (1, 2), (2, 3), (3, 4) ORDER BY 2, 1 LIMIT 1 OFFSET 2
+
 === INSERT ON CONFLICT Support
 
 Starting with PostgreSQL 9.5, you can do an upsert or ignore unique or exclusion constraint

data/doc/release_notes/4.27.0.txt

@@ -0,0 +1,78 @@
+= New Features
+
+* A before_after_save plugin has been added, which for newly
+  created objects refreshes the object before calling after_create,
+  and resets the modified flag before calling after_update.
+  Previously, these actions were not taken until after after_save
+  was called.  This will be the default behavior in Sequel 5.
+
+* In create_table blocks, primary_key now supports a :keep_order
+  option, which will not change the order in which the primary key
+  is added.  Without this option, Sequel's historical behavior of
+  making the primary key column the first column is used.
+
+    DB.create_table(:foo) do
+      Integer :a
+      primary_key :b, :keep_order=>true
+    end
+    # CREATE TABLE foo 
+    # (a integer, b integer PRIMARY KEY AUTOINCREMENT)
+
+  The schema dumper now uses this option if necessary, allowing it
+  to correctly dump tables where the primary key column is not the
+  first column.
+
+* Dataset#single_record! and #single_value! have been added.  These
+  are faster versions of #single_record and #single_value that
+  don't require cloning the dataset.  If you are sure the dataset
+  will only return a single row or a single value, you can use
+  these methods for better performance.
+
+* The new jsonb and json functions added in PostgreSQL 9.5 are now
+  supported by the pg_json_ops extension.
+
+    Sequel.pg_jsonb_op(:metadata).set(%w'a b', [1,2,3])
+    # jsonb_set("metadata", ARRAY['a','b'], '[1,2,3]'::jsonb, true)
+
+= Other Improvements
+
+* Sequel.synchronize is no longer a stub on MRI.  Testing has shown
+  that relying on the global interpreter lock to protect
+  multi-threaded access to hashes is not safe in all environments,
+  so Sequel now uses a mutex on MRI just as it does on other ruby
+  interpreters.
+
+* Database#schema now sets the :auto_increment option correctly for
+  auto incrementing primary keys if they are not the first column
+  in the table.
+
+* Dataset#single_value and #with_sql_single_value are now slightly
+  faster by avoiding an array allocation.
+
+* Model datasets can now use #with_sql_single_value and return a
+  single value, instead of an array in [:column_name, value] format.
+
+* Model#persisted? in the active_model plugin will now return false
+  if the transaction that inserts the row for the object is rolled
+  back.
+  
+* bin/sequel now warns if additional arguments are passed that it
+  ignores.  In Sequel 5, bin/sequel will raise an error in these
+  cases.
+
+* Database#foreign_key_list on PostgreSQL now returns referenced
+  composite keys in the correct order.
+
+* The postgres adapter now works with postgres-pr 0.7.0. Note that
+  postgres adapter users that want a pure-ruby driver are encouraged
+  to use jeremyevans-postgres-pr as that has many additional bugfixes
+  and is the version tested with Sequel on a regular basis.
+
+* The jdbc/postgresql adapter now recognizes an additional disconnect
+  error.
+
+= Backwards Compatibility
+
+* Users who were relying on #with_sql_single_value returning an array
+  instead of a single value for model datasets need to update their
+  code.

data/doc/thread_safety.rdoc

@@ -4,7 +4,7 @@ Most Sequel usage (and all common Sequel usage) is thread safe by default.  Spec
 
 == Connection Pool
 
-In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block (actually busy-wait) until a connection is available or the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
+In order to allow multiple threads to operate on the same database at the same time, Sequel uses a connection pool.  The connection pool is designed so that a thread uses a connection for the minimum amount of time, returning the connection to the pool as soon as it is done using the connection.  If a thread requests a connection and the pool does not have an available connection, a new connection will be created.  If the maximum number of connections in the pool has already been reached, the thread will block until a connection is available or the connection pool timeout has elapsed (in which case a PoolTimeout error will be raised).
 
 == Exceptions
 

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

@@ -135,7 +135,7 @@ module Sequel
         end
 
         def disconnect_error?(exception, opts)
-          super || exception.message =~ /\AThis connection has been closed\.\z|\AFATAL: terminating connection due to administrator command\z/
+          super || exception.message =~ /\A(This connection has been closed\.|FATAL: terminating connection due to administrator command|An I\/O error occurred while sending to the backend\.)\z/
         end
 
         # Use setNull for nil arguments as the default behavior of setString

data/lib/sequel/adapters/postgres.rb

@@ -2,6 +2,10 @@ Sequel.require 'adapters/shared/postgres'
 
 begin 
   require 'pg' 
+
+  # Work around postgres-pr 0.7.0+ which ships with a pg.rb file
+  raise LoadError unless defined?(PGconn::CONNECTION_OK)
+
   SEQUEL_POSTGRES_USES_PG = true
 rescue LoadError => e 
   SEQUEL_POSTGRES_USES_PG = false

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

@@ -308,7 +308,7 @@ module Sequel
         ref_ds = base_ds.
           join(:pg_class___cl2, :oid=>:co__confrelid).
           join(:pg_attribute___att2, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__confkey)).
-          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__conkey, [x]), x]}, 32, :att2__attnum)).
+          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__confkey, [x]), x]}, 32, :att2__attnum)).
           select(:co__conname___name, :cl2__relname___table, :att2__attname___refcolumn)
 
         # If a schema is given, we only search in that schema, and the returned :table

data/lib/sequel/core.rb

@@ -293,24 +293,14 @@ module Sequel
     end
   end
 
-  if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
-  # :nocov:
-    # Mutex used to protect mutable data structures
-    @data_mutex = Mutex.new
-
-    # Unless in single threaded mode, protects access to any mutable
-    # global data structure in Sequel.
-    # Uses a non-reentrant mutex, so calling code should be careful.
-    def self.synchronize(&block)
-      @single_threaded ? yield : @data_mutex.synchronize(&block)
-    end
-  # :nocov:
-  else
-    # Yield directly to the block.  You don't need to synchronize
-    # access on MRI because the GVL makes certain methods atomic.
-    def self.synchronize
-      yield
-    end
+  # Mutex used to protect mutable data structures
+  @data_mutex = Mutex.new
+
+  # Unless in single threaded mode, protects access to any mutable
+  # global data structure in Sequel.
+  # Uses a non-reentrant mutex, so calling code should be careful.
+  def self.synchronize(&block)
+    @single_threaded ? yield : @data_mutex.synchronize(&block)
   end
 
   # Uses a transaction on all given databases with the given options. This:

data/lib/sequel/database/query.rb

@@ -161,7 +161,7 @@ module Sequel
 
       primary_keys = 0
       auto_increment_set = false
-      cols.all? do |_,c|
+      cols.each do |_,c|
         auto_increment_set = true if c.has_key?(:auto_increment)
         primary_keys += 1 if c[:primary_key]
       end

data/lib/sequel/database/schema_generator.rb

@@ -236,22 +236,35 @@ module Sequel
       #
       # If an array of column symbols is used, you can specify the :name option
       # to name the constraint.
+      #
+      # Options:
+      # :keep_order :: For non-composite primary keys, respects the existing order of
+      #                columns, overriding the default behavior of making the primary
+      #                key the first column.
       # 
       # Examples:
       #   primary_key(:id)
+      #   primary_key(:id, Bigint)
+      #   primary_key(:id, Bigint, :keep_order=>true)
       #   primary_key([:street_number, :house_number], :name=>:some constraint_name)
       def primary_key(name, *args)
         return composite_primary_key(name, *args) if name.is_a?(Array)
-        @primary_key = @db.serial_primary_key_options.merge({:name => name})
+        column = @db.serial_primary_key_options.merge({:name => name})
         
         if opts = args.pop
           opts = {:type => opts} unless opts.is_a?(Hash)
           if type = args.pop
-            opts.merge!(:type => type)
+            opts = opts.merge(:type => type)
           end
-          @primary_key.merge!(opts)
+          column.merge!(opts)
+        end
+
+        @primary_key = column
+        if column[:keep_order]
+          columns << column
+        else
+          columns.unshift(column)
         end
-        @primary_key
       end
 
       # The name of the primary key for this generator, if it has a primary key.

data/lib/sequel/dataset/actions.rb

@@ -12,7 +12,7 @@ module Sequel
       << [] all avg count columns columns! delete each
       empty? fetch_rows first first! get import insert interval last
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
-      single_record single_value sum to_hash to_hash_groups truncate update
+      single_record single_record! single_value single_value! sum to_hash to_hash_groups truncate update
     METHS
 
     # Inserts the given argument into the database.  Returns self so it
@@ -637,22 +637,51 @@ module Sequel
       _select_map(column, true, &block)
     end
 
-    # Returns the first record in the dataset, or nil if the dataset
-    # has no records. Users should probably use +first+ instead of
-    # this method.
+    # Limits the dataset to one record, and returns the first record in the dataset,
+    # or nil if the dataset has no records. Users should probably use +first+ instead of
+    # this method. Example:
+    #
+    #   DB[:test].single_record # SELECT * FROM test LIMIT 1
+    #   # => {:column_name=>'value'}
     def single_record
-      clone(:limit=>1).each{|r| return r}
-      nil
+      clone(:limit=>1).single_record!
+    end
+
+    # Returns the first record in dataset, without limiting the dataset. Returns nil if
+    # the dataset has no records. Users should probably use +first+ instead of this method.
+    # This should only be used if you know the dataset is already limited to a single record.
+    # This method may be desirable to use for performance reasons, as it does not clone the
+    # receiver. Example:
+    #
+    #   DB[:test].single_record! # SELECT * FROM test
+    #   # => {:column_name=>'value'}
+    def single_record!
+      with_sql_first(select_sql)
     end
 
     # Returns the first value of the first record in the dataset.
     # Returns nil if dataset is empty.  Users should generally use
-    # +get+ instead of this method.
+    # +get+ instead of this method. Example:
+    #
+    #   DB[:test].single_value # SELECT * FROM test LIMIT 1
+    #   # => 'value'
     def single_value
       if r = ungraphed.naked.single_record
-        r.values.first
+        r.each{|_, v| return v}
       end
     end
+
+    # Returns the first value of the first record in the dataset, without limiting the dataset.
+    # Returns nil if the dataset is empty. Users should generally use +get+ instead of this
+    # method.  Should not be used on graphed datasets or datasets that have row_procs that
+    # don't return hashes.  This method may be desirable to use for performance reasons, as
+    # it does not clone the receiver.
+    #
+    #   DB[:test].single_value! # SELECT * FROM test
+    #   # => 'value'
+    def single_value!
+      with_sql_single_value(select_sql)
+    end
     
     # Returns the sum for the given column/expression.
     # Uses a virtual row block if no column is given.
@@ -818,7 +847,7 @@ module Sequel
     # only a single value.  See with_sql_each.
     def with_sql_single_value(sql)
       if r = with_sql_first(sql)
-        r.values.first
+        r.each{|_, v| return v}
       end
     end
 

data/lib/sequel/extensions/pg_json_ops.rb

@@ -50,6 +50,7 @@
 #   j.each_text              # json_each_text(json_column)
 #   j.keys                   # json_object_keys(json_column)
 #   j.typeof                 # json_typeof(json_column)
+#   j.strip_nulls            # json_strip_nulls(json_column)
 #
 #   j.populate(:a)           # json_populate_record(:a, json_column)
 #   j.populate_set(:a)       # json_populate_recordset(:a, json_column)
@@ -58,11 +59,16 @@
 #
 # There are additional methods are are only supported on JSONBOp instances:
 #
-#   j.contain_all(:a)  # (jsonb_column ?& a)
-#   j.contain_any(:a)  # (jsonb_column ?| a)
-#   j.contains(:h)     # (jsonb_column @> h)
-#   j.contained_by(:h) # (jsonb_column <@ h)
-#   j.has_key?('a')    # (jsonb_column ? 'a')
+#   j - 1                  # (jsonb_column - 1)
+#   j.concat(:h)           # (jsonb_column || h)
+#   j.contain_all(:a)      # (jsonb_column ?& a)
+#   j.contain_any(:a)      # (jsonb_column ?| a)
+#   j.contains(:h)         # (jsonb_column @> h)
+#   j.contained_by(:h)     # (jsonb_column <@ h)
+#   j.delete_path(%w'0 a') # (jsonb_column #- ARRAY['0','a'])
+#   j.has_key?('a')        # (jsonb_column ? 'a')
+#   j.pretty               # jsonb_pretty(jsonb_column)
+#   j.set(%w'0 a', :h)     # jsonb_set(jsonb_column, ARRAY['0','a'], h, true)
 #
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
@@ -192,6 +198,13 @@ module Sequel
         SQL::Function.new(function_name(:populate_recordset), arg, self)
       end
 
+      # Returns a json value stripped of all internal null values.
+      #
+      #   json_op.strip_nulls # json_strip_nulls(json)
+      def strip_nulls
+        self.class.new(function(:strip_nulls))
+      end
+
       # Builds arbitrary record from json object.  You need to define the
       # structure of the record using #as on the resulting object:
       #
@@ -266,12 +279,30 @@ module Sequel
     #
     #   jsonb_op = Sequel.pg_jsonb(:jsonb)
     class JSONBOp < JSONBaseOp
+      CONCAT = ["(".freeze, " || ".freeze, ")".freeze].freeze
       CONTAIN_ALL = ["(".freeze, " ?& ".freeze, ")".freeze].freeze
       CONTAIN_ANY = ["(".freeze, " ?| ".freeze, ")".freeze].freeze
       CONTAINS = ["(".freeze, " @> ".freeze, ")".freeze].freeze
       CONTAINED_BY = ["(".freeze, " <@ ".freeze, ")".freeze].freeze
+      DELETE_PATH = ["(".freeze, " #- ".freeze, ")".freeze].freeze
       HAS_KEY = ["(".freeze, " ? ".freeze, ")".freeze].freeze
 
+      # jsonb expression for deletion of the given argument from the
+      # current jsonb.
+      #
+      #   jsonb_op - "a" # (jsonb - 'a')
+      def -(other)
+        self.class.new(super)
+      end
+
+      # jsonb expression for concatenation of the given jsonb into
+      # the current jsonb.
+      #
+      #   jsonb_op.concat(:h) # (jsonb || h)
+      def concat(other)
+        json_op(CONCAT, wrap_input_jsonb(other))
+      end
+
       # Check if the receiver contains all of the keys in the given array:
       #
       #   jsonb_op.contain_all(:a) # (jsonb ?& a)
@@ -300,6 +331,13 @@ module Sequel
         bool_op(CONTAINED_BY, wrap_input_jsonb(other))
       end
 
+      # Check if the other jsonb contains all entries in the receiver:
+      #
+      #   jsonb_op.delete_path(:h) # (jsonb #- h)
+      def delete_path(other)
+        json_op(DELETE_PATH, wrap_input_array(other))
+      end
+
       # Check if the receiver contains the given key:
       #
       #   jsonb_op.has_key?('a') # (jsonb ? 'a')
@@ -313,6 +351,21 @@ module Sequel
         self
       end
 
+      # Returns a json value for the object at the given path.
+      #
+      #   jsonb_op.pretty # jsonb_pretty(jsonb)
+      def pretty
+        Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
+      end
+
+      # Returns a json value for the object at the given path.
+      #
+      #   jsonb_op.set(['a', 'b'], h) # jsonb_set(jsonb, ARRAY['a', 'b'], h, true)
+      #   jsonb_op.set(['a', 'b'], h, false) # jsonb_set(jsonb, ARRAY['a', 'b'], h, false)
+      def set(path, other, create_missing=true)
+        self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
+      end
+
       private
 
       # Return a placeholder literal with the given str and args, wrapped