sequel 3.21.0 → 3.31.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,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/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.
     # ---------------------
 

data/lib/sequel/database/misc.rb

@@ -1,13 +1,13 @@
 module Sequel
   class Database
     # ---------------------
-    # :section: Miscellaneous methods
+    # :section: 7 - Miscellaneous methods
     # These methods don't fit neatly into another category.
     # ---------------------
 
     # 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,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,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
+      @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).
+    # 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 = @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).
+    # 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 = @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 +106,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).
@@ -90,6 +142,12 @@ module Sequel
       {:primary_key => true, :type => Integer, :auto_increment => true}
     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 and adapter support prepared transactions
     # (two-phase commit), false by default.
     def supports_prepared_transactions?
@@ -106,6 +164,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.
@@ -175,12 +245,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 +269,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 +279,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 +294,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 +314,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 +340,15 @@ module Sequel
     def typecast_value_time(value)
       case value
       when Time
-        value
+        if value.is_a?(SQLTime)
+          value
+        else
+          SQLTime.create(value.hour, value.min, value.sec, value.respond_to?(:nsec) ? 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