sequel 3.0.0 → 3.1.0

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

@@ -1,8 +1,10 @@
-Sequel.require 'adapters/utils/unsupported'
+Sequel.require %w'savepoint_transactions unsupported', 'adapters/utils'
 
 module Sequel
   module SQLite
     module DatabaseMethods
+      include Sequel::Database::SavepointTransactions
+
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
@@ -199,7 +201,7 @@ module Sequel
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
           row[:primary_key] = row.delete(:pk).to_i == 1
-          row[:default] = nil if blank_object?(row[:default])
+          row[:default] = nil if blank_object?(row[:default]) || row[:default] == 'NULL'
           row[:db_type] = row.delete(:type)
           row[:type] = schema_column_type(row[:db_type])
           row
@@ -264,7 +266,7 @@ module Sequel
       # Allow inserting of values directly from a dataset.
       def insert_sql(*values)
         if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
-          "INSERT INTO #{source_list(@opts[:from])} #{values.first.sql};"
+          "#{insert_sql_base}#{source_list(@opts[:from])} #{values.first.sql};"
         else
           super(*values)
         end

data/lib/sequel/adapters/sqlite.rb

@@ -83,26 +83,6 @@ module Sequel
         _execute(sql, opts){|conn| conn.get_first_value(sql, opts[:arguments])}
       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.transaction_active?
-          begin
-            result = nil
-            log_info('Transaction.begin')
-            conn.transaction{result = yield(conn)}
-            result
-          rescue ::Exception => e
-            log_info('Transaction.rollback')
-            transaction_error(e, SQLite3::Exception)
-          ensure
-            log_info('Transaction.commit') unless e
-          end
-        end
-      end
-      
       private
       
       # Log the SQL and the arguments, and yield an available connection.  Rescue
@@ -126,6 +106,11 @@ module Sequel
         o[:max_connections] = 1 if @opts[:database] == ':memory:' || blank_object?(@opts[:database])
         o
       end
+      
+      # The main error class that SQLite3 raises
+      def database_error_classes
+        [SQLite3::Exception]
+      end
 
       # Disconnect given connections from the database.
       def disconnect_connection(c)

data/lib/sequel/adapters/utils/savepoint_transactions.rb

@@ -0,0 +1,80 @@
+# Module included in adapters that support savepoints, currently MySQL and PostgreSQL.
+module Sequel
+  class Database
+    module SavepointTransactions
+      SQL_SAVEPOINT = 'SAVEPOINT autopoint_%d'.freeze
+      SQL_ROLLBACK_TO_SAVEPOINT = 'ROLLBACK TO SAVEPOINT autopoint_%d'.freeze
+      SQL_RELEASE_SAVEPOINT = 'RELEASE SAVEPOINT autopoint_%d'.freeze
+      
+      # Any adapter that includes this module must support savepoints.
+      def supports_savepoints?
+        true
+      end
+      
+      private
+      
+      # Don't add the current thread to the list of threads with active
+      # connections if it is already in the list.  If there isn't an
+      # active transaction on this thread, set the transaction depth to
+      # zero.
+      def add_transaction
+        th = Thread.current
+        unless @transactions.include?(th)
+          th[:sequel_transaction_depth] = 0
+          super
+        end
+      end
+      
+      # If a savepoint is requested, don't reuse an existing transaction
+      def already_in_transaction?(conn, opts)
+        super and !opts[:savepoint]
+      end
+      
+      # SQL to start a new savepoint
+      def begin_savepoint_sql(depth)
+        SQL_SAVEPOINT % depth
+      end
+      
+      # If there is no active transaction, start a new transaction. Otherwise,
+      # start a savepoint inside the current transaction.  Increment the 
+      def begin_transaction(conn)
+        th = Thread.current
+        depth = th[:sequel_transaction_depth]
+        conn = transaction_statement_object(conn) if respond_to?(:transaction_statement_object, true)
+        log_connection_execute(conn, depth > 0 ? begin_savepoint_sql(depth) : begin_transaction_sql)
+        th[:sequel_transaction_depth] += 1
+        conn
+      end
+      
+      # SQL to commit a savepoint
+      def commit_savepoint_sql(depth)
+        SQL_RELEASE_SAVEPOINT % depth
+      end
+      
+      # If currently inside a savepoint, commit/release the savepoint.
+      # Otherwise, commit the transaction.
+      def commit_transaction(conn)
+        depth = Thread.current[:sequel_transaction_depth]
+        log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
+      end
+      
+      # Decrement the current savepoint/transaction depth
+      def remove_transaction(conn)
+        depth = (Thread.current[:sequel_transaction_depth] -= 1)
+        super unless depth > 0
+      end
+      
+      # SQL to rollback to a savepoint
+      def rollback_savepoint_sql(depth)
+        SQL_ROLLBACK_TO_SAVEPOINT % depth
+      end
+      
+      # If currently inside a savepoint, rollback to the start of the savepoint.
+      # Otherwise, rollback the entire transaction.
+      def rollback_transaction(conn)
+        depth = Thread.current[:sequel_transaction_depth]
+        log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
+      end
+    end
+  end
+end

data/lib/sequel/adapters/utils/unsupported.rb

@@ -11,18 +11,6 @@ class Sequel::Dataset
     def intersect(ds, all=false)
       raise(Sequel::Error, "INTERSECT not supported")
     end
-    
-    private
-    
-    # Since EXCEPT and INTERSECT are not supported, and order shouldn't matter
-    # when UNION is used, don't worry about parantheses.  This may potentially
-    # give incorrect results if UNION ALL is used.
-    def select_compounds_sql(sql)
-      return unless @opts[:compounds]
-      @opts[:compounds].each do |type, dataset, all|
-        sql << " #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)}"
-      end
-    end
   end
 
   # This module should be included in the dataset class for all databases that

data/lib/sequel/core.rb

@@ -118,6 +118,15 @@ module Sequel
     Database.quote_identifiers = value
   end
 
+  # Load all Sequel extensions given.  Only loads extensions included in this
+  # release of Sequel, doesn't load external extensions.
+  #
+  #   Sequel.extension(:schema_dumper)
+  #   Sequel.extension(:pagination, :query)
+  def self.extension(*extensions)
+    require(extensions, 'extensions')
+  end
+
   # Require all given files which should be in the same or a subdirectory of
   # this file.  If a subdir is given, assume all files are in that subdir.
   def self.require(files, subdir=nil)
@@ -139,7 +148,7 @@ module Sequel
     begin
       Date.parse(s, Sequel.convert_two_digit_years)
     rescue => e
-      raise InvalidValue, "Invalid Date value '#{self}' (#{e.message})"
+      raise InvalidValue, "Invalid Date value #{s.inspect} (#{e.message})"
     end
   end
 
@@ -153,7 +162,7 @@ module Sequel
         datetime_class.parse(s)
       end
     rescue => e
-      raise InvalidValue, "Invalid #{datetime_class} value '#{self}' (#{e.message})"
+      raise InvalidValue, "Invalid #{datetime_class} value #{s.inspect} (#{e.message})"
     end
   end
 
@@ -162,7 +171,7 @@ module Sequel
     begin
       Time.parse(s)
     rescue => e
-      raise InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
+      raise InvalidValue, "Invalid Time value #{s.inspect} (#{e.message})"
     end
   end
 

data/lib/sequel/core_sql.rb

@@ -210,6 +210,7 @@ class Symbol
   include Sequel::SQL::BooleanMethods
   include Sequel::SQL::NumericMethods
   include Sequel::SQL::StringMethods
+  include Sequel::SQL::SubscriptMethods
   include Sequel::SQL::ComplexExpressionMethods
   include Sequel::SQL::InequalityMethods if RUBY_VERSION < '1.9.0'
 
@@ -237,12 +238,4 @@ class Symbol
     Sequel::SQL::Function.new(self, *args)
   end
   alias_method(:[], :sql_function) if RUBY_VERSION < '1.9.0'
-
-  # Return an SQL array subscript with the given arguments.
-  #
-  #   :array.sql_subscript(1) # SQL: array[1]
-  #   :array.sql_subscript(1, 2) # SQL: array[1, 2]
-  def sql_subscript(*sub)
-    Sequel::SQL::Subscript.new(self, sub.flatten)
-  end
 end

data/lib/sequel/database.rb

@@ -17,11 +17,15 @@ module Sequel
     include Metaprogramming
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado db2 dbi do firebird informix jdbc mysql odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite db2 dbi do firebird informix jdbc mysql odbc openbase oracle postgres sqlite'.collect{|x| x.to_sym}
 
     SQL_BEGIN = 'BEGIN'.freeze
     SQL_COMMIT = 'COMMIT'.freeze
     SQL_ROLLBACK = 'ROLLBACK'.freeze
+    
+    TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+    TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+    TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
 
     # The identifier input method to use by default
     @@identifier_input_method = nil
@@ -70,7 +74,7 @@ module Sequel
       @opts ||= opts
       
       @single_threaded = opts.include?(:single_threaded) ? opts[:single_threaded] : @@single_threaded
-      @schemas = nil
+      @schemas = {}
       @default_schema = opts.include?(:default_schema) ? opts[:default_schema] : default_schema_default
       @prepared_statements = {}
       @transactions = []
@@ -438,13 +442,8 @@ module Sequel
       quoted_name = quote_schema_table(table)
       opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema)
 
-      @schemas.delete(quoted_name) if opts[:reload] && @schemas
-      return @schemas[quoted_name] if @schemas && @schemas[quoted_name]
-
-      @schemas ||= Hash.new do |h,k|
-        quote_name = quote_schema_table(k)
-        h[quote_name] if h.include?(quote_name)
-      end
+      @schemas.delete(quoted_name) if opts[:reload]
+      return @schemas[quoted_name] if @schemas[quoted_name]
 
       cols = schema_parse_table(table_name, opts)
       raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
@@ -460,20 +459,21 @@ module Sequel
     def synchronize(server=nil, &block)
       @pool.hold(server || :default, &block)
     end
+    
+    # Whether the database and adapter support savepoints
+    def supports_savepoints?
+      false
+    end
 
     # Returns true if a table with the given name exists.  This requires a query
     # to the database unless this database object already has the schema for
     # the given table name.
     def table_exists?(name)
-      if @schemas && @schemas[name]
+      begin 
+        from(name).first
         true
-      else
-        begin 
-          from(name).first
-          true
-        rescue
-          false
-        end
+      rescue
+        false
       end
     end
     
@@ -484,29 +484,21 @@ module Sequel
       true
     end
 
-    # A simple implementation of SQL transactions. Nested transactions are not 
-    # supported - calling #transaction within a transaction will reuse the 
-    # current transaction. Should be overridden for databases that support nested 
-    # transactions.
-    def transaction(opts={})
+    # Starts a database transaction.  When a database transaction is used,
+    # either all statements are successful or none of the statements are
+    # successful.  Note that MySQL MyISAM tabels do not support transactions.
+    #
+    # The following options are respected:
+    #
+    # * :server  - The server to use for the transaction
+    # * :savepoint - Whether to create a new savepoint for this transaction,
+    #   only respected if the database adapter supports savepoints.  By
+    #   default Sequel will reuse an existing transaction, so if you want to
+    #   use a savepoint you must use this option.
+    def transaction(opts={}, &block)
       synchronize(opts[:server]) do |conn|
-        return yield(conn) if @transactions.include?(Thread.current)
-        log_info(begin_transaction_sql)
-        conn.execute(begin_transaction_sql)
-        begin
-          @transactions << Thread.current
-          yield(conn)
-        rescue Exception => e
-          log_info(rollback_transaction_sql)
-          conn.execute(rollback_transaction_sql)
-          transaction_error(e)
-        ensure
-          unless e
-            log_info(commit_transaction_sql)
-            conn.execute(commit_transaction_sql)
-          end
-          @transactions.delete(Thread.current)
-        end
+        return yield(conn) if already_in_transaction?(conn, opts)
+        _transaction(conn, &block)
       end
     end
     
@@ -554,6 +546,45 @@ module Sequel
     
     private
     
+    # Internal generic transaction method.  Any exception raised by the given
+    # block will cause the transaction to be rolled back.  If the exception is
+    # not Sequel::Rollback, the error will be reraised. If no exception occurs
+    # inside the block, the transaction is commited.
+    def _transaction(conn)
+      begin
+        add_transaction
+        t = begin_transaction(conn)
+        yield(conn)
+      rescue Exception => e
+        rollback_transaction(t)
+        transaction_error(e)
+      ensure
+        begin
+          commit_transaction(t) unless e
+        rescue Exception => e
+          raise_error(e, :classes=>database_error_classes)
+        ensure
+          remove_transaction(t)
+        end
+      end
+    end
+    
+    # Add the current thread to the list of active transactions
+    def add_transaction
+      @transactions << Thread.current
+    end    
+
+    # Whether the current thread/connection is already inside a transaction
+    def already_in_transaction?(conn, opts)
+      @transactions.include?(Thread.current)
+    end
+    
+    # Start a new database transaction on the given connection.
+    def begin_transaction(conn)
+      log_connection_execute(conn, begin_transaction_sql)
+      conn
+    end
+    
     # SQL to BEGIN a transaction.
     def begin_transaction_sql
       SQL_BEGIN
@@ -576,17 +607,33 @@ module Sequel
         obj.respond_to?(:empty?) ? obj.empty? : false
       end
     end
+    
+    # Commit the active transaction on the connection
+    def commit_transaction(conn)
+      log_connection_execute(conn, commit_transaction_sql)
+    end
 
     # SQL to COMMIT a transaction.
     def commit_transaction_sql
       SQL_COMMIT
     end
+    
+    # Method called on the connection object to execute SQL on the database,
+    # used by the transaction code.
+    def connection_execute_method
+      :execute
+    end
 
     # The default options for the connection pool.
     def connection_pool_default_options
       {}
     end
     
+    # Which transaction errors to translate, blank by default.
+    def database_error_classes
+      []
+    end
+    
     # The default value for default_schema.
     def default_schema_default
       nil
@@ -614,6 +661,13 @@ module Sequel
     def input_identifier_meth
       dataset.method(:input_identifier)
     end
+    
+    # Log the given SQL and then execute it on the connection, used by
+    # the transaction code.
+    def log_connection_execute(conn, sql)
+      log_info(sql)
+      conn.send(connection_execute_method, sql)
+    end
 
     # Return a dataset that uses the default identifier input and output methods
     # for this database.  Used when parsing metadata so that column symbols are
@@ -648,7 +702,7 @@ module Sequel
     # and traceback.
     def raise_error(exception, opts={})
       if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
-        e = DatabaseError.new("#{exception.class} #{exception.message}")
+        e = (opts[:disconnect] ? DatabaseDisconnectError : DatabaseError).new("#{exception.class}: #{exception.message}")
         e.set_backtrace(exception.backtrace)
         raise e
       else
@@ -660,12 +714,22 @@ module Sequel
     def remove_cached_schema(table)
       @schemas.delete(quote_schema_table(table)) if @schemas
     end
+    
+    # Remove the current thread from the list of active transactions
+    def remove_transaction(conn)
+      @transactions.delete(Thread.current)
+    end
 
     # Remove the cached schema_utility_dataset, because the identifier
     # quoting has changed.
     def reset_schema_utility_dataset
       @schema_utility_dataset = nil
     end
+    
+    # Rollback the active transaction on the connection
+    def rollback_transaction(conn)
+      log_connection_execute(conn, rollback_transaction_sql)
+    end
 
     # Split the schema information from the table
     def schema_and_table(table_name)
@@ -686,7 +750,7 @@ module Sequel
         Sequel.convert_tinyint_to_bool ? :boolean : :integer
       when /\Ainterval\z/io
         :interval
-      when /\A(character( varying)?|varchar|text)/io
+      when /\A(character( varying)?|(var)?char|text)/io
         :string
       when /\A(int(eger)?|bigint|smallint)/io
         :integer
@@ -733,8 +797,8 @@ module Sequel
     end
 
     # Raise a database error unless the exception is an Rollback.
-    def transaction_error(e, *classes)
-      raise_error(e, :classes=>classes) unless Rollback === e
+    def transaction_error(e)
+      raise_error(e, :classes=>database_error_classes) unless Rollback === e
     end
 
     # Typecast the value to an SQL::Blob