sequel 4.21.0 → 4.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd1a779cad72f3c5831e46f1cb9ee5c5fa0cb75a
-  data.tar.gz: 561c34f1d23f0eb77d59e483b2beab3ebed21172
+  metadata.gz: 7bcc145a56d7aca254c6a4298678e07ea3cbd4f0
+  data.tar.gz: 8c90dbb6ef553ddb4995b70f9ac3d0cf03d4dd76
 SHA512:
-  metadata.gz: c3a11392dd6ab72a6af845fe59b85a1bbde7827d27aa255b434129b76034ad1be980a5e45a37a0ea82b0849c1ab4cd2013c108c22f13e898c3d9c6da345d32f6
-  data.tar.gz: 327de977bc6020cd9413bc50d0df32a8432784ee99e9fa277dd74a89f7b6f3e3ef7a89159534bafeeb5b42c99d38f3881d5aee67e5bcb832354f94e8ed7391ef
+  metadata.gz: 5b0214c84c88c09f8c3130a75a1e0f3cacf55584f3f3fc310907cd4e08cfdc39147ea4fca90475917db55ac054bcfc8778ea8df2648b2edff8ca9282f4348c72
+  data.tar.gz: b6efbc0bdd00bd6e5d668960b085e5fd26b6da7fa6592c4621c5f3505d221b1988243af9fbd27ba8075541de6d3a2c24a13c73f36240761416f2c7c7ba10db47

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 4.22.0 (2015-05-01)
+
+* Deprecate the db2, dbi, fdbsql, firebird, jdbc/fdbsql, informix, and openbase adapters (jeremyevans)
+
+* Avoid hash allocations and rehashes (jeremyevans)
+
+* Don't silently ignore :jdbc_properties Database option in jdbc adapter (jeremyevans)
+
+* Make tree plugin set reciprocal association for children association correctly (lpil, jeremyevans) (#995)
+
+* Add Sequel::MassAssignmentRestriction exception, raised for mass assignment errors in strict mode (jeremyevans) (#994)
+
+* Handle ODBC::SQL_BIT type as boolean in the odbc adapter, fixing boolean handling on odbc/mssql (jrgns) (#993)
+
+* Make :auto_validations plugin check :default entry instead of :ruby_default entry for checking existence of default value (jeremyevans) (#990)
+
+* Adapters should now set :default schema option to nil when adapter can determine that the value is nil (jeremyevans)
+
+* Do not add a schema :max_length entry for a varchar(max) column on MSSQL (jeremyevans)
+
+* Allow :default value for PostgreSQL array columns to be a ruby array when using the pg_array extension (jeremyevans) (#989)
+
+* Add csv_serializer plugin for serializing model objects to and from csv (bjmllr, jeremyevans) (#988)
+
+* Make Dataset#to_hash and #to_hash_groups handle single array argument for model datasets (jeremyevans)
+
+* Handle Model#cancel_action in association before hooks (jeremyevans)
+
+* Use a condition variable instead of busy waiting in the threaded connection pools on ruby 1.9+ (jeremyevans)
+
+* Use Symbol#to_proc instead of explicit blocks (jeremyevans)
+
 === 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)

data/README.rdoc

@@ -12,8 +12,7 @@ toolkit for Ruby.
   two-phase commit, transaction isolation, master/slave
   configurations, and database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, CUBRID,
-  DataObjects, DB2, DBI, Firebird, FoundationDB SQL Layer,
-  IBM_DB, Informix, JDBC, MySQL, Mysql2, ODBC, OpenBase, Oracle,
+  DataObjects, IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle,
   PostgreSQL, SQLAnywhere, SQLite3, Swift, and TinyTDS.
 
 == Resources
@@ -466,7 +465,7 @@ to select from a qualified table:
 
 === Identifier aliases
 
-You can also alias identifiers by using the triple undersecore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
+You can also alias identifiers by using the triple underscore special notation <tt>:column___alias</tt> or <tt>:table__column___alias</tt>:
 
   items.literal(:price___p)
   # price AS p
@@ -807,7 +806,7 @@ Sequel models also provide a +subset+ class method that creates a dataset method
 
 You can define a +validate+ method for your model, which +save+
 will check before attempting to save the model in the database.
-If an attribute of the model isn't valid, you should add a error
+If an attribute of the model isn't valid, you should add an error
 message for that attribute to the model object's +errors+. If an
 object has any errors added by the validate method, +save+ will
 raise an error or return false depending on how it is configured

data/doc/opening_databases.rdoc

@@ -154,39 +154,6 @@ cubrid is a ruby extension for accessing a CUBRID database.  Currently,
 the ruby cubrid gem is in fairly rough state, with broken transaction
 support and some other issues, but most things work.
 
-=== db2 
-
-Requires: db2/db2cli
-
-This is the older DB2 adapter.  It's recommended you try the ibmdb adapter
-instead for new DB2 work, as it is better supported.
-
-=== dbi 
-
-Allows access to a multitude of databases via ruby-dbi.  Additional options:
-
-:db_type :: Specifying 'mssql' allows Microsoft SQL Server specific syntax to
-            be used.  Otherwise has no effect.
-
-DBI connection strings are a preprocessed a bit, and are specified with a dbi-
-in front of the protocol.  Examples:
-
-  dbi-ado://...
-  dbi-db2://...
-  dbi-frontbase://...
-  dbi-interbase://...
-  dbi-msql://...
-  dbi-mysql://...
-  dbi-odbc://...
-  dbi-oracle://...
-  dbi-pg://...
-  dbi-proxy://...
-  dbi-sqlite://...
-  dbi-sqlrelay://...
-
-While the DBI adapter does work, it is recommended that you use another adapter
-if your database supports it.
-
 === do 
 
 Requires: data_objects
@@ -206,24 +173,6 @@ Connection string examples:
   do:postgres://user:password@host/database
   do:mysql://user:password@host/database
 
-=== fdbsql
-
-Requires: pg
-
-The following additional options are supported:
-
-:connect_timeout :: Set the number of seconds to wait for a connection (default 20).
-:notice_receiver :: A proc that be called with the PGresult objects that have notice or warning messages.
-                    The default notice receiver just prints the messages to stderr, but this can be used
-                    to handle notice/warning messages differently.
-:sslmode :: Set to 'disable', 'allow', 'prefer', 'require' to choose how to treat SSL.
-
-=== firebird 
-
-Requires: fb (using code at http://github.com/wishdev/fb)
-
-Does not support the :port option.
-
 === ibmdb
 
 requires 'ibm_db'
@@ -231,31 +180,14 @@ requires 'ibm_db'
 This connects to DB2 using IBM_DB.  This is the recommended adapter if you are
 using a C-based ruby to connect to DB2.
 
-=== informix 
-
-Does not support the :host or :port options.  Depending on the configuration of your server
-it may be necessary to either set
-   
-   DB.quote_identifier = false
-
-or set
-
-   export DELIMIDENT=y
-
-in the scripts environment.
-
-The following additional options are supported:
-
-:nolog :: Disable transactions for the database.
- 
 === jdbc 
 
 Requires: java
 
 Houses Sequel's JDBC support when running on JRuby.
-Support for individual database types is done using sub adapters.
+Support for individual database types is done using subadapters.
 There are currently subadapters for PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby,
-Oracle, MSSQL, JTDS, AS400, Progress, Fdbsql, Firebird, Informix, and DB2.
+Oracle, MSSQL, JTDS, AS400, Progress, Firebird, Informix, and DB2.
 For PostgreSQL, MySQL, SQLite, H2, HSQLDB, Derby, and JTDS,
 this can use the jdbc-* gem, for the others you need to have the .jar in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
@@ -291,7 +223,6 @@ Example connection strings:
   jdbc:jdbcprogress:T:hostname:port:database
   jdbc:cubrid:hostname:port:database:::
   jdbc:sqlanywhere://localhost?DBN=Test;UID=user;PWD=password
-  jdbc:fdbsql://localhost:15432/user?user=user&password=password
 
 You can also use JNDI connection strings:
 
@@ -358,10 +289,6 @@ The :host and :port options are not respected. The following additional options
 :drvconnect :: Can be given an ODBC connection string, and will use ODBC::Database#drvconnect to
                do the connection.  Typical usage would be: <tt>Sequel.odbc(:drvconnect=>'driver={...};...')</tt>
 
-=== openbase 
-
-The :port option is ignored.
-
 === oracle 
 
 Requires: oci8
@@ -445,6 +372,14 @@ The following additional options are supported:
 :readonly :: open database in read-only mode
 :timeout :: the busy timeout to use in milliseconds (default: 5000).
 
+Note that SQLite memory databases are restricted to a single connection by
+default.  This is because SQLite does not allow multiple connections to
+a single memory database.  For this reason, Sequel sets the maximum number
+of connections in the connection pool to 1 by default when an SQLite memory
+database is used.  Attempts to force the use of more than 1 connection
+can result in weird behavior, since the connections will be to separate
+memory databases.
+
 === swift
 
 swift is a ruby 1.9+ library, so you'll need to be running ruby 1.9+.  It

data/doc/release_notes/4.22.0.txt

@@ -0,0 +1,72 @@
+= New Features
+
+* A csv_serializer plugin has been added, for serializing model
+  objects and datasets to CSV, or parsing CSV into a model
+  object or array of model objects.  Behavior and API is similar to
+  the existing xml_serializer and json_serializer plugins.
+
+* Sequel::MassAssignmentRestriction is now raised for mass assignment
+  errors in strict mode (the default).  Previously the generic
+  Sequel::Error was used.
+
+= Other Improvements
+
+* On Ruby 1.9+, Sequel now uses condition variables instead of busy
+  waiting for connections in the threaded conection pools.  This
+  can significantly decrease overhead when waiting for connections,
+  which can improve performance on machines that are compute
+  bottlenecked.  This also makes the connection pool checkouts more
+  fair, reducing the chance that a request for a connection will
+  fail with a PoolTimeout when under heavy resource contention.
+ 
+* Sequel now attempts to avoid hash allocations and rehashing in
+  performance sensitive code.  This can speed up Dataset#clone,
+  Model#clone, and #Model#dup by about 60%, and speed up method
+  chains such as:
+
+    ds.select(:a).where(:a=>1).order(1)
+
+  by almost 20%.
+
+* Symbol#to_proc is used instead of explicit blocks across the
+  the library, which should improve performance slightly on Ruby 1.9+.
+
+* When Model#cancel_action is used in association before hooks,
+  Sequel will now return false if raise_on_save_failure = false,
+  instead of raising an exception.  This mirrors the behavior
+  when Model#cancel_action is used inside model save hooks when
+  raise_on_save_failure = false.
+
+* Dataset#to_hash and #to_hash_groups now work correctly on model
+  datasets when given a single array argument.
+
+* The auto_validations plugin now works correctly on columns that
+  have a default value, but where the default value is not parseable
+  into a ruby object by the adapter.
+
+* The tree plugin now correctly sets the reciprocal association
+  in the children association it creates.
+
+* In the pg_array extension, if the :default value when creating a
+  column is set to a ruby array, Sequel will now convert it to a
+  PostgreSQL array.
+
+* Sequel no longer adds a :max_length entry to the schema for
+  varchar(max) columns on Microsoft SQL Server.
+
+* Adapters now are specified to set the :default schema entry for
+  columns to nil if the adapter can determine the :default is nil.
+  Adapters that ship with Sequel already did this, but previously
+  it was unspecified behavior.
+
+* Sequel no longer silently ignores the :jdbc_properties Database
+  option in the jdbc adapter.  Previously, it only used the
+  :jdbc_properties option if it was not able to connect without it.
+
+* Bit types are now converted to boolean values in the ODBC adapter.
+
+= Backwards Compatibility
+
+* The db2, dbi, fdbsql, firebird, jdbc/fdbsql, informix, and openbase
+  adapters are now deprecated and will be removed in a future version
+  of Sequel.

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

@@ -294,7 +294,7 @@ module Sequel
         
         def fetch_ado_schema(type, criteria=[])
           execute_open_ado_schema(type, criteria) do |s|
-            cols = s.Fields.extend(Enumerable).map {|c| c.Name}
+            cols = s.Fields.extend(Enumerable).map(&:Name)
             s.getRows.transpose.each do |r|
               row = {}
               cols.each{|c| row[c] = r.shift}

data/lib/sequel/adapters/cubrid.rb

@@ -6,7 +6,7 @@ module Sequel
      CUBRID_TYPE_PROCS = {
        ::Cubrid::DATE => lambda{|t| Date.new(t.year, t.month, t.day)},
        ::Cubrid::TIME => lambda{|t| SQLTime.create(t.hour, t.min, t.sec)},
-       21 => lambda{|s| s.to_i}
+       21 => lambda(&:to_i)
      }
 
     class Database < Sequel::Database
@@ -31,7 +31,7 @@ module Sequel
       end
 
       def server_version
-        @server_version ||= synchronize{|c| c.server_version}
+        @server_version ||= synchronize(&:server_version)
       end
       
       def execute(sql, opts=OPTS)
@@ -125,7 +125,7 @@ module Sequel
         execute(sql) do |stmt|
           begin
             cols = stmt.column_info.map{|c| [output_identifier(c[COLUMN_INFO_NAME]), CUBRID_TYPE_PROCS[c[COLUMN_INFO_TYPE]]]}
-            @columns = cols.map{|c| c.first}
+            @columns = cols.map(&:first)
             stmt.each do |r|
               row = {}
               cols.zip(r).each{|(k, p), v| row[k] = (v && p) ? p.call(v) : v}

data/lib/sequel/adapters/db2.rb

@@ -1,5 +1,6 @@
 require 'db2/db2cli'
 Sequel.require %w'shared/db2', 'adapters'
+Sequel::Deprecation.deprecate 'The db2 adapter is deprecated and will be removed in a future version of Sequel.  Please switch to the ibmdb adapter.'
 
 module Sequel
   module DB2

data/lib/sequel/adapters/dbi.rb

@@ -1,4 +1,5 @@
 require 'dbi'
+Sequel::Deprecation.deprecate 'The dbi adapter is deprecated and will be removed in a future version of Sequel.  Please switch to another adapter.'
 
 module Sequel
   module DBI

data/lib/sequel/adapters/fdbsql.rb

@@ -2,6 +2,7 @@ require 'pg'
 
 Sequel.require 'adapters/utils/pg_types'
 Sequel.require 'adapters/shared/fdbsql'
+Sequel::Deprecation.deprecate 'The fdbsql adapter is deprecated and will be removed in a future version of Sequel.'
 
 module Sequel
   module Fdbsql
@@ -109,12 +110,12 @@ module Sequel
 
         # Execute the given SQL with the stored bind arguments.
         def execute(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          super(sql, {:arguments=>bind_arguments}.merge!(opts), &block)
         end
 
         # Same as execute, explicit due to intricacies of alias and super.
         def execute_dui(sql, opts=OPTS, &block)
-          super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
+          super(sql, {:arguments=>bind_arguments}.merge!(opts), &block)
         end
       end
 

data/lib/sequel/adapters/firebird.rb

@@ -1,5 +1,6 @@
 require 'fb'
 Sequel.require 'adapters/shared/firebird'
+Sequel::Deprecation.deprecate 'The firebird adapter is deprecated and will be removed in a future version of Sequel.'
 
 module Sequel
   # The Sequel Firebird adapter requires the ruby fb driver located at

data/lib/sequel/adapters/ibmdb.rb

@@ -393,28 +393,8 @@ module Sequel
         end
       end
       
-      # Methods for DB2 prepared statements using the native driver.
-      module PreparedStatementMethods
-        include Sequel::Dataset::UnnumberedArgumentMapper
-        
-        private
-        # Execute the prepared statement with arguments instead of the given SQL.
-        def execute(sql, opts=OPTS, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Execute the prepared statment with arguments instead of the given SQL.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-
-        # Execute the prepared statement with arguments instead of the given SQL.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
+      PreparedStatementMethods = prepared_statements_module(:prepare_bind, Sequel::Dataset::UnnumberedArgumentMapper)
 
-      end
-      
       # Emulate support of bind arguments in called statements.
       def call(type, bind_arguments={}, *values, &block)
         ps = to_prepared_statement(type, values)

data/lib/sequel/adapters/informix.rb

@@ -1,5 +1,6 @@
 require 'informix'
 Sequel.require 'adapters/shared/informix'
+Sequel::Deprecation.deprecate 'The informix adapter is deprecated and will be removed in a future version of Sequel.  Please switch to the ibmdb adapter.'
 
 module Sequel
   module Informix

data/lib/sequel/adapters/jdbc.rb

@@ -204,6 +204,7 @@ module Sequel
           args.concat([opts[:user], opts[:password]]) if opts[:user] && opts[:password]
           begin
             JavaSQL::DriverManager.setLoginTimeout(opts[:login_timeout]) if opts[:login_timeout]
+            raise StandardError, "skipping regular connection" if opts[:jdbc_properties]
             JavaSQL::DriverManager.getConnection(*args)
           rescue JavaSQL::SQLException, NativeException, StandardError => e
             raise e unless driver
@@ -254,7 +255,7 @@ module Sequel
                 log_yield(sql){stmt.execute(sql)}
               when :insert
                 log_yield(sql){execute_statement_insert(stmt, sql)}
-                last_insert_id(conn, opts.merge(:stmt=>stmt))
+                last_insert_id(conn, Hash[opts].merge!(:stmt=>stmt))
               else
                 log_yield(sql){stmt.executeUpdate(sql)}
               end
@@ -267,13 +268,17 @@ module Sequel
       # Execute the given DDL SQL, which should not return any
       # values or rows.
       def execute_ddl(sql, opts=OPTS)
-        execute(sql, {:type=>:ddl}.merge(opts))
+        opts = Hash[opts]
+        opts[:type] = :ddl
+        execute(sql, opts)
       end
       
       # Execute the given INSERT SQL, returning the last inserted
       # row id.
       def execute_insert(sql, opts=OPTS)
-        execute(sql, {:type=>:insert}.merge(opts))
+        opts = Hash[opts]
+        opts[:type] = :insert
+        execute(sql, opts)
       end
 
       # Use the JDBC metadata to get a list of foreign keys for the table.
@@ -434,7 +439,7 @@ module Sequel
                 log_yield(msg, args){cps.execute}
               when :insert
                 log_yield(msg, args){execute_prepared_statement_insert(cps)}
-                last_insert_id(conn, opts.merge(:prepared=>true, :stmt=>cps))
+                last_insert_id(conn, Hash[opts].merge!(:prepared=>true, :stmt=>cps))
               else
                 log_yield(msg, args){cps.executeUpdate}
               end
@@ -666,53 +671,36 @@ module Sequel
 
       Database::DatasetClass = self
       
-      # Use JDBC PreparedStatements instead of emulated ones.  Statements
-      # created using #prepare are cached at the connection level to allow
-      # reuse.  This also supports bind variables by using unnamed
-      # prepared statements created using #call.
-      module PreparedStatementMethods
-        include Sequel::Dataset::UnnumberedArgumentMapper
-        
-        private
-        
-        # Execute the prepared SQL using the stored type and
-        # arguments derived from the hash passed to call.
-        def execute(sql, opts=OPTS, &block)
-          super(self, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(self, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(self, {:arguments=>bind_arguments, :type=>:insert}.merge(opts), &block)
-        end
+      PreparedStatementMethods = prepared_statements_module(
+        "sql = self; opts = Hash[opts]; opts[:arguments] = bind_arguments",
+        Sequel::Dataset::UnnumberedArgumentMapper,
+        %w"execute execute_dui") do
+          private
+
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts=OPTS)
+            sql = self
+            opts = Hash[opts]
+            opts[:arguments] = bind_arguments
+            opts[:type] = :insert
+            super
+          end
       end
       
-      # Use JDBC CallableStatements to execute stored procedures.  Only supported
-      # if the underlying database has stored procedure support.
-      module StoredProcedureMethods
-        include Sequel::Dataset::StoredProcedureMethods
-        
-        private
-        
-        # Execute the database stored procedure with the stored arguments.
-        def execute(sql, opts=OPTS, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts=OPTS, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts=OPTS, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>:insert}.merge(opts), &block)
-        end
+      StoredProcedureMethods = prepared_statements_module(
+        "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
+        Sequel::Dataset::StoredProcedureMethods,
+        %w"execute execute_dui") do
+          private
+
+          # Same as execute, explicit due to intricacies of alias and super.
+          def execute_insert(sql, opts=OPTS)
+            sql = @sproc_name
+            opts = Hash[opts]
+            opts[:args] = @sproc_args
+            opts[:type] = :insert
+            super
+          end
       end
       
       # Whether to convert some Java types to ruby types when retrieving rows.