sequel 3.48.0 → 4.0.0

data/lib/sequel/adapters/ibmdb.rb

@@ -210,7 +210,7 @@ module Sequel
       end
 
       # Execute the given SQL on the database.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         if sql.is_a?(Symbol)
           execute_prepared_statement(sql, opts, &block)
         else
@@ -222,7 +222,7 @@ module Sequel
 
       # Execute the given SQL on the database, returning the last inserted
       # identity value.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         synchronize(opts[:server]) do |c|
           if sql.is_a?(Symbol)
             execute_prepared_statement(sql, opts)
@@ -304,14 +304,14 @@ module Sequel
 
       # IBM_DB uses an autocommit setting instead of sending SQL queries.
       # So starting a transaction just turns autocommit off.
-      def begin_transaction(conn, opts={})
+      def begin_transaction(conn, opts=OPTS)
         log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
         set_transaction_isolation(conn, opts)
       end
 
       # This commits transaction in progress on the
       # connection and sets autocommit back on.
-      def commit_transaction(conn, opts={})
+      def commit_transaction(conn, opts=OPTS)
         log_yield(TRANSACTION_COMMIT){conn.commit}
       end
     
@@ -355,7 +355,7 @@ module Sequel
 
       # This rolls back the transaction in progress on the
       # connection and sets autocommit back on.
-      def rollback_transaction(conn, opts={})
+      def rollback_transaction(conn, opts=OPTS)
         log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
 
@@ -392,17 +392,17 @@ module Sequel
         
         private
         # Execute the prepared statement with arguments instead of the given SQL.
-        def execute(sql, opts={}, &block)
+        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={}, &block)
+        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={}, &block)
+        def execute_insert(sql, opts=OPTS, &block)
           super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
         end
 

data/lib/sequel/adapters/informix.rb

@@ -14,21 +14,13 @@ module Sequel
       end
     
       # Returns number of rows affected
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]){|c| log_yield(sql){c.immediate(sql)}}
       end
-      def do(*a, &block)
-        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute_dui')
-        execute_dui(*a, &block)
-      end
       
-      def execute(sql, opts={})
+      def execute(sql, opts=OPTS)
         synchronize(opts[:server]){|c| yield log_yield(sql){c.cursor(sql)}}
       end
-      def query(*a, &block)
-        Sequel::Deprecation.deprecate('Database#query', 'Please use Database#execute')
-        execute(*a, &block)
-      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/adapters/jdbc.rb

@@ -179,7 +179,7 @@ module Sequel
 
       # Execute the given stored procedure with the give name. If a block is
       # given, the stored procedure should return rows.
-      def call_sproc(name, opts = {})
+      def call_sproc(name, opts = OPTS)
         args = opts[:args] || []
         sql = "{call #{name}(#{args.map{'?'}.join(',')})}"
         synchronize(opts[:server]) do |conn|
@@ -252,7 +252,7 @@ module Sequel
       
       # Execute the given SQL.  If a block is given, if should be a SELECT
       # statement or something else that returns rows.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         return call_sproc(sql, opts, &block) if opts[:sproc]
         return execute_prepared_statement(sql, opts, &block) if [Symbol, Dataset].any?{|c| sql.is_a?(c)}
         synchronize(opts[:server]) do |conn|
@@ -277,18 +277,18 @@ module Sequel
 
       # Execute the given DDL SQL, which should not return any
       # values or rows.
-      def execute_ddl(sql, opts={})
+      def execute_ddl(sql, opts=OPTS)
         execute(sql, {:type=>:ddl}.merge(opts))
       end
       
       # Execute the given INSERT SQL, returning the last inserted
       # row id.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         execute(sql, {:type=>:insert}.merge(opts))
       end
       
       # Use the JDBC metadata to get the index information for the table.
-      def indexes(table, opts={})
+      def indexes(table, opts=OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
         schema, table = schema_and_table(table)
@@ -311,7 +311,7 @@ module Sequel
       end
       
       # All tables in this database
-      def tables(opts={})
+      def tables(opts=OPTS)
         get_tables('TABLE', opts)
       end
       
@@ -319,14 +319,14 @@ module Sequel
       # using the :uri, :url, or :database options.  You don't
       # need to worry about this if you use Sequel.connect
       # with the JDBC connectrion strings.
-      def uri(opts={})
+      def uri(opts=OPTS)
         opts = @opts.merge(opts)
         ur = opts[:uri] || opts[:url] || opts[:database]
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
 
       # All views in this database
-      def views(opts={})
+      def views(opts=OPTS)
         get_tables('VIEW', opts)
       end
 
@@ -387,7 +387,7 @@ module Sequel
       # statement, use that statement instead of creating another.
       # Otherwise, prepare a new statement for the connection, bind the
       # variables, and execute it.
-      def execute_prepared_statement(name, opts={})
+      def execute_prepared_statement(name, opts=OPTS)
         args = opts[:arguments]
         if name.is_a?(Dataset)
           ps = name
@@ -561,7 +561,7 @@ module Sequel
       end
       
       # Parse the table schema for the given table.
-      def schema_parse_table(table, opts={})
+      def schema_parse_table(table, opts=OPTS)
         m = output_identifier_meth(opts[:dataset])
         im = input_identifier_meth(opts[:dataset])
         ds = dataset
@@ -585,7 +585,7 @@ module Sequel
           ts << [m.call(h[:column_name]), s]
         end
         if schemas.length > 1
-          Sequel::Deprecation.deprecate('Schema parsing in the jdbc adapter resulted in columns being returned for a table with the same name in multiple schemas.  This will raise an Error starting in Sequel 4.  Please explicitly qualify your table with a schema.')
+          raise Error, 'Schema parsing in the jdbc adapter resulted in columns being returned for a table with the same name in multiple schemas.  Please explicitly qualify your table with a schema.'
         end
         ts
       end
@@ -623,17 +623,17 @@ module Sequel
         
         # Execute the prepared SQL using the stored type and
         # arguments derived from the hash passed to call.
-        def execute(sql, opts={}, &block)
+        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={}, &block)
+        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={}, &block)
+        def execute_insert(sql, opts=OPTS, &block)
           super(self, {:arguments=>bind_arguments, :type=>:insert}.merge(opts), &block)
         end
       end
@@ -646,17 +646,17 @@ module Sequel
         private
         
         # Execute the database stored procedure with the stored arguments.
-        def execute(sql, opts={}, &block)
+        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={}, &block)
+        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={}, &block)
+        def execute_insert(sql, opts=OPTS, &block)
           super(@sproc_name, {:args=>@sproc_args, :sproc=>true, :type=>:insert}.merge(opts), &block)
         end
       end

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

@@ -20,7 +20,7 @@ module Sequel
         end
 
         # TODO: Fix for AS400
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           nil
         end
 
@@ -32,7 +32,7 @@ module Sequel
         private
 
         # Use JDBC connection's setAutoCommit to false to start transactions
-        def begin_transaction(conn, opts={})
+        def begin_transaction(conn, opts=OPTS)
           set_transaction_isolation(conn, opts)
           super
         end

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

@@ -16,7 +16,7 @@ module Sequel
         private
         
         # Get the last inserted id using LAST_INSERT_ID().
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           if stmt = opts[:stmt]
             rs = stmt.getGeneratedKeys
             begin

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

@@ -38,7 +38,7 @@ module Sequel
           end
         end
         
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = IDENTITY_VAL_LOCAL
             rs = log_yield(sql){stmt.executeQuery(sql)}

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

@@ -117,7 +117,7 @@ module Sequel
         end
 
         # Use IDENTITY_VAL_LOCAL() to get the last inserted id.
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'SELECT IDENTITY_VAL_LOCAL() FROM sysibm.sysdummy1'
             rs = log_yield(sql){stmt.executeQuery(sql)}

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

@@ -48,7 +48,7 @@ module Sequel
         
         # If the :prepare option is given and we aren't in a savepoint,
         # prepare the transaction for a two-phase commit.
-        def commit_transaction(conn, opts={})
+        def commit_transaction(conn, opts=OPTS)
           if (s = opts[:prepare]) && _trans(conn)[:savepoint_level] <= 1
             log_connection_execute(conn, "PREPARE COMMIT #{s}")
           else
@@ -115,7 +115,7 @@ module Sequel
         end
 
         # Use IDENTITY() to get the last inserted id.
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'SELECT IDENTITY();'
             rs = log_yield(sql){stmt.executeQuery(sql)}

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

@@ -65,7 +65,7 @@ module Sequel
         end
 
         # Use IDENTITY() to get the last inserted id.
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'CALL IDENTITY()'
             rs = log_yield(sql){stmt.executeQuery(sql)}

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

@@ -13,7 +13,7 @@ module Sequel
         private
         
         # TODO: implement
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           nil
         end
       end

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

@@ -22,7 +22,7 @@ module Sequel
         private
         
         # Get the last inserted id using SCOPE_IDENTITY().
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
             rs = log_yield(sql){stmt.executeQuery(sql)}
@@ -33,7 +33,7 @@ module Sequel
         
         # Call the generic JDBC version instead of MSSQL version,
         # since the JDBC version handles primary keys.
-        def schema_parse_table(table, opts={})
+        def schema_parse_table(table, opts=OPTS)
           jdbc_schema_parse_table(table, opts)
         end
         

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

@@ -27,7 +27,7 @@ module Sequel
         end
 
         # Get the last inserted id using LAST_INSERT_ID().
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           if stmt = opts[:stmt]
             rs = stmt.getGeneratedKeys
             begin

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

@@ -27,6 +27,10 @@ module Sequel
           false
         end
 
+        def disconnect_error?(exception, opts)
+          super || exception.message =~ /\AClosed Connection/
+        end
+
         def last_insert_id(conn, opts)
           unless sequence = opts[:sequence]
             if t = opts[:table]
@@ -105,7 +109,7 @@ module Sequel
         end
       
         def convert_type_oracle_timestamptz(v)
-          convert_type_oracle_timestamp(db.synchronize{|c| v.timestampValue(c)})
+          convert_type_oracle_timestamp(db.synchronize(@opts[:server]){|c| v.timestampValue(c)})
         end
       
         def convert_type_proc(v)

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

@@ -21,7 +21,7 @@ module Sequel
         end
 
         # See Sequel::Postgres::Adapter#copy_into
-        def copy_into(table, opts={})
+        def copy_into(table, opts=OPTS)
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
@@ -58,7 +58,7 @@ module Sequel
         end
         
         # See Sequel::Postgres::Adapter#copy_table
-        def copy_table(table, opts={})
+        def copy_table(table, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             copy_manager = org.postgresql.copy.CopyManager.new(conn)
             copier = copy_manager.copy_out(copy_table_sql(table, opts))
@@ -181,7 +181,7 @@ module Sequel
         
         # Literalize strings similar to the native postgres adapter
         def literal_string_append(sql, v)
-          sql << APOS << db.synchronize{|c| c.escape_string(v)} << APOS
+          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << APOS
         end
       end
     end

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

@@ -13,7 +13,7 @@ module Sequel
         
         # Swallow pointless exceptions when the foreign key list pragma
         # doesn't return any rows.
-        def foreign_key_list(table, opts={})
+        def foreign_key_list(table, opts=OPTS)
           super
         rescue Sequel::DatabaseError => e
           raise unless e.message =~ FOREIGN_KEY_ERROR_RE
@@ -22,7 +22,7 @@ module Sequel
 
         # Swallow pointless exceptions when the index list pragma
         # doesn't return any rows.
-        def indexes(table, opts={})
+        def indexes(table, opts=OPTS)
           super
         rescue Sequel::DatabaseError => e
           raise unless e.message =~ FOREIGN_KEY_ERROR_RE
@@ -37,7 +37,7 @@ module Sequel
         end
 
         # Use last_insert_rowid() to get the last inserted id.
-        def last_insert_id(conn, opts={})
+        def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             rs = stmt.executeQuery(LAST_INSERT_ROWID)
             rs.next

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

@@ -44,7 +44,7 @@ module Sequel
       end
 
       # Use JDBC connection's setAutoCommit to false to start transactions
-      def begin_transaction(conn, opts={})
+      def begin_transaction(conn, opts=OPTS)
         if supports_savepoints?
           th = _trans(conn)
           if sps = th[:savepoints]
@@ -62,7 +62,7 @@ module Sequel
       end
       
       # Use JDBC connection's commit method to commit transactions
-      def commit_transaction(conn, opts={})
+      def commit_transaction(conn, opts=OPTS)
         if supports_savepoints?
           sps = _trans(conn)[:savepoints]
           if sps.empty?
@@ -92,7 +92,7 @@ module Sequel
       end
       
       # Use JDBC connection's rollback method to rollback transactions
-      def rollback_transaction(conn, opts={})
+      def rollback_transaction(conn, opts=OPTS)
         if supports_savepoints?
           sps = _trans(conn)[:savepoints]
           if sps.empty?

data/lib/sequel/adapters/mock.rb

@@ -142,18 +142,18 @@ module Sequel
       # Store the sql used for later retrieval with #sqls, and return
       # the appropriate value using either the #autoid, #fetch, or
       # #numrows methods.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         synchronize(opts[:server]){|c| _execute(c, sql, opts, &block)} 
       end
       alias execute_ddl execute
 
       # Store the sql used, and return the value of the #numrows method.
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         execute(sql, opts.merge(:meth=>:numrows))
       end
 
       # Store the sql used, and return the value of the #autoid method.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         execute(sql, opts.merge(:meth=>:autoid))
       end
 
@@ -186,7 +186,7 @@ module Sequel
         end
       end
 
-      def _execute(c, sql, opts={}, &block)
+      def _execute(c, sql, opts=OPTS, &block)
         sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
         sql += " -- #{@opts[:append]}" if @opts[:append]
         sql += " -- #{c.server.is_a?(Symbol) ? c.server : c.server.inspect}" if c.server != :default
@@ -362,15 +362,15 @@ module Sequel
 
       private
 
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         super(sql, opts.merge(:dataset=>self), &block)
       end
 
-      def execute_dui(sql, opts={}, &block)
+      def execute_dui(sql, opts=OPTS, &block)
         super(sql, opts.merge(:dataset=>self), &block)
       end
 
-      def execute_insert(sql, opts={}, &block)
+      def execute_insert(sql, opts=OPTS, &block)
         super(sql, opts.merge(:dataset=>self), &block)
       end
     end