sequel 3.28.0 → 3.29.0

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

@@ -9,11 +9,6 @@ module Sequel
       module DatabaseMethods
         include Sequel::MySQL::DatabaseMethods
         
-        # Return instance of Sequel::Swift::MySQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::Swift::MySQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # The database name for the given database.

data/lib/sequel/adapters/swift/postgres.rb

@@ -41,11 +41,6 @@ module Sequel
           end
         end
         
-        # Return instance of Sequel::Swift::Postgres::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::Swift::Postgres::Dataset.new(self, opts)
-        end
-        
         # Run the SELECT SQL on the database and yield the rows
         def execute(sql, opts={})
           synchronize(opts[:server]) do |conn|

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

@@ -8,10 +8,12 @@ module Sequel
       # Database instance methods for SQLite databases accessed via Swift.
       module DatabaseMethods
         include Sequel::SQLite::DatabaseMethods
-        
-        # Return instance of Sequel::Swift::SQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::Swift::SQLite::Dataset.new(self, opts)
+
+        # Set the correct pragmas on the connection.
+        def connect(opts)
+          c = super
+          connection_pragmas.each{|s| log_yield(s){c.execute(s)}}
+          c
         end
       end
       

data/lib/sequel/adapters/tinytds.rb

@@ -16,11 +16,6 @@ module Sequel
         TinyTds::Client.new(opts)
       end
       
-      # Return instance of Sequel::TinyTDS::Dataset with the given options.
-      def dataset(opts = nil)
-        TinyTDS::Dataset.new(self, opts)
-      end
-    
       # Execute the given +sql+ on the server.  If the :return option
       # is present, its value should be a method symbol that is called
       # on the TinyTds::Result object returned from executing the
@@ -150,6 +145,8 @@ module Sequel
     
     class Dataset < Sequel::Dataset
       include Sequel::MSSQL::DatasetMethods
+
+      Database::DatasetClass = self
       
       # SQLite already supports named bind arguments, so use directly.
       module ArgumentMapper
@@ -208,22 +205,28 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |result|
           each_opts = {:cache_rows=>false}
-          each_opts[:timezone] = :utc if Sequel.database_timezone == :utc
-          offset = @opts[:offset]
-          @columns = cols = result.fields.map{|c| output_identifier(c)}
+          each_opts[:timezone] = :utc if db.timezone == :utc
+          rn = row_number_column if @opts[:offset]
+          columns = cols = result.fields.map{|c| output_identifier(c)}
+          if opts[:offset]
+            rn = row_number_column
+            columns = columns.dup
+            columns.delete(rn)
+          end
+          @columns = columns
           if identifier_output_method
             each_opts[:as] = :array
             result.each(each_opts) do |r|
               h = {}
               cols.zip(r).each{|k, v| h[k] = v}
-              h.delete(row_number_column) if offset
+              h.delete(rn) if rn
               yield h
             end
           else
             each_opts[:symbolize_keys] = true
             if offset
               result.each(each_opts) do |r|
-                r.delete(row_number_column) if offset
+                r.delete(rn) if rn
                 yield r
               end
             else

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

@@ -51,5 +51,13 @@ module Sequel
         limit(@opts[:limit]).
         where(SQL::Identifier.new(rn) > o))
     end
+
+    private
+
+    # This emulation adds an extra row number column that should be
+    # eliminated.
+    def offset_returns_row_number_column?
+      true
+    end
   end
 end

data/lib/sequel/core.rb

@@ -240,6 +240,46 @@ module Sequel
     end
   end
 
+  # Uses a transaction on all given databases with the given options. This:
+  #
+  #   Sequel.transaction([DB1, DB2, DB3]){...}
+  #
+  # is equivalent to:
+  #
+  #   DB1.transaction do
+  #     DB2.transaction do
+  #       DB3.transaction do
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  # except that if Sequel::Rollback is raised by the block, the transaction is
+  # rolled back on all databases instead of just the last one.
+  #
+  # Note that this method cannot guarantee that all databases will commit or
+  # rollback.  For example, if DB3 commits but attempting to commit on DB2
+  # fails (maybe because foreign key checks are deferred), there is no way
+  # to uncommit the changes on DB3.  For that kind of support, you need to
+  # have two-phase commit/prepared transactions (which Sequel supports on
+  # some databases).
+  def self.transaction(dbs, opts={}, &block)
+    unless opts[:rollback]
+      rescue_rollback = true
+      opts = opts.merge(:rollback=>:reraise)
+    end
+    pr = dbs.reverse.inject(block){|bl, db| proc{db.transaction(opts, &bl)}}
+    if rescue_rollback
+      begin
+        pr.call
+      rescue Sequel::Rollback => e
+        nil
+      end
+    else
+      pr.call
+    end
+  end
+
   # Same as Sequel.require, but wrapped in a mutex in order to be thread safe.
   def self.ts_require(*args)
     check_requiring_thread{require(*args)}

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite db2 dbi do firebird ibmdb informix jdbc mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
 
     # Whether to use the single threaded connection pool by default
     @@single_threaded = false
@@ -218,7 +218,6 @@ module Sequel
     # If a server option is given, acquires a connection for that specific
     # server, instead of the :default server.
     #
-    #
     #   DB.synchronize do |conn|
     #     ...
     #   end

data/lib/sequel/database/dataset.rb

@@ -24,10 +24,10 @@ module Sequel
     #
     #   DB.dataset # SELECT *
     #   DB.dataset.from(:items) # SELECT * FROM items
-    def dataset
-      ds = Sequel::Dataset.new(self)
+    def dataset(opts=nil)
+      @dataset_class.new(self, opts)
     end
-    
+
     # Fetches records for an arbitrary SQL statement. If a block is given,
     # it is used to iterate over the records:
     #

data/lib/sequel/database/dataset_defaults.rb

@@ -5,6 +5,9 @@ module Sequel
     # This methods change the default behavior of this database's datasets.
     # ---------------------
 
+    # The default class to use for datasets
+    DatasetClass = Sequel::Dataset
+
     # The identifier input method to use by default
     @@identifier_input_method = nil
 
@@ -42,9 +45,59 @@ module Sequel
       @@quote_identifiers = value
     end
 
+    # The class to use for creating datasets.  Should respond to
+    # new with the Database argument as the first argument, and
+    # an optional options hash.
+    attr_reader :dataset_class
+
     # The default schema to use, generally should be nil.
     attr_accessor :default_schema
 
+    # If the database has any dataset modules associated with it,
+    # use a subclass of the given class that includes the modules
+    # as the dataset class.
+    def dataset_class=(c)
+      unless @dataset_modules.empty?
+        c = Class.new(c)
+        @dataset_modules.each{|m| c.send(:include, m)}
+      end
+      @dataset_class = c
+    end
+
+    # Equivalent to extending all datasets produced by the database with a
+    # module.  What it actually does is use a subclass of the current dataset_class
+    # as the new dataset_class, and include the module in the subclass.
+    # Instead of a module, you can provide a block that is used to create an
+    # anonymous module.
+    #
+    # This allows you to override any of the dataset methods even if they are
+    # defined directly on the dataset class that this Database object uses.
+    #
+    # Examples:
+    #
+    #   # Introspec columns for all of DB's datasets
+    #   DB.extend_datasets(Sequel::ColumnsIntrospection)
+    #   
+    #   # Trace all SELECT queries by printing the SQL and the full backtrace
+    #   DB.extend_datasets do
+    #     def fetch_rows(sql)
+    #       puts sql
+    #       puts caller
+    #       super
+    #     end
+    #   end
+    def extend_datasets(mod=nil, &block)
+      raise(Error, "must provide either mod or block, not both") if mod && block
+      mod = Module.new(&block) if block
+      if @dataset_modules.empty?
+       @dataset_modules = [mod]
+       @dataset_class = Class.new(@dataset_class)
+      else
+       @dataset_modules << mod
+      end
+      @dataset_class.send(:include, mod)
+    end
+
     # The method to call on identifiers going into the database
     def identifier_input_method
       case @identifier_input_method
@@ -109,6 +162,11 @@ module Sequel
     
     private
     
+    # The default dataset class to use for the database
+    def dataset_class_default
+      self.class.const_get(:DatasetClass)
+    end
+    
     # The default value for default_schema.
     def default_schema_default
       nil

data/lib/sequel/database/misc.rb

@@ -19,6 +19,9 @@ module Sequel
     # The options hash for this database
     attr_reader :opts
     
+    # Set the timezone to use for this database, overridding <tt>Sequel.database_timezone</tt>.
+    attr_writer :timezone
+    
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
@@ -50,15 +53,46 @@ module Sequel
       @schemas = {}
       @default_schema = @opts.fetch(:default_schema, default_schema_default)
       @prepared_statements = {}
-      @transactions = []
+      @transactions = {}
       @identifier_input_method = nil
       @identifier_output_method = nil
       @quote_identifiers = nil
+      @timezone = nil
+      @dataset_class = dataset_class_default
+      @dataset_modules = []
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
       @pool = ConnectionPool.get_pool(@opts, &block)
 
       ::Sequel::DATABASES.push(self)
     end
+
+    # If a transaction is not currently in process, yield to the block immediately.
+    # Otherwise, add the block to the list of blocks to call after the currently
+    # in progress transaction commits (and only if it commits).
+    def after_commit(opts={}, &block)
+      raise Error, "must provide block to after_commit" unless block
+      synchronize(opts) do |conn|
+        if h = @transactions[conn]
+          raise Error, "cannot call after_commit in a prepared transaction" if h[:prepare]
+          (h[:after_commit] ||= []) << block
+        else
+          yield
+        end
+      end
+    end
+    
+    # If a transaction is not currently in progress, ignore the block.
+    # Otherwise, add the block to the list of the blocks to call after the currently
+    # in progress transaction rolls back (and only if it rolls back).
+    def after_rollback(opts={}, &block)
+      raise Error, "must provide block to after_rollback" unless block
+      synchronize(opts) do |conn|
+        if h = @transactions[conn]
+          raise Error, "cannot call after_rollback in a prepared transaction" if h[:prepare]
+          (h[:after_rollback] ||= []) << block
+        end
+      end
+    end
     
     # Cast the given type to a literal type
     #
@@ -68,6 +102,20 @@ module Sequel
       type_literal(:type=>type)
     end
 
+    # Convert the given timestamp from the application's timezone,
+    # to the databases's timezone or the default database timezone if
+    # the database does not have a timezone.
+    def from_application_timestamp(v)
+      Sequel.convert_output_timestamp(v, timezone)
+    end
+
+    # Return true if already in a transaction given the options,
+    # false otherwise.  Respects the :server option for selecting
+    # a shard.
+    def in_transaction?(opts={})
+      synchronize(opts[:server]){|conn| !!@transactions[conn]}
+    end
+
     # Returns a string representation of the database object including the
     # class name and the connection URI (or the opts if the URI
     # cannot be constructed).
@@ -112,6 +160,18 @@ module Sequel
       false
     end
 
+    # The timezone to use for this database, defaulting to <tt>Sequel.database_timezone</tt>.
+    def timezone
+      @timezone || Sequel.database_timezone
+    end
+
+    # Convert the given timestamp to the application's timezone,
+    # from the databases's timezone or the default database timezone if
+    # the database does not have a timezone.
+    def to_application_timestamp(v)
+      Sequel.convert_timestamp(v, timezone)
+    end
+
     # Typecast the value to the given column_type. Calls
     # typecast_value_#{column_type} if the method exists,
     # otherwise returns the value.
@@ -205,7 +265,7 @@ module Sequel
     # Typecast the value to true, false, or nil
     def typecast_value_boolean(value)
       case value
-      when false, 0, "0", /\Af(alse)?\z/i
+      when false, 0, "0", /\Af(alse)?\z/i, /\Ano?\z/i
         false
       else
         blank_object?(value) ? nil : true

data/lib/sequel/database/query.rb

@@ -37,9 +37,12 @@ module Sequel
     attr_accessor :transaction_isolation_level
     
     # Runs the supplied SQL statement string on the database server.
-    # Alias for run.
+    # Returns self so it can be safely chained:
+    #
+    #   DB << "UPADTE albums SET artist_id = NULL" << "DROP TABLE artists"
     def <<(sql)
       run(sql)
+      self
     end
     
     # Call the prepared statement with the given name with the given hash
@@ -112,14 +115,15 @@ module Sequel
     
     # Returns the schema for the given table as an array with all members being arrays of length 2,
     # the first member being the column name, and the second member being a hash of column information.
+    # The table argument can also be a dataset, as long as it only has one table.
     # Available options are:
     #
     # :reload :: Ignore any cached results, and get fresh information from the database.
     # :schema :: An explicit schema to use.  It may also be implicitly provided
     #            via the table name.
     #
-    # If schema parsing is supported by the database, the column information should at least contain the
-    # following columns:
+    # If schema parsing is supported by the database, the column information should hash at least contain the
+    # following entries:
     #
     # :allow_null :: Whether NULL is an allowed value for the column.
     # :db_type :: The database type for the column, as a database specific string.
@@ -152,9 +156,20 @@ module Sequel
     def schema(table, opts={})
       raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
 
-      sch, table_name = schema_and_table(table)
-      quoted_name = quote_schema_table(table)
-      opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema)
+      opts = opts.dup
+      if table.is_a?(Dataset)
+        o = table.opts
+        from = o[:from]
+        raise(Error, "can only parse the schema for a dataset with a single from table") unless from && from.length == 1 && !o.include?(:join) && !o.include?(:sql)
+        tab = table.first_source_table
+        sch, table_name = schema_and_table(tab)
+        quoted_name = table.literal(tab)
+        opts[:dataset] = table
+      else
+        sch, table_name = schema_and_table(table)
+        quoted_name = quote_schema_table(table)
+      end
+      opts[:schema] = sch if sch && !opts.include?(:schema)
 
       @schemas.delete(quoted_name) if opts[:reload]
       return @schemas[quoted_name] if @schemas[quoted_name]
@@ -199,6 +214,9 @@ module Sequel
     # :prepare :: A string to use as the transaction identifier for a
     #             prepared transaction (two-phase commit), if the database/adapter
     #             supports prepared transactions.
+    # :rollback :: Can the set to :reraise to reraise any Sequel::Rollback exceptions
+    #              raised, or :always to always rollback even if no exceptions occur
+    #              (useful for testing).
     # :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
@@ -225,40 +243,65 @@ module Sequel
     # not a Sequel::Rollback, the error will be reraised. If no exception occurs
     # inside the block, the transaction is commited.
     def _transaction(conn, opts={})
+      rollback = opts[:rollback]
       begin
-        add_transaction
-        t = begin_transaction(conn, opts)
-        yield(conn)
+        add_transaction(conn, opts)
+        begin_transaction(conn, opts)
+        if rollback == :always
+          begin
+            yield(conn)
+          rescue Exception => e1
+            raise e1
+          ensure
+            raise ::Sequel::Rollback unless e1
+          end
+        else
+          yield(conn)
+        end
       rescue Exception => e
-        rollback_transaction(t, opts) if t
-        transaction_error(e, :conn=>conn)
+        rollback_transaction(conn, opts)
+        transaction_error(e, :conn=>conn, :rollback=>rollback)
       ensure
         begin
-          commit_or_rollback_transaction(e, t, opts)
-        rescue Exception => e
-          raise_error(e, :classes=>database_error_classes, :conn=>conn)
+          committed = commit_or_rollback_transaction(e, conn, opts)
+        rescue Exception => e2
+          raise_error(e2, :classes=>database_error_classes, :conn=>conn)
         ensure
-          remove_transaction(t)
+          remove_transaction(conn, committed)
         end
       end
     end
 
     # Add the current thread to the list of active transactions
-    def add_transaction
-      th = Thread.current
+    def add_transaction(conn, opts)
       if supports_savepoints?
-        unless @transactions.include?(th)
-          th[:sequel_transaction_depth] = 0
-          @transactions << th
+        unless @transactions[conn]
+          @transactions[conn] = {:savepoint_level=>0}
+          @transactions[conn][:prepare] = opts[:prepare] if supports_prepared_transactions?
         end
       else
-        @transactions << th
+        @transactions[conn] = {}
+        @transactions[conn][:prepare] = opts[:prepare] if supports_prepared_transactions?
       end
     end    
 
+    # Call all stored after_commit blocks for the given transaction
+    def after_transaction_commit(conn)
+      if ary = @transactions[conn][:after_commit]
+        ary.each{|b| b.call}
+      end
+    end
+
+    # Call all stored after_rollback blocks for the given transaction
+    def after_transaction_rollback(conn)
+      if ary = @transactions[conn][:after_rollback]
+        ary.each{|b| b.call}
+      end
+    end
+
     # Whether the current thread/connection is already inside a transaction
     def already_in_transaction?(conn, opts)
-      @transactions.include?(Thread.current) && (!supports_savepoints? || !opts[:savepoint])
+      @transactions.has_key?(conn) && (!supports_savepoints? || !opts[:savepoint])
     end
     
     # SQL to start a new savepoint
@@ -275,17 +318,16 @@ module Sequel
     # Start a new database transaction or a new savepoint on the given connection.
     def begin_transaction(conn, opts={})
       if supports_savepoints?
-        th = Thread.current
-        if (depth = th[:sequel_transaction_depth]) > 0
+        th = @transactions[conn]
+        if (depth = th[:savepoint_level]) > 0
           log_connection_execute(conn, begin_savepoint_sql(depth))
         else
           begin_new_transaction(conn, opts)
         end
-        th[:sequel_transaction_depth] += 1
+        th[:savepoint_level] += 1
       else
         begin_new_transaction(conn, opts)
       end
-      conn
     end
     
     # SQL to BEGIN a transaction.
@@ -348,12 +390,16 @@ module Sequel
       # Thread.current.status is checked because Thread#kill skips rescue
       # blocks (so exception would be nil), but the transaction should
       # still be rolled back.
-      def commit_or_rollback_transaction(exception, thread, opts)
-        unless exception
+      def commit_or_rollback_transaction(exception, conn, opts)
+        if exception
+          false
+        else
           if Thread.current.status == 'aborting'
-            rollback_transaction(thread, opts)
+            rollback_transaction(conn, opts)
+            false
           else
-            commit_transaction(thread, opts)
+            commit_transaction(conn, opts)
+            true
           end
         end
       end
@@ -361,8 +407,13 @@ module Sequel
       # Whether to commit the current transaction.  On ruby 1.9 and JRuby,
       # transactions will be committed if Thread#kill is used on an thread
       # that has a transaction open, and there isn't a work around.
-      def commit_or_rollback_transaction(exception, thread, opts)
-        commit_transaction(thread, opts) unless exception
+      def commit_or_rollback_transaction(exception, conn, opts)
+        if exception
+          false
+        else
+          commit_transaction(conn, opts)
+          true
+        end
       end
     end
     
@@ -374,7 +425,7 @@ module Sequel
     # Commit the active transaction on the connection
     def commit_transaction(conn, opts={})
       if supports_savepoints?
-        depth = Thread.current[:sequel_transaction_depth]
+        depth = @transactions[conn][:savepoint_level]
         log_connection_execute(conn, depth > 1 ? commit_savepoint_sql(depth-1) : commit_transaction_sql)
       else
         log_connection_execute(conn, commit_transaction_sql)
@@ -395,8 +446,8 @@ module Sequel
     # Return a Method object for the dataset's output_identifier_method.
     # Used in metadata parsing to make sure the returned information is in the
     # correct format.
-    def input_identifier_meth
-      dataset.method(:input_identifier)
+    def input_identifier_meth(ds=nil)
+      (ds || dataset).method(:input_identifier)
     end
     
     # Return a dataset that uses the default identifier input and output methods
@@ -413,24 +464,28 @@ module Sequel
     # Return a Method object for the dataset's output_identifier_method.
     # Used in metadata parsing to make sure the returned information is in the
     # correct format.
-    def output_identifier_meth
-      dataset.method(:output_identifier)
+    def output_identifier_meth(ds=nil)
+      (ds || dataset).method(:output_identifier)
     end
 
-    # SQL to ROLLBACK a transaction.
-    def rollback_transaction_sql
-      SQL_ROLLBACK
-    end
-    
     # Remove the cached schema for the given schema name
     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)
-      th = Thread.current
-      @transactions.delete(th) if !supports_savepoints? || ((th[:sequel_transaction_depth] -= 1) <= 0)
+    def remove_transaction(conn, committed)
+      if !supports_savepoints? || ((@transactions[conn][:savepoint_level] -= 1) <= 0)
+        begin
+          if committed
+            after_transaction_commit(conn)
+          else
+            after_transaction_rollback(conn)
+          end
+        ensure
+          @transactions.delete(conn)
+        end
+      end
     end
 
     # SQL to rollback to a savepoint
@@ -441,13 +496,18 @@ module Sequel
     # Rollback the active transaction on the connection
     def rollback_transaction(conn, opts={})
       if supports_savepoints?
-        depth = Thread.current[:sequel_transaction_depth]
+        depth = @transactions[conn][:savepoint_level]
         log_connection_execute(conn, depth > 1 ? rollback_savepoint_sql(depth-1) : rollback_transaction_sql)
       else
         log_connection_execute(conn, rollback_transaction_sql)
       end
     end
 
+    # SQL to ROLLBACK a transaction.
+    def rollback_transaction_sql
+      SQL_ROLLBACK
+    end
+    
     # Match the database's column type to a ruby type via a
     # regular expression, and return the ruby type as a symbol
     # such as :integer or :string.
@@ -469,8 +529,8 @@ module Sequel
         :boolean
       when /\A(real|float|double( precision)?)\z/io
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+)\))?)|(?:small)?money)\z/io
-        $1 && $1 == '0' ? :integer : :decimal
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?)|(?:small)?money)\z/io
+        $1 && ['0', 'false'].include?($1) ? :integer : :decimal
       when /bytea|[bc]lob|image|(var)?binary/io
         :blob
       when /\Aenum/io
@@ -492,7 +552,11 @@ module Sequel
 
     # Raise a database error unless the exception is an Rollback.
     def transaction_error(e, opts={})
-      raise_error(e, opts.merge(:classes=>database_error_classes)) unless e.is_a?(Rollback)
+      if e.is_a?(Rollback)
+        raise e if opts[:rollback] == :reraise
+      else
+        raise_error(e, opts.merge(:classes=>database_error_classes))
+      end
     end
   end
 end