sequel 3.21.0 → 3.39.0

data/lib/sequel/database/dataset_defaults.rb

@@ -1,10 +1,13 @@
 module Sequel
   class Database
     # ---------------------
-    # :section: Methods that set defaults for created datasets
+    # :section: 5 - Methods that set defaults for created datasets
     # 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,62 @@ module Sequel
       @@quote_identifiers = value
     end
 
-    # The default schema to use, generally should be nil.
+    # 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.  This sets
+    # the default schema used for some schema modification and
+    # introspection queries, but does not effect most dataset code.
     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
+      reset_schema_utility_dataset
+      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 +165,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/logging.rb

@@ -1,7 +1,7 @@
 module Sequel
   class Database
     # ---------------------
-    # :section: Methods relating to logging
+    # :section: 6 - Methods relating to logging
     # This methods affect relating to the logging of executed SQL.
     # ---------------------
 
@@ -17,6 +17,11 @@ module Sequel
     # is :info, it can be set to :debug to log at DEBUG level.
     attr_accessor :sql_log_level
 
+    # Log a message at error level, with information about the exception.
+    def log_exception(exception, message)
+      log_each(:error, "#{exception.class}: #{exception.message.strip}: #{message}")
+    end
+
     # Log a message at level info to all loggers.
     def log_info(message, args=nil)
       log_each(:info, args ? "#{message}; #{args.inspect}" : message)
@@ -31,7 +36,7 @@ module Sequel
       begin
         yield
       rescue => e
-        log_each(:error, "#{e.class}: #{e.message.strip}: #{sql}")
+        log_exception(e, sql)
         raise
       ensure
         log_duration(Time.now - start, sql) unless e

data/lib/sequel/database/misc.rb

@@ -1,13 +1,35 @@
 module Sequel
   class Database
     # ---------------------
-    # :section: Miscellaneous methods
+    # :section: 7 - Miscellaneous methods
     # These methods don't fit neatly into another category.
     # ---------------------
+    
+    # Hash of extension name symbols to callable objects to load the extension
+    # into the Database object (usually by extending it with a module defined
+    # in the extension).
+    EXTENSIONS = {}
+
+    # Register an extension callback for Database objects.  ext should be the
+    # extension name symbol, and mod should either be a Module that the
+    # database is extended with, or a callable object called with the database
+    # object.  If mod is not provided, a block can be provided and is treated
+    # as the mod object.
+    def self.register_extension(ext, mod=nil, &block)
+      if mod
+        raise(Error, "cannot provide both mod and block to Database.register_extension") if block
+        if mod.is_a?(Module)
+          block = proc{|db| db.extend(mod)}
+        else
+          block = mod
+        end
+      end
+      Sequel.synchronize{EXTENSIONS[ext] = block}
+    end
 
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
-    def self.uri_to_options(uri) # :nodoc:
+    def self.uri_to_options(uri)
       { :user => uri.user,
         :password => uri.password,
         :host => uri.host,
@@ -19,11 +41,14 @@ 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.
     #
     # Accepts the following options:
-    # :default_schema :: The default schema to use, should generally be nil
+    # :default_schema :: The default schema to use, see #default_schema.
     # :disconnection_proc :: A proc used to disconnect the connection
     # :identifier_input_method :: A string method symbol to call on identifiers going into the database
     # :identifier_output_method :: A string method symbol to call on identifiers coming from the database
@@ -50,14 +75,50 @@ 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
+      @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
+      @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)
+      Sequel.synchronize{::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).
+    # Options:
+    # :server :: The server/shard to use.
+    def after_commit(opts={}, &block)
+      raise Error, "must provide block to after_commit" unless block
+      synchronize(opts[:server]) do |conn|
+        if h = _trans(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).
+    # Options:
+    # :server :: The server/shard to use.
+    def after_rollback(opts={}, &block)
+      raise Error, "must provide block to after_rollback" unless block
+      synchronize(opts[:server]) do |conn|
+        if h = _trans(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,11 +129,52 @@ module Sequel
       type_literal(:type=>type)
     end
 
+    # Load an extension into the receiver.  In addition to requiring the extension file, this
+    # also modifies the database to work with the extension (usually extending it with a
+    # module defined in the extension file).  If no related extension file exists or the
+    # extension does not have specific support for Database objects, an Error will be raised.
+    # Returns self.
+    def extension(*exts)
+      Sequel.extension(*exts)
+      exts.each do |ext|
+        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          pr.call(self)
+        else
+          raise(Error, "Extension #{ext} does not have specific support handling individual databases")
+        end
+      end
+      self
+    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
+
+    # Whether the database uses a global namespace for the index.  If
+    # false, the indexes are going to be namespaced per table.
+    def global_index_namespace?
+      true
+    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| !!_trans(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).
+    # class name and connection URI and options used when connecting (if any).
     def inspect
-      "#<#{self.class}: #{(uri rescue opts).inspect}>" 
+      a = []
+      a << uri.inspect if uri
+      if (oo = opts[:orig_opts]) && !oo.empty?
+        a << oo.inspect
+      end
+      "#<#{self.class}: #{a.join(' ')}>"
     end
 
     # Proxy the literal call to the dataset.
@@ -84,12 +186,34 @@ module Sequel
       schema_utility_dataset.literal(v)
     end
 
+    # Synchronize access to the prepared statements cache.
+    def prepared_statement(name)
+      Sequel.synchronize{prepared_statements[name]}
+    end
+
     # Default serial primary key options, used by the table creation
     # code.
     def serial_primary_key_options
       {:primary_key => true, :type => Integer, :auto_increment => true}
     end
 
+    # Cache the prepared statement object at the given name.
+    def set_prepared_statement(name, ps)
+      Sequel.synchronize{prepared_statements[name] = ps}
+    end
+
+    # Whether the database supports CREATE TABLE IF NOT EXISTS syntax,
+    # false by default.
+    def supports_create_table_if_not_exists?
+      false
+    end
+
+    # Whether the database supports DROP TABLE IF EXISTS syntax,
+    # default is the same as #supports_create_table_if_not_exists?.
+    def supports_drop_table_if_exists?
+      supports_create_table_if_not_exists?
+    end
+
     # Whether the database and adapter support prepared transactions
     # (two-phase commit), false by default.
     def supports_prepared_transactions?
@@ -101,11 +225,34 @@ module Sequel
       false
     end
 
+    # Whether the database and adapter support savepoints inside prepared transactions
+    # (two-phase commit), default is false.
+    def supports_savepoints_in_prepared_transactions?
+      supports_prepared_transactions? && supports_savepoints?
+    end
+
     # Whether the database and adapter support transaction isolation levels, false by default.
     def supports_transaction_isolation_levels?
       false
     end
 
+    # Whether DDL statements work correctly in transactions, false by default.
+    def supports_transactional_ddl?
+      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.
@@ -121,29 +268,10 @@ module Sequel
       end
     end
     
-    # Returns the URI identifying the database, which may not be the
-    # same as the URI used when connecting.
-    # This method can raise an error if the database used options
-    # instead of a connection string, and will not include uri
-    # parameters.
-    #
-    #   Sequel.connect('postgres://localhost/db?user=billg').url
-    #   # => "postgres://billg@localhost/db"
+    # Returns the URI use to connect to the database.  If a URI
+    # was not used when connecting, returns nil.
     def uri
-      uri = URI::Generic.new(
-        adapter_scheme.to_s,
-        nil,
-        @opts[:host],
-        @opts[:port],
-        nil,
-        "/#{@opts[:database]}",
-        nil,
-        nil,
-        nil
-      )
-      uri.user = @opts[:user]
-      uri.password = @opts[:password] if uri.user
-      uri.to_s
+      opts[:uri]
     end
     
     # Explicit alias of uri for easier subclassing.
@@ -175,12 +303,17 @@ module Sequel
     def database_error_classes
       []
     end
+
+    # Return true if exception represents a disconnect error, false otherwise.
+    def disconnect_error?(exception, opts)
+      opts[:disconnect]
+    end
     
     # Convert the given exception to a DatabaseError, keeping message
     # and traceback.
     def raise_error(exception, opts={})
       if !opts[:classes] || Array(opts[:classes]).any?{|c| exception.is_a?(c)}
-        raise Sequel.convert_exception_class(exception, opts[:disconnect] ? DatabaseDisconnectError : DatabaseError)
+        raise Sequel.convert_exception_class(exception, disconnect_error?(exception, opts) ? DatabaseDisconnectError : DatabaseError)
       else
         raise exception
       end
@@ -194,7 +327,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
@@ -204,10 +337,10 @@ module Sequel
     # Typecast the value to a Date
     def typecast_value_date(value)
       case value
-      when Date
-        value
       when DateTime, Time
         Date.new(value.year, value.month, value.day)
+      when Date
+        value
       when String
         Sequel.string_to_date(value)
       when Hash
@@ -219,12 +352,7 @@ module Sequel
 
     # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
     def typecast_value_datetime(value)
-      klass = Sequel.datetime_class
-      if value.is_a?(Hash)
-        klass.send(klass == Time ? :mktime : :new, *[:year, :month, :day, :hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
-      else
-        Sequel.typecast_to_application_timestamp(value)
-      end
+      Sequel.typecast_to_application_timestamp(value)
     end
 
     # Typecast the value to a BigDecimal
@@ -244,9 +372,21 @@ module Sequel
       Float(value)
     end
 
-    # Typecast the value to an Integer
-    def typecast_value_integer(value)
-      Integer(value)
+    # Used for checking/removing leading zeroes from strings so they don't get
+    # interpreted as octal.
+    LEADING_ZERO_RE = /\A0+(\d)/.freeze
+    if RUBY_VERSION >= '1.9'
+      # Typecast the value to an Integer
+      def typecast_value_integer(value)
+        (value.is_a?(String) && value =~ LEADING_ZERO_RE) ? Integer(value, 10) : Integer(value)
+      end
+    else
+      # Replacement string when replacing leading zeroes.
+      LEADING_ZERO_REP = "\\1".freeze 
+      # Typecast the value to an Integer
+      def typecast_value_integer(value)
+        Integer(value.is_a?(String) ? value.sub(LEADING_ZERO_RE, LEADING_ZERO_REP) : value)
+      end
     end
 
     # Typecast the value to a String
@@ -258,12 +398,16 @@ module Sequel
     def typecast_value_time(value)
       case value
       when Time
-        value
+        if value.is_a?(SQLTime)
+          value
+        else
+          # specifically check for nsec == 0 value to work around JRuby 1.6 ruby 1.9 mode bug
+          SQLTime.create(value.hour, value.min, value.sec, (value.respond_to?(:nsec) && value.nsec != 0) ? value.nsec/1000.0 : value.usec)
+        end
       when String
         Sequel.string_to_time(value)
       when Hash
-        t = Time.now
-        Time.mktime(t.year, t.month, t.day, *[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.create(*[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end