sequel 3.48.0 → 4.0.0

data/lib/sequel/adapters/mysql.rb

@@ -151,12 +151,12 @@ module Sequel
       end
 
       # Return the number of matched rows when executing a delete/update statement.
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         execute(sql, opts){|c| return affected_rows(c)}
       end
 
       # Return the last inserted id when executing an insert statement.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         execute(sql, opts){|c| return c.insert_id}
       end
 
@@ -347,7 +347,7 @@ module Sequel
       end
       
       # Set the :type option to :select if it hasn't been set.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         super(sql, {:type=>:select}.merge(opts), &block)
       end
       

data/lib/sequel/adapters/mysql2.rb

@@ -51,12 +51,12 @@ module Sequel
       end
 
       # Return the number of matched rows when executing a delete/update statement.
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         execute(sql, opts){|c| return c.affected_rows}
       end
 
       # Return the last inserted id when executing an insert statement.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         execute(sql, opts){|c| return c.last_id}
       end
 
@@ -155,13 +155,13 @@ module Sequel
       end
 
       # Set the :type option to :select if it hasn't been set.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         super(sql, {:type=>:select}.merge(opts), &block)
       end
 
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
       def literal_string_append(sql, v)
-        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
+        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(v)} << APOS
       end
     end
   end

data/lib/sequel/adapters/odbc.rb

@@ -33,7 +33,7 @@ module Sequel
         c.disconnect
       end
 
-      def execute(sql, opts={})
+      def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
             r = log_yield(sql){conn.run(sql)}
@@ -47,7 +47,7 @@ module Sequel
         end
       end
       
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
             log_yield(sql){conn.do(sql)}
@@ -56,10 +56,6 @@ module Sequel
           end
         end
       end
-      def do(*a, &block)
-        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute_dui')
-        execute_dui(*a, &block)
-      end
 
       private
       

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

@@ -11,7 +11,7 @@ module Sequel
         LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
         
         # Return the last inserted identity value.
-        def execute_insert(sql, opts={})
+        def execute_insert(sql, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             begin
               log_yield(sql){conn.do(sql)}

data/lib/sequel/adapters/openbase.rb

@@ -19,17 +19,13 @@ module Sequel
         c.disconnect
       end
       
-      def execute(sql, opts={})
+      def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           r = log_yield(sql){conn.execute(sql)}
           yield(r) if block_given?
           r
         end
       end
-      def do(*a, &block)
-        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute')
-        execute(*a, &block)
-      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/adapters/oracle.rb

@@ -61,21 +61,17 @@ module Sequel
         nil
       end
 
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         _execute(nil, sql, opts, &block)
       end
-      def do(*a, &block)
-        Sequel::Deprecation.deprecate('Database#do', 'Please use Database#execute')
-        execute_dui(*a, &block)
-      end
 
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         _execute(:insert, sql, opts)
       end
 
       private
 
-      def _execute(type, sql, opts={}, &block)
+      def _execute(type, sql, opts=OPTS, &block)
         synchronize(opts[:server]) do |conn|
           begin
             return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
@@ -214,12 +210,12 @@ module Sequel
         end
       end
 
-      def begin_transaction(conn, opts={})
+      def begin_transaction(conn, opts=OPTS)
         log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
         set_transaction_isolation(conn, opts)
       end
       
-      def commit_transaction(conn, opts={})
+      def commit_transaction(conn, opts=OPTS)
         log_yield(TRANSACTION_COMMIT){conn.commit}
       end
 
@@ -251,11 +247,11 @@ module Sequel
         super
       end
       
-      def rollback_transaction(conn, opts={})
+      def rollback_transaction(conn, opts=OPTS)
         log_yield(TRANSACTION_ROLLBACK){conn.rollback}
       end
 
-      def schema_parse_table(table, opts={})
+      def schema_parse_table(table, opts=OPTS)
         schema, table = schema_and_table(table)
         schema ||= opts[:schema]
         schema_and_table = if ds = opts[:dataset]
@@ -359,17 +355,17 @@ module Sequel
         
         # Run execute_select on the database with the given SQL and the stored
         # bind arguments.
-        def execute(sql, opts={}, &block)
+        def execute(sql, opts=OPTS, &block)
           super(prepared_sql, {: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(prepared_sql, {: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(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
       end
@@ -381,17 +377,17 @@ module Sequel
           
         # Execute the stored prepared statement name and the stored bind
         # arguments instead of the SQL given.
-        def execute(sql, opts={}, &block)
+        def execute(sql, opts=OPTS, &block)
           super(prepared_statement_name, 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(prepared_statement_name, 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(prepared_statement_name, opts, &block)
         end
       end

data/lib/sequel/adapters/postgres.rb

@@ -133,6 +133,9 @@ module Sequel
           disconnect ||= !status_ok
           disconnect ||= e.message =~ DISCONNECT_ERROR_RE
           disconnect ? raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError)) : raise
+        rescue IOError, Errno::EPIPE, Errno::ECONNRESET => e
+          disconnect = true
+          raise(Sequel.convert_exception_class(e, Sequel::DatabaseDisconnectError))
         ensure
           block if status_ok && !disconnect
         end
@@ -270,12 +273,12 @@ module Sequel
       def disconnect_connection(conn)
         begin
           conn.finish
-        rescue PGError
+        rescue PGError, IOError
         end
       end
       
       # Execute the given SQL with the given args on an available connection.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         synchronize(opts[:server]){|conn| check_database_errors{_execute(conn, sql, opts, &block)}}
       end
 
@@ -304,7 +307,7 @@ module Sequel
         # If a block is provided, the method continually yields to the block, one yield
         # per row.  If a block is not provided, a single string is returned with all
         # of the data.
-        def copy_table(table, opts={})
+        def copy_table(table, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             conn.execute(copy_table_sql(table, opts))
             begin
@@ -344,7 +347,7 @@ module Sequel
         #
         # If a block is provided and :data option is not, this will yield to the block repeatedly.
         # The block should return a string, or nil to signal that it is finished.
-        def copy_into(table, opts={})
+        def copy_into(table, opts=OPTS)
           data = opts[:data]
           data = Array(data) if data.is_a?(String)
 
@@ -397,7 +400,7 @@ module Sequel
         # * the channel the notification was sent to (as a string)
         # * the backend pid of the notifier (as an integer),
         # * and the payload of the notification (as a string or nil).
-        def listen(channels, opts={}, &block)
+        def listen(channels, opts=OPTS, &block)
           check_database_errors do
             synchronize(opts[:server]) do |conn|
               begin
@@ -503,7 +506,7 @@ module Sequel
       # deallocate that statement first and then prepare this statement.
       # If a block is given, yield the result, otherwise, return the number
       # of rows changed.
-      def execute_prepared_statement(conn, name, opts={}, &block)
+      def execute_prepared_statement(conn, name, opts=OPTS, &block)
         ps = prepared_statement(name)
         sql = ps.prepared_sql
         ps_name = name.to_s
@@ -613,7 +616,7 @@ module Sequel
       #
       # This is untested with the prepared statement/bound variable support,
       # and unlikely to work with either.
-      def use_cursor(opts={})
+      def use_cursor(opts=OPTS)
         clone(:cursor=>{:rows_per_fetch=>1000}.merge(opts))
       end
 
@@ -636,23 +639,15 @@ module Sequel
 
           private
           
-          # PostgreSQL most of the time requires type information for each of
-          # arguments to a prepared statement.  Handle this by allowing the
-          # named argument to have a __* suffix, with the * being the type.
-          # In the generated SQL, cast the bound argument to that type to
-          # elminate ambiguity (and PostgreSQL from raising an exception).
           def prepared_arg(k)
-            y, type = k.to_s.split("__")
+            y = k
             if i = prepared_args.index(y)
               i += 1
             else
               prepared_args << y
               i = prepared_args.length
             end
-            if type
-              Sequel::Deprecation.deprecate('Specifying prepared statement argument types via the __type suffix', "If a manual cast is really need, surround the prepared statement argument in Sequel.cast")
-            end
-            LiteralString.new("#{prepared_arg_placeholder}#{i}#{"::#{type}" if type}")
+            LiteralString.new("#{prepared_arg_placeholder}#{i}")
           end
 
           # Always assume a prepared argument.
@@ -669,12 +664,12 @@ module Sequel
           private
           
           # Execute the given SQL with the stored bind arguments.
-          def execute(sql, opts={}, &block)
+          def execute(sql, opts=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={}, &block)
+          def execute_dui(sql, opts=OPTS, &block)
             super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
           end
         end
@@ -694,18 +689,18 @@ module Sequel
           
           # Execute the stored prepared statement name and the stored bind
           # arguments instead of the SQL given.
-          def execute(sql, opts={}, &block)
+          def execute(sql, opts=OPTS, &block)
             super(prepared_statement_name, 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(prepared_statement_name, opts, &block)
           end
         end
         
         # Execute the given type of statement with the hash of values.
-        def call(type, bind_vars={}, *values, &block)
+        def call(type, bind_vars=OPTS, *values, &block)
           ps = to_prepared_statement(type, values)
           ps.extend(BindArgumentMethods)
           ps.call(bind_vars, &block)
@@ -776,12 +771,12 @@ module Sequel
       
       # Use the driver's escape_bytea
       def literal_blob_append(sql, v)
-        sql << APOS << db.synchronize{|c| c.escape_bytea(v)} << APOS
+        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape_bytea(v)} << APOS
       end
       
       # Use the driver's escape_string
       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
       
       # For each row in the result set, yield a hash with column name symbol
@@ -800,7 +795,7 @@ module Sequel
   end
 end
 
-if SEQUEL_POSTGRES_USES_PG
+if SEQUEL_POSTGRES_USES_PG && !ENV['NO_SEQUEL_PG']
   begin
     require 'sequel_pg'
   rescue LoadError

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

@@ -14,7 +14,7 @@ module Sequel
         :cubrid
       end
 
-      def indexes(table, opts={})
+      def indexes(table, opts=OPTS)
         m = output_identifier_meth
         m2 = input_identifier_meth
         indexes = {}
@@ -61,11 +61,11 @@ module Sequel
           end
       end
 
-      def tables(opts={})
+      def tables(opts=OPTS)
         _tables('CLASS')
       end
 
-      def views(opts={})
+      def views(opts=OPTS)
         _tables('VCLASS')
       end
 

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

@@ -30,7 +30,7 @@ module Sequel
       alias_method :server_version, :db2_version
 
       # Use SYSIBM.SYSCOLUMNS to get the information on the tables.
-      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])
         metadata_dataset.with_sql("SELECT * FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = #{literal(im.call(table))} ORDER BY COLNO").
@@ -61,7 +61,7 @@ module Sequel
       end
 
       # Use SYSCAT.INDEXES to get the indexes for the table
-      def indexes(table, opts = {})
+      def indexes(table, opts = OPTS)
         m = output_identifier_meth
         indexes = {}
         metadata_dataset.

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

@@ -35,16 +35,16 @@ module Sequel
         self << restart_sequence_sql(*args)
       end
 
-      def sequences(opts={})
+      def sequences(opts=OPTS)
         ds = self[:"rdb$generators"].server(opts[:server]).filter(:"rdb$system_flag" => 0).select(:"rdb$generator_name")
         block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$generator_name"])}
       end
 
-      def tables(opts={})
+      def tables(opts=OPTS)
         tables_or_views(0, opts)
       end
 
-      def views(opts={})
+      def views(opts=OPTS)
         tables_or_views(1, opts)
       end
 
@@ -70,7 +70,7 @@ module Sequel
         AUTO_INCREMENT
       end
       
-      def create_sequence_sql(name, opts={})
+      def create_sequence_sql(name, opts=OPTS)
         "CREATE SEQUENCE #{quote_identifier(name)}"
       end
 
@@ -82,7 +82,7 @@ module Sequel
         create_statements.each{|sql| execute_ddl(sql)}
       end
 
-      def create_table_sql_list(name, generator, options={})
+      def create_table_sql_list(name, generator, options=OPTS)
         statements = [create_table_sql(name, generator, options)]
         drop_seq_statement = nil
         generator.columns.each do |c|
@@ -111,7 +111,7 @@ module Sequel
         [drop_seq_statement, statements]
       end
 
-      def create_trigger_sql(table, name, definition, opts={})
+      def create_trigger_sql(table, name, definition, opts=OPTS)
         events = opts[:events] ? Array(opts[:events]) : [:insert, :update, :delete]
         whence = opts[:after] ? 'AFTER' : 'BEFORE'
         inactive = opts[:inactive] ? 'INACTIVE' : 'ACTIVE'
@@ -133,7 +133,7 @@ module Sequel
         super
       end
 
-      def restart_sequence_sql(name, opts={})
+      def restart_sequence_sql(name, opts=OPTS)
         seq_name = quote_identifier(name)
         "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
       end