sequel 4.34.0 → 4.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2bbb9208954c7c7fb4d531621af12ac2ce850339
-  data.tar.gz: fb5c58d9906bba99dd60543dae4089f71b3b3037
+  metadata.gz: 29e8963c69c4f6e3b0af0840e6cc881934ca608f
+  data.tar.gz: 30d2fa8ead89124fa8a4e8a4582a11a78bf7a5c8
 SHA512:
-  metadata.gz: e00cd2f1752cdd25fd45c30479d4f104c10a7e4b6411eba817601b48b367c1a8cda00f84da65486b948497cf27f7429245654e0f77886ff1088a0d1588b39ca7
-  data.tar.gz: 63fce28567f5a354105a9cf816a6be443b73755beed960567011e3b16169cd22a8ae65fc692b00bd4f337fef57cb1db8105ada35aa150634b738675b83dfdeb8
+  metadata.gz: 2961452f5e6b3f1ab7e32da5e4a4dd92e9362a13bb561999ebd493ab8877132d803b7c3e22206ded6a9c2e8336a9bde344c3e2707cbe81732a115d45383d4186
+  data.tar.gz: 72c885ba7219f83ac043bf213045f7b67ebbf213c4aa8380224c9c9d76fd1cd446f043e77ba0765e34684cf0fd35300b6b966a688f6e631e83b4b556ecb25b76

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 4.35.0 (2016-06-01)
+
+* Add :headline option to PostgreSQL Dataset#full_text_search for adding an extract of the matched text to the SELECT list (jeremyevans)
+
+* Make :rollback=>:always inside a transaction use a savepoint automatically if supported (jeremyevans) (#1193)
+
+* Recognize bool type as boolean in the schema dumper (jeremyevans) (#1192)
+
+* Make Dataset#to_hash and #to_hash_groups work correctly for model datasets doing eager loading (jeremyevans)
+
+* Make delay_add_association plugin handle hashes and primary keys passed to add_* association methods (jeremyevans) (#1187)
+
+* Treat :Bignum as a generic type, to support 64-bit integers on ruby 2.4+, where Bignum == Integer (jeremyevans)
+
+* Add server_logging extension for including server/shard information when logging queries (jeremyevans)
+
+* Add Database#log_connection_info, for including connection information when logging queries (jeremyevans)
+
+* Add Dataset#skip_locked for skipping locked rows on PostgreSQL 9.5+, MSSQL, and Oracle (jeremyevans)
+
+* Allow Sequel::Model#lock! to accept an optional lock style (petedmarsh) (#1183)
+
+* Add sql_comments extension for setting SQL comments on queries (jeremyevans)
+
+* Make Postgres::PGRange#cover? handle empty, unbounded, and exclusive beginning ranges (jeremyevans)
+
+* Fix frozen string literal issues on JRuby 9.1.0.0 (jeremyevans)
+
+* Allow json_serializer :include option with cascaded values to work correctly when used with association_proxies (jeremyevans)
+
 === 4.34.0 (2016-05-01)
 
 * Add support for :dataset_associations_join association option to dataset_associations plugin, for making resulting datasets have appropriate joins (jeremyevans)

data/Rakefile

@@ -82,21 +82,18 @@ end
 
 ### Specs
 
-run_spec = proc do |patterns|
+run_spec = proc do |file|
   lib_dir = File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
   rubylib = ENV['RUBYLIB']
   ENV['RUBYLIB'] ? (ENV['RUBYLIB'] += ":#{lib_dir}") : (ENV['RUBYLIB'] = lib_dir)
-  if RUBY_PLATFORM =~ /mingw32/ || RUBY_DESCRIPTION =~ /windows/i
-    patterns = patterns.split.map{|pat| Dir[pat].to_a}.flatten.join(' ')
-  end
-  sh "#{FileUtils::RUBY} -e \"ARGV.each{|f| require f}\" #{patterns}"
+  sh "#{FileUtils::RUBY} #{file}"
   ENV['RUBYLIB'] = rubylib
 end
 
-spec_task = proc do |description, name, files, coverage|
+spec_task = proc do |description, name, file, coverage|
   desc description
   task name do
-    run_spec.call(files)
+    run_spec.call(file)
   end
 
   desc "#{description} with warnings, some warnings filtered"
@@ -110,7 +107,7 @@ spec_task = proc do |description, name, files, coverage|
     desc "#{description} with coverage"
     task :"#{name}_cov" do
       ENV['COVERAGE'] = '1'
-      run_spec.call(files)
+      run_spec.call(file)
       ENV.delete('COVERAGE')
     end
   end
@@ -121,19 +118,19 @@ task :default => :spec
 desc "Run the core, model, and extension/plugin specs"
 task :spec => [:spec_core, :spec_model, :spec_plugin]
 
-spec_task.call("Run core and model specs together", :spec_core_model, './spec/core/*_spec.rb ./spec/model/*_spec.rb', true)
-spec_task.call("Run core specs", :spec_core, './spec/core/*_spec.rb', false)
-spec_task.call("Run model specs", :spec_model, './spec/model/*_spec.rb', false)
-spec_task.call("Run plugin/extension specs", :spec_plugin, './spec/extensions/*_spec.rb', true)
-spec_task.call("Run bin/sequel specs", :spec_bin, './spec/bin_spec.rb', false)
-spec_task.call("Run core extensions specs", :spec_core_ext, './spec/core_extensions_spec.rb', true)
-spec_task.call("Run integration tests", :spec_integration, './spec/integration/*_test.rb', true)
+spec_task.call("Run core and model specs together", :spec_core_model, 'spec/core_model_spec.rb', true)
+spec_task.call("Run core specs", :spec_core, 'spec/core_spec.rb', false)
+spec_task.call("Run model specs", :spec_model, 'spec/model_spec.rb', false)
+spec_task.call("Run plugin/extension specs", :spec_plugin, 'spec/plugin_spec.rb', true)
+spec_task.call("Run bin/sequel specs", :spec_bin, 'spec/bin_spec.rb', false)
+spec_task.call("Run core extensions specs", :spec_core_ext, 'spec/core_extensions_spec.rb', true)
+spec_task.call("Run integration tests", :spec_integration, 'spec/adapter_spec.rb none', true)
 
 %w'postgres sqlite mysql informix oracle firebird mssql db2 sqlanywhere'.each do |adapter|
-  spec_task.call("Run #{adapter} tests", :"spec_#{adapter}", "./spec/adapters/#{adapter}_spec.rb ./spec/integration/*_test.rb", true)
+  spec_task.call("Run #{adapter} tests", :"spec_#{adapter}", "spec/adapter_spec.rb #{adapter}", true)
 end
 
-spec_task.call("Run model specs without the associations code", :_spec_model_no_assoc, Dir["./spec/model/*_spec.rb"].delete_if{|f| f =~ /association|eager_loading/}.join(' '), false)
+spec_task.call("Run model specs without the associations code", :_spec_model_no_assoc, 'spec/model_no_assoc_spec.rb', false)
 desc "Run model specs without the associations code"
 task :spec_model_no_assoc do
   ENV['SEQUEL_NO_ASSOCIATIONS'] = '1'

data/doc/object_model.rdoc

@@ -263,7 +263,7 @@ The following shortcuts exist for creating Sequel::SQL::ValueList objects:
 === Sequel::SQL::Identifier
 
 Sequel::SQL::Identifier objects represent single identifiers.  The main reason for
-their existance is that they are not checked for double or triple underscores, so no
+their existence is that they are not checked for double or triple underscores, so no
 automatic qualification or aliasing happens for them:
 
   Sequel::SQL::Identifier.new(:col__umn) # "col__umn"
@@ -389,7 +389,7 @@ The following shortcut exists for creating Sequel::SQL::ColumnAll objects:
 
 === Sequel::SQL::Constant
 
-Sequel::SQL::Constant objects represent constants or psuedo-constants in SQL,
+Sequel::SQL::Constant objects represent constants or pseudo-constants in SQL,
 such as TRUE, NULL, and CURRENT_TIMESTAMP.  These are not designed to be created
 or used by the end user, but some existing values are predefined under the
 Sequel namespace:
@@ -544,9 +544,9 @@ They use a hash-based API, supporting the :frame, :order, :partition, and :windo
 options:
 
   Sequel::SQL::Window.new(:order=>:a) # (ORDER BY "a")
-  Sequel::SQL::Window.new(:parition=>:a) # (PARTITION BY "a")
+  Sequel::SQL::Window.new(:partition=>:a) # (PARTITION BY "a")
 
-  Sequel::SQL::Window.new(:parition=>:a, :frame=>:all)
+  Sequel::SQL::Window.new(:partition=>:a, :frame=>:all)
   # (PARTITION BY "a" ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
 
 === Sequel::SQL::Wrapper

data/doc/release_notes/4.35.0.txt

@@ -0,0 +1,130 @@
+= Forwards Compatibility
+
+* Ruby 2.4 will unify the Fixnum and Bignum classes into the Integer
+  class, making both Fixnum and Bignum references to Integer. This
+  will have the affect of changing the behavior of Sequel migrations
+  that use a reference to the Bignum class.  
+
+  For example, code like this will change behavior in ruby 2.4:
+
+    DB.create_table(:table) do
+      add_column :column, Bignum
+    end
+    # or:
+    DB.get(Sequel.cast('1', Bignum))
+
+  as this references the Bignum class. On ruby <2.4, this will create
+  a 64-bit integer column, on ruby 2.4+, it will create a 32-bit
+  integer column.
+
+  Code like this will be fine and does not need changing:
+
+    DB.create_table(:table) do
+      Bignum :column
+    end
+
+  as this calls the Bignum method.
+
+  Sequel now supports the :Bignum symbol as a generic type, so you
+  can now switch references to the Bignum class to the :Bignum
+  symbol whenever you want a generic 64-bit integer type:
+
+    DB.create_table(:table) do
+      add_column :column, :Bignum
+    end
+    # or:
+    DB.get(Sequel.cast('1', :Bignum))
+
+  Note that you should only do this if you are using Sequel 4.35.0+,
+  as previous versions of Sequel will treat the :Bignum symbol as
+  a database-specific type named Bignum.
+
+= New Features
+
+* A Sequel::Database#log_connection_info accessor has been added.  If
+  set to true, this includes connection information in Sequel's query
+  log.  In threaded connection pools (the default), this makes it
+  simple to see which connection is executing which queries.
+
+    DB.log_connection_info = true
+    DB.get(1)
+    # Logged: (0.000004s) (conn: 9713390226040) SELECT 1 AS v LIMIT 
+
+* Sequel::Model#lock! now supports an optional lock style, instead
+  of always using FOR UPDATE (which is still the default):
+
+    Example.first.lock!('FOR NO KEY UPDATE')
+    #=> SELECT * FROM examples WHERE id = 1 FOR NO KEY UPDATE LIMIT 1
+
+* Sequel::Database#skip_locked has been added, which skips locked rows
+  when returning query results. This is useful whenever you are
+  implementing a queue or similar data structure.  Currently, this is
+  supported on PostgreSQL 9.5+, Oracle, and Microsoft SQL Server.
+
+* An sql_comments extension has been added for setting SQL comments
+  on queries:
+
+    ds = DB[:table].comment("Some Comment").all
+    # SELECT * FROM table -- Some Comment
+    #
+
+  All consecutive whitespace in the comment is replaced by a
+  single space, and the comment ends in a newline so that it works
+  correctly in subqueries.
+
+  This extension is mostly useful if you are doing analysis of your
+  database server query log and want to include higher level
+  information about the query in the comment.
+
+* A server_logging extension has been added, which includes
+  server/shard information in the query log, if connection info
+  is being logged.
+
+    DB.extension :server_logging
+    DB.log_connection_info = true
+    DB.get(1)
+    # Logged: (0.000004s) (conn: 9712828677240, server: read_only)
+    #         SELECT 1 AS v LIMIT 1 
+    DB[:a].insert(:b=>1)
+    # Logged: (0.000003s) (conn: 9712534040260, server: default)
+    #         INSERT INTO a (b) VALUES (1)
+
+* On PostgreSQL, Database#full_text_search now supports a
+  :headline option for adding an extract of the matched text to
+  the SELECT list.
+
+* Sequel::Postgres::PGRange#cover? has been added to the pg_range
+  extension, which works with empty, unbounded, and exclusive
+  beginning ranges.  Previously, using #cover? with these ranges
+  would raise an exception.  Note that cover? is now always
+  defined, where previously it was only defined on ruby 1.9+.
+
+= Other Improvements
+
+* The jdbc adapters now work correctly on JRuby 9.1.  Previously,
+  some parts were broken on JRuby 9.1 due to frozen string literal
+  issues.
+
+* Sequel::Dataset#to_hash and #to_hash_groups now work correctly for
+  model datasets doing eager loading.
+
+* Using Sequel::Database#transaction with the :rollback=>:always
+  option now automatically uses a savepoint if supported when run
+  inside another transaction.  If savepoints are not supported,
+  using :rollback=>:always inside a transaction will now raise an
+  exception.
+
+* The delay_add_association plugin now handles hashes and primary keys
+  passed to the add_* association methods.
+
+* The json_serializer :include option now works correctly when using
+  *_to_many associations with the association_proxies plugin.
+
+* The schema_dumper extension now recognizes bool as a boolean type,
+  for consistency with the Database schema parser.
+
+= Backwards Compatibility
+
+* Custom adapters should switch from using log_yield to
+  log_connection_yield so that they work correctly when using
+  log_connection_info.

data/doc/schema_modification.rdoc

@@ -74,6 +74,11 @@ as the second argument, either as ruby classes, symbols, or strings:
     column :a6, 'timestamp(6)'     # timestamp(6)
   end
 
+If you use a ruby class as the type, Sequel will try to guess the appropriate type name for the
+database you are using.  If a symbol or string as used as the type, it is used verbatim as the type
+name in SQL, with the exception of :Bignum.  Using the symbol :Bignum as a type will use the
+appropriate 64-bit integer type for the database you are using.
+
 === Column options
 
 When using the type name as method, the third argument is an options hash, and when using the +column+
@@ -107,7 +112,7 @@ You've seen this one used already.  It's used to create an autoincrementing inte
 
 If you want an autoincrementing 64-bit integer:
 
-  create_table(:a0){primary_key :id, :type=>Bignum}
+  create_table(:a0){primary_key :id, :type=>:Bignum}
 
 If you want to create a primary key column that doesn't use an autoincrementing integer, you should
 not use this method.  Instead, you should use the :primary_key option to the +column+ method or type
@@ -520,11 +525,11 @@ This modifies a column's type.  Most databases will attempt to convert existing
 the columns to the new type:
 
   alter_table(:albums) do
-    set_column_type :copies_sold, Bignum
+    set_column_type :copies_sold, :Bignum
   end
 
 You can specify the type as a string or symbol, in which case it is used verbatim, or as a supported
-ruby class, in which case it gets converted to an appropriate database type.
+ruby class or the :Bignum symbol, in which case it gets converted to an appropriate database type.
 
 === +set_column_allow_null+
 

data/doc/security.rdoc

@@ -191,10 +191,10 @@ Instead, you should do:
 The no_auto_string_literals extension can also be used to remove the default support
 for plain strings as literal strings in update methods.
 
-==== SQL Fragment passed to Dataset#lock_style
+==== SQL Fragment passed to Dataset#lock_style and Model#lock!
 
-The Sequel::Dataset#lock_style method also treats an input string 
-as SQL code. This method should not be called with user input.
+The Sequel::Dataset#lock_style and Sequel::Model#lock! methods also treat
+an input string as SQL code. This method should not be called with user input.
 
 ==== SQL Type Names
 

data/lib/sequel/adapters/ado.rb

@@ -64,7 +64,7 @@ module Sequel
         return super if opts[:provider]
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.Execute(sql, 1)}
+            log_connection_yield(sql, conn){conn.Execute(sql, 1)}
             WIN32OLE::ARGV[1]
           rescue ::WIN32OLERuntimeError => e
             raise_error(e)
@@ -75,7 +75,7 @@ module Sequel
       def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            r = log_yield(sql){conn.Execute(sql)}
+            r = log_connection_yield(sql, conn){conn.Execute(sql)}
             yield(r) if block_given?
           rescue ::WIN32OLERuntimeError => e
             raise_error(e)

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

@@ -111,8 +111,8 @@ module Sequel
         def execute_insert(sql, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             begin
-              log_yield(sql){conn.Execute(sql)}
-              res = log_yield(LAST_INSERT_ID){conn.Execute(LAST_INSERT_ID)}
+              log_connection_yield(sql, conn){conn.Execute(sql)}
+              res = log_connection_yield(LAST_INSERT_ID, conn){conn.Execute(LAST_INSERT_ID)}
               res.getRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)
@@ -203,15 +203,15 @@ module Sequel
         end
 
         def begin_transaction(conn, opts=OPTS)
-          log_yield('Transaction.begin'){conn.BeginTrans}
+          log_connection_yield('Transaction.begin', conn){conn.BeginTrans}
         end
           
         def commit_transaction(conn, opts=OPTS)
-          log_yield('Transaction.commit'){conn.CommitTrans}
+          log_connection_yield('Transaction.commit', conn){conn.CommitTrans}
         end
           
         def rollback_transaction(conn, opts=OPTS)
-          log_yield('Transaction.rollback'){conn.RollbackTrans}
+          log_connection_yield('Transaction.rollback', conn){conn.RollbackTrans}
         end
           
         def schema_column_type(db_type)
@@ -313,7 +313,7 @@ module Sequel
           ado_schema = AdoSchema.new(type, criteria)
           synchronize(opts[:server]) do |conn|
             begin
-              r = log_yield("OpenSchema #{type.inspect}, #{criteria.inspect}") { 
+              r = log_connection_yield("OpenSchema #{type.inspect}, #{criteria.inspect}", conn) { 
                 if ado_schema.criteria.empty?
                   conn.OpenSchema(ado_schema.type) 
                 else

data/lib/sequel/adapters/ado/mssql.rb

@@ -21,8 +21,8 @@ module Sequel
           return super unless @opts[:provider]
           synchronize(opts[:server]) do |conn|
             begin
-              log_yield(sql){conn.Execute(sql)}
-              res = log_yield(ROWS_AFFECTED){conn.Execute(ROWS_AFFECTED)}
+              log_connection_yield(sql, conn){conn.Execute(sql)}
+              res = log_connection_yield(ROWS_AFFECTED, conn){conn.Execute(ROWS_AFFECTED)}
               res.getRows.transpose.each{|r| return r.shift}
             rescue ::WIN32OLERuntimeError => e
               raise_error(e)

data/lib/sequel/adapters/amalgalite.rb

@@ -81,7 +81,7 @@ module Sequel
         db = ::Amalgalite::Database.new(opts[:database])
         db.busy_handler(::Amalgalite::BusyTimeout.new(opts.fetch(:timeout, 5000)/50, 50))
         db.type_map = SequelTypeMap.new(self)
-        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
+        connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
         db
       end
       
@@ -92,25 +92,25 @@ module Sequel
 
       # Run the given SQL with the given arguments. Returns nil.
       def execute_ddl(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}}
+        _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.execute_batch(sql)}}
         nil
       end
       
       # Run the given SQL with the given arguments and return the number of changed rows.
       def execute_dui(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}; conn.row_changes}
+        _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.execute_batch(sql)}; conn.row_changes}
       end
       
       # Run the given SQL with the given arguments and return the last inserted row id.
       def execute_insert(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.execute_batch(sql)}; conn.last_insert_rowid}
+        _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.execute_batch(sql)}; conn.last_insert_rowid}
       end
       
       # Run the given SQL with the given arguments and yield each row.
       def execute(sql, opts=OPTS)
         _execute(sql, opts) do |conn|
           begin
-            yield(stmt = log_yield(sql){conn.prepare(sql)})
+            yield(stmt = log_connection_yield(sql, conn){conn.prepare(sql)})
           ensure
             stmt.close if stmt
           end
@@ -119,7 +119,7 @@ module Sequel
       
       # Run the given SQL with the given arguments and return the first value of the first row.
       def single_value(sql, opts=OPTS)
-        _execute(sql, opts){|conn| log_yield(sql){conn.first_value_from(sql)}}
+        _execute(sql, opts){|conn| log_connection_yield(sql, conn){conn.first_value_from(sql)}}
       end
       
       private

data/lib/sequel/adapters/cubrid.rb

@@ -38,7 +38,7 @@ module Sequel
       
       def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
-          r = log_yield(sql) do
+          r = log_connection_yield(sql, conn) do
             begin
               conn.query(sql)
             rescue => e
@@ -92,11 +92,11 @@ module Sequel
       private
 
       def begin_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_BEGIN){conn.auto_commit = false}
+        log_connection_yield(TRANSACTION_BEGIN, conn){conn.auto_commit = false}
       end
       
       def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){conn.commit}
+        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
       end
 
       def database_error_classes
@@ -112,7 +112,7 @@ module Sequel
       # This doesn't actually work, as the cubrid ruby driver
       # does not implement transactions correctly.
       def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
       end
     end