sequel 3.0.0 → 3.1.0

data/lib/sequel/adapters/ado.rb

@@ -25,10 +25,21 @@ module Sequel
         end
       end
 
+      # Connect to the database. In addition to the usual database options,
+      # the following option has effect:
+      #
+      # * :command_timout - Sets the time in seconds to wait while attempting
+      #     to execute a command before cancelling the attempt and generating
+      #     an error. Specificially, it sets the ADO CommandTimeout property.
+      #     If this property is not set, the default of 30 seconds is used.
+      # * :provider - Sets the Provider of this ADO connection (for example, "SQLOLEDB")
+
       def connect(server)
         opts = server_opts(server)
         s = "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
         handle = WIN32OLE.new('ADODB.Connection')
+        handle.CommandTimeout = opts[:command_timeout] if opts[:command_timeout]
+        handle.Provider = opts[:provider] if opts[:provider]
         handle.Open(s)
         handle
       end

data/lib/sequel/adapters/amalgalite.rb

@@ -119,26 +119,6 @@ module Sequel
         _execute(sql, opts){|conn| conn.first_value_from(sql)}
       end
       
-      # Use the native driver transaction method if there isn't already a transaction
-      # in progress on the connection, always yielding a connection inside a transaction
-      # transaction.
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if conn.in_transaction?
-          begin
-            result = nil
-            log_info('Transaction.begin')
-            conn.transaction{result = yield(conn)}
-            result
-          rescue ::Exception => e
-            log_info('Transaction.rollback')
-            transaction_error(e, ::Amalgalite::Error, ::Amalgalite::SQLite3::Error)
-          ensure
-            log_info('Transaction.commit') unless e
-          end
-        end
-      end
-      
       private
       
       # Log the SQL and yield an available connection.  Rescue
@@ -162,6 +142,11 @@ module Sequel
         o[:max_connections] = 1 if @opts[:database] == ':memory:' || blank_object?(@opts[:database])
         o
       end
+      
+      # Both main error classes that Amalgalite raises
+      def database_error_classes
+        [::Amalgalite::Error, ::Amalgalite::SQLite3::Error]
+      end
 
       # Disconnect given connections from the database.
       def disconnect_connection(c)

data/lib/sequel/adapters/do.rb

@@ -116,37 +116,6 @@ module Sequel
         uri.split(":").first
       end
       
-      # Use DataObject's transaction support for transactions.  This
-      # only supports single level transactions, and it always prepares
-      # transactions and commits them immediately after.  It's wasteful,
-      # but required by DataObject's API.
-      def transaction(opts={})
-        th = Thread.current
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(th)
-          t = ::DataObjects::Transaction.create_for_uri(uri)
-          t.instance_variable_get(:@connection).close
-          t.instance_variable_set(:@connection, conn)
-          begin
-            log_info("Transaction.begin")
-            t.begin
-            @transactions << th
-            yield(conn)
-          rescue Exception => e
-            log_info("Transaction.rollback")
-            t.rollback
-            transaction_error(e)
-          ensure
-            unless e
-              log_info("Transaction.commit")
-              t.prepare
-              t.commit 
-            end
-            @transactions.delete(th)
-          end
-        end
-      end
-      
       # Return the DataObjects URI for the Sequel URI, removing the do:
       # prefix.
       def uri(opts={})
@@ -155,22 +124,61 @@ module Sequel
       end
 
       private
+      
+      # DataObjects uses a special transaction object to keep track of
+      # transactions.  Unfortunately, it tries to create a new connection
+      # to do a transaction.  So we close the connection created and
+      # substitute our own.
+      def begin_transaction(conn)
+        log_info(TRANSACTION_BEGIN)
+        t = ::DataObjects::Transaction.create_for_uri(uri)
+        t.instance_variable_get(:@connection).close
+        t.instance_variable_set(:@connection, conn)
+        t.begin
+        t
+      end
+      
+      # DataObjects requires transactions be prepared before being
+      # committed, so we do that.
+      def commit_transaction(t)
+        log_info(TRANSACTION_ROLLBACK)
+        t.prepare
+        t.commit 
+      end
+      
+      # Method to call on a statement object to execute SQL that does
+      # not return any rows.
+      def connection_execute_method
+        :execute_non_query
+      end
+      
+      # The DataObjects adapter should convert exceptions by default.
+      def connection_pool_default_options
+        super.merge(:pool_convert_exceptions=>false)
+      end
 
       # Close the given database connection.
       def disconnect_connection(c)
         c.close
       end
       
+      # Execute SQL on the connection by creating a command first
+      def log_connection_execute(conn, sql)
+        log_info(sql)
+        conn.create_command(sql).execute_non_query
+      end
+      
+      # We use the transactions rollback method to rollback.
+      def rollback_transaction(t)
+        log_info(TRANSACTION_COMMIT)
+        t.rollback
+      end
+      
       # Allow extending the given connection when it is first created.
       # By default, just returns the connection.
       def setup_connection(conn)
         conn
       end
-      
-      # The DataObjects adapter should convert exceptions by default.
-      def connection_pool_default_options
-        super.merge(:pool_convert_exceptions=>false)
-      end
     end
     
     # Dataset class for Sequel::DataObjects::Database objects.

data/lib/sequel/adapters/firebird.rb

@@ -31,26 +31,6 @@ module Sequel
         conn
       end
 
-      # Creates a table with the columns given in the provided block:
-      #
-      #   DB.create_table :posts do
-      #     primary_key :id, :serial
-      #     column :title, :text
-      #     column :content, :text
-      #     index :title
-      #   end
-      #
-      # See Schema::Generator.
-      # Firebird gets an override because of the mess of creating a
-      # generator for auto-incrementing primary keys.
-      def create_table(name, options={}, &block)
-        options = {:generator=>options} if options.is_a?(Schema::Generator)
-        generator = options[:generator] || Schema::Generator.new(self, &block)
-        drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
-        (create_statements + index_sql_list(name, generator.indexes)).each{|sql| execute_ddl(sql)}
-      end
-
       def create_trigger(*args)
         self << create_trigger_sql(*args)
       end
@@ -103,28 +83,6 @@ module Sequel
         block_given? ? yield(ds) : ds.map{|r| ds.send(:output_identifier, r[:"rdb$relation_name"])}
       end
 
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(Thread.current)
-          log_info("Transaction.begin")
-          conn.transaction
-          begin
-            @transactions << Thread.current
-            yield(conn)
-          rescue ::Exception => e
-            log_info("Transaction.rollback")
-            conn.rollback
-            transaction_error(e, Fb::Error)
-          ensure
-            unless e
-              log_info("Transaction.commit")
-              conn.commit
-            end
-            @transactions.delete(Thread.current)
-          end
-        end
-      end
-
       private
 
       # Use Firebird specific syntax for add column
@@ -147,10 +105,29 @@ module Sequel
         AUTO_INCREMENT
       end
       
+      def begin_transaction(conn)
+        log_info(TRANSACTION_BEGIN)
+        conn.transaction
+        conn
+      end
+
+      def commit_transaction(conn)
+        log_info(TRANSACTION_COMMIT)
+        conn.commit
+      end
+      
       def create_sequence_sql(name, opts={})
         "CREATE SEQUENCE #{quote_identifier(name)}"
       end
 
+      # Firebird gets an override because of the mess of creating a
+      # sequence and trigger for auto-incrementing primary keys.
+      def create_table_from_generator(name, generator, options)
+        drop_statement, create_statements = create_table_sql_list(name, generator, options)
+        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        create_statements.each{|sql| execute_ddl(sql)}
+      end
+
       def create_table_sql_list(name, generator, options={})
         statements = [create_table_sql(name, generator, options)]
         drop_seq_statement = nil
@@ -192,6 +169,10 @@ module Sequel
         end_sql
         sql
       end
+      
+      def database_error_classes
+        [Fb::Error]
+      end
 
       def disconnect_connection(c)
         c.close
@@ -205,9 +186,14 @@ module Sequel
         seq_name = quote_identifier(name)
         "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
       end
+      
+      def rollback_transaction(conn)
+        log_info(TRANSACTION_ROLLBACK)
+        conn.rollback
+      end
 
       def type_literal_generic_string(column)
-        column[:text] ? :"BLOB SUBTYPE TEXT" : super
+        column[:text] ? :"BLOB SUB_TYPE TEXT" : super
       end
     end
 

data/lib/sequel/adapters/jdbc.rb

@@ -209,33 +209,6 @@ module Sequel
         ts
       end
       
-      # Default transaction method that should work on most JDBC
-      # databases.  Does not use the JDBC transaction methods, uses
-      # SQL BEGIN/ROLLBACK/COMMIT statements instead.
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(Thread.current)
-          stmt = conn.createStatement
-          begin
-            log_info(begin_transaction_sql)
-            stmt.execute(begin_transaction_sql)
-            @transactions << Thread.current
-            yield(conn)
-          rescue Exception => e
-            log_info(rollback_transaction_sql)
-            stmt.execute(rollback_transaction_sql)
-            transaction_error(e)
-          ensure
-            unless e
-              log_info(commit_transaction_sql)
-              stmt.execute(commit_transaction_sql)
-            end
-            stmt.close
-            @transactions.delete(Thread.current)
-          end
-        end
-      end
-      
       # The uri for this connection.  You can specify the uri
       # using the :uri, :url, or :database options.  You don't
       # need to worry about this if you use Sequel.connect
@@ -248,6 +221,12 @@ module Sequel
       
       private
       
+      # JDBC uses a statement object to execute SQL on the database
+      def begin_transaction(conn)
+        conn = conn.createStatement
+        super
+      end
+      
       # The JDBC adapter should not need the pool to convert exceptions.
       def connection_pool_default_options
         super.merge(:pool_convert_exceptions=>false)
@@ -323,6 +302,12 @@ module Sequel
         synchronize{|c| metadata_dataset.send(:process_result_set, c.getMetaData.send(*args), &block)}
       end
       
+      # Close the given statement when removing the transaction
+      def remove_transaction(stmt)
+        stmt.close if stmt
+        super
+      end
+      
       # Java being java, you need to specify the type of each argument
       # for the prepared statement, and bind it individually.  This
       # guesses which JDBC method to use, and hopefully JRuby will convert
@@ -372,6 +357,11 @@ module Sequel
         end
         ts
       end
+      
+      # Create a statement object to execute transaction statements.
+      def transaction_statement_object(conn)
+        conn.createStatement
+      end
     end
     
     class Dataset < Sequel::Dataset

data/lib/sequel/adapters/mysql.rb

@@ -55,6 +55,9 @@ module Sequel
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
       
+      # Mysql::Error messages that indicate the current connection should be disconnected
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\ACommands out of sync; you can't run this command now\z/
+      
       set_adapter_scheme :mysql
       
       # Support stored procedures on MySQL
@@ -101,8 +104,7 @@ module Sequel
 
         # By default, MySQL 'where id is null' selects the last inserted id
         conn.query("set SQL_AUTO_IS_NULL=0") unless opts[:auto_is_null]
-
-        conn.query_with_result = false
+        
         class << conn
           attr_accessor :prepared_statements
         end
@@ -132,29 +134,6 @@ module Sequel
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
       end
-      
-      # Support single level transactions on MySQL.
-      def transaction(opts={})
-        synchronize(opts[:server]) do |conn|
-          return yield(conn) if @transactions.include?(Thread.current)
-          log_info(begin_transaction_sql)
-          conn.query(begin_transaction_sql)
-          begin
-            @transactions << Thread.current
-            yield(conn)
-          rescue ::Exception => e
-            log_info(rollback_transaction_sql)
-            conn.query(rollback_transaction_sql)
-            transaction_error(e, Mysql::Error)
-          ensure
-            unless e
-              log_info(commit_transaction_sql)
-              conn.query(commit_transaction_sql)
-            end
-            @transactions.delete(Thread.current)
-          end
-        end
-      end
 
       private
       
@@ -162,33 +141,49 @@ module Sequel
       # option is :select, yield the result of the query, otherwise
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
-        log_info(sql)
-        conn.query(sql)
-        if opts[:type] == :select
-          loop do
-            begin
-              r = conn.use_result
-            rescue Mysql::Error
-              nil
-            else
-              begin
-                yield r
-              ensure
+        begin
+          log_info(sql)
+          r = conn.query(sql)
+          if opts[:type] == :select
+            yield r if r
+            if conn.respond_to?(:next_result) && conn.next_result
+              loop do
                 r.free
+                r = nil
+                begin
+                  r = conn.use_result
+                rescue Mysql::Error
+                  break
+                end
+                yield r
+                break unless conn.next_result
               end
             end
-            break unless conn.respond_to?(:next_result) && conn.next_result
+          else
+            yield conn if block_given?
           end
-        else
-          yield conn if block_given?
+        rescue Mysql::Error => e
+          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+        ensure
+          r.free if r
         end
       end
       
+      # MySQL connections use the query method to execute SQL without a result
+      def connection_execute_method
+        :query
+      end
+      
       # MySQL doesn't need the connection pool to convert exceptions.
       def connection_pool_default_options
         super.merge(:pool_convert_exceptions=>false)
       end
       
+      # The MySQL adapter main error class is Mysql::Error
+      def database_error_classes
+        [Mysql::Error]
+      end
+      
       # The database name when using the native adapter is always stored in
       # the :database option.
       def database_name