sequel 3.10.0 → 3.11.0

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

@@ -130,11 +130,6 @@ module Sequel
         clone(:sequence=>s)
       end
 
-      # Oracle does not support DISTINCT ON
-      def supports_distinct_on?
-        false
-      end
-
       # Oracle does not support INTERSECT ALL or EXCEPT ALL
       def supports_intersect_except_all?
         false

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

@@ -113,24 +113,19 @@ module Sequel
       # is true.
       def apply_connection_settings
         if Postgres.force_standard_strings
-          sql = "SET standard_conforming_strings = ON"
-          @db.log_info(sql)
           # This setting will only work on PostgreSQL 8.2 or greater
           # and we don't know the server version at this point, so
           # try it unconditionally and rescue any errors.
-          execute(sql) rescue nil
+          execute("SET standard_conforming_strings = ON") rescue nil
         end
         if cmm = Postgres.client_min_messages
-          sql = "SET client_min_messages = '#{cmm.to_s.upcase}'"
-          @db.log_info(sql)
-          execute(sql)
+          execute("SET client_min_messages = '#{cmm.to_s.upcase}'")
         end
       end
 
       # Get the last inserted value for the given sequence.
       def last_insert_id(sequence)
         sql = SELECT_CURRVAL % sequence
-        @db.log_info(sql)
         execute(sql) do |r|
           val = single_value(r)
           return val.to_i if val
@@ -140,7 +135,6 @@ module Sequel
       # Get the primary key for the given table.
       def primary_key(schema, table)
         sql = SELECT_PK[schema, table]
-        @db.log_info(sql)
         execute(sql) do |r|
           return single_value(r)
         end
@@ -149,14 +143,12 @@ module Sequel
       # Get the primary key and sequence for the given table.
       def sequence(schema, table)
         sql = SELECT_SERIAL_SEQUENCE[schema, table]
-        @db.log_info(sql)
         execute(sql) do |r|
           seq = single_value(r)
           return seq if seq
         end
         
         sql = SELECT_CUSTOM_SEQUENCE[schema, table]
-        @db.log_info(sql)
         execute(sql) do |r|
           return single_value(r)
         end
@@ -501,6 +493,11 @@ module Sequel
           nil
         end
       end
+
+      # Don't log, since logging is done by the underlying connection.
+      def log_connection_execute(conn, sql) 
+        conn.execute(sql)
+      end
       
       # Use a dollar sign instead of question mark for the argument
       # placeholder.
@@ -702,6 +699,11 @@ module Sequel
         [insert_sql(columns, LiteralString.new('VALUES ' + values.map {|r| literal(Array(r))}.join(COMMA_SEPARATOR)))]
       end
       
+      # DISTINCT ON is a PostgreSQL extension
+      def supports_distinct_on?
+        true
+      end
+      
       # PostgreSQL supports modifying joined datasets
       def supports_modifying_joins?
         true
@@ -758,7 +760,7 @@ module Sequel
 
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
       def literal_blob(v)
-        "'#{v.gsub(/[\000-\037\047\134\177-\377]/){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
+        "'#{v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"}}'"
       end
 
       # PostgreSQL uses FALSE for false values

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

@@ -1,5 +1,8 @@
 module Sequel
   module SQLite
+    # No matter how you connect to SQLite, the following Database options
+    # can be used to set PRAGMAs on connections in a thread-safe manner:
+    # :auto_vacuum, :foreign_keys, :synchronous, and :temp_store.
     module DatabaseMethods
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
@@ -21,7 +24,8 @@ module Sequel
       end
       
       # Set the auto_vacuum PRAGMA using the given symbol (:none, :full, or
-      # :incremental).
+      # :incremental).  See pragma_set.  Consider using the :auto_vacuum
+      # Database option instead.
       def auto_vacuum=(value)
         value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
         pragma_set(:auto_vacuum, value)
@@ -31,6 +35,19 @@ module Sequel
       def database_type
         :sqlite
       end
+      
+      # Boolean signifying the value of the foreign_keys PRAGMA, or nil
+      # if not using SQLite 3.6.19+.
+      def foreign_keys
+        pragma_get(:foreign_keys).to_i == 1 if sqlite_version >= 30619
+      end
+      
+      # Set the foreign_keys PRAGMA using the given boolean value, if using
+      # SQLite 3.6.19+.  If not using 3.6.19+, no error is raised. See pragma_set.
+      # Consider using the :foreign_keys Database option instead.
+      def foreign_keys=(value)
+        pragma_set(:foreign_keys, !!value ? 'on' : 'off') if sqlite_version >= 30619
+      end
 
       # Return a hash containing index information. Hash keys are index name symbols.
       # Values are subhashes with two keys, :columns and :unique.  The value of :columns
@@ -61,13 +78,30 @@ module Sequel
       end
       
       # Set the value of the given PRAGMA to value.
+      #
+      # This method is not thread safe, and will not work correctly if there
+      # are multiple connections in the Database's connection pool. PRAGMA
+      # modifications should be done when the connection is created, using
+      # an option provided when creating the Database object.
       def pragma_set(name, value)
         execute_ddl("PRAGMA #{name} = #{value}")
       end
       
-      # SQLite supports savepoints
+      # The version of the server as an integer, where 3.6.19 = 30619.
+      # If the server version can't be determined, 0 is used.
+      def sqlite_version
+        return @sqlite_version if defined?(@sqlite_version)
+        @sqlite_version = begin
+          v = get{sqlite_version{}}
+          [10000, 100, 1].zip(v.split('.')).inject(0){|a, m| a + m[0] * Integer(m[1])}
+        rescue
+          0
+        end
+      end
+      
+      # SQLite 3.6.8+ supports savepoints. 
       def supports_savepoints?
-        true
+        sqlite_version >= 30608
       end
 
       # A symbol signifying the value of the synchronous PRAGMA.
@@ -75,7 +109,8 @@ module Sequel
         SYNCHRONOUS[pragma_get(:synchronous).to_i]
       end
       
-      # Set the synchronous PRAGMA using the given symbol (:off, :normal, or :full).
+      # Set the synchronous PRAGMA using the given symbol (:off, :normal, or :full). See pragma_set.
+      # Consider using the :synchronous Database option instead.
       def synchronous=(value)
         value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
         pragma_set(:synchronous, value)
@@ -95,7 +130,8 @@ module Sequel
         TEMP_STORE[pragma_get(:temp_store).to_i]
       end
       
-      # Set the temp_store PRAGMA using the given symbol (:default, :file, or :memory).
+      # Set the temp_store PRAGMA using the given symbol (:default, :file, or :memory). See pragma_set.
+      # Consider using the :temp_store Database option instead.
       def temp_store=(value)
         value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
         pragma_set(:temp_store, value)
@@ -195,6 +231,21 @@ module Sequel
       def identifier_output_method_default
         nil
       end
+      
+      # Array of PRAGMA SQL statements based on the Database options that should be applied to
+      # new connections.
+      def connection_pragmas
+        ps = []
+        v = typecast_value_boolean(opts.fetch(:foreign_keys, 1))
+        ps << "PRAGMA foreign_keys = #{v ? 1 : 0}"
+        [[:auto_vacuum, AUTO_VACUUM], [:synchronous, SYNCHRONOUS], [:temp_store, TEMP_STORE]].each do |prag, con|
+          if v = opts[prag]
+            raise(Error, "Value for PRAGMA #{prag} not supported, should be one of #{con.join(', ')}") unless v = con.index(v.to_sym)
+            ps << "PRAGMA #{prag} = #{v}"
+          end
+        end
+        ps
+      end
 
       # Parse the output of the table_info pragma
       def parse_pragma(table_name, opts)
@@ -265,11 +316,6 @@ module Sequel
         @opts[:where] ? super : filter(1=>1).delete
       end
       
-      # SQLite does not support DISTINCT ON
-      def supports_distinct_on?
-        false
-      end
-      
       # Return an array of strings specifying a query explanation for a SELECT of the
       # current dataset.
       def explain

data/lib/sequel/adapters/sqlite.rb

@@ -37,6 +37,8 @@ module Sequel
         db.busy_timeout(opts.fetch(:timeout, 5000))
         db.type_translation = true
         
+        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
+        
         # Handle datetimes with Sequel.datetime_class
         prok = proc do |t,v|
           v = Time.at(v.to_i).iso8601 if UNIX_EPOCH_TIME_FORMAT.match(v)
@@ -70,32 +72,37 @@ module Sequel
       
       # Run the given SQL with the given arguments and return the number of changed rows.
       def execute_dui(sql, opts={})
-        _execute(sql, opts){|conn| conn.execute_batch(sql, opts[:arguments]); conn.changes}
+        _execute(opts){|conn| log_yield(sql, opts[:arguments]){conn.execute_batch(sql, opts[:arguments])}; conn.changes}
       end
       
       # Run the given SQL with the given arguments and return the last inserted row id.
       def execute_insert(sql, opts={})
-        _execute(sql, opts){|conn| conn.execute(sql, opts[:arguments]); conn.last_insert_row_id}
+        _execute(opts){|conn| log_yield(sql, opts[:arguments]){conn.execute(sql, opts[:arguments])}; conn.last_insert_row_id}
       end
       
       # Run the given SQL with the given arguments and yield each row.
-      def execute(sql, opts={}, &block)
-        _execute(sql, opts){|conn| conn.query(sql, opts[:arguments], &block)}
+      def execute(sql, opts={})
+        _execute(opts) do |conn|
+          begin
+            yield(result = log_yield(sql, opts[:arguments]){conn.query(sql, opts[:arguments])})
+          ensure
+            result.close if result
+          end
+        end
       end
       
       # Run the given SQL with the given arguments and return the first value of the first row.
       def single_value(sql, opts={})
-        _execute(sql, opts){|conn| conn.get_first_value(sql, opts[:arguments])}
+        _execute(opts){|conn| log_yield(sql, opts[:arguments]){conn.get_first_value(sql, opts[:arguments])}}
       end
       
       private
       
-      # Log the SQL and the arguments, and yield an available connection.  Rescue
+      # Yield an available connection.  Rescue
       # any SQLite3::Exceptions and turn them into DatabaseErrors.
-      def _execute(sql, opts)
+      def _execute(opts, &block)
         begin
-          log_info(sql, opts[:arguments])
-          synchronize(opts[:server]){|conn| yield conn}
+          synchronize(opts[:server], &block)
         rescue SQLite3::Exception => e
           raise_error(e)
         end

data/lib/sequel/connection_pool.rb

@@ -60,12 +60,16 @@ class Sequel::ConnectionPool
   # Instantiates a connection pool with the given options.  The block is called
   # with a single symbol (specifying the server/shard to use) every time a new
   # connection is needed.  The following options are respected for all connection
-  # pools:  #
+  # pools:
+  # * :after_connect - The proc called after each new connection is made, with the
+  #   connection object, useful for customizations that you want to apply to all
+  #   connections.
   # * :disconnection_proc - The proc called when removing connections from the pool,
   #   which is passed the connection to disconnect.
   def initialize(opts={}, &block)
     raise(Sequel::Error, "No connection proc specified") unless @connection_proc = block
     @disconnection_proc = opts[:disconnection_proc]
+    @after_connect = opts[:after_connect]
   end
   
   # Alias for size, not aliased directly for ease of subclass implementation
@@ -85,6 +89,7 @@ class Sequel::ConnectionPool
   def make_new(server)
     begin
       conn = @connection_proc.call(server)
+      @after_connect.call(conn) if @after_connect
     rescue Exception=>exception
       raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
     end

data/lib/sequel/connection_pool/single.rb

@@ -10,6 +10,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   
   # Disconnect the connection from the database.
   def disconnect(opts=nil, &block)
+    return unless @conn
     block ||= @disconnection_proc
     block.call(@conn) if block
     @conn = nil

data/lib/sequel/core.rb

@@ -46,6 +46,9 @@
 #
 # You can set the SEQUEL_NO_CORE_EXTENSIONS constant or environment variable to have
 # Sequel not extend the core classes.
+#
+# For a more expanded introduction, see the {README}[link:files/README_rdoc.html].
+# For a quicker introduction, see the {cheat sheet}[link:files/doc/cheat_sheet_rdoc.html].
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
@@ -117,6 +120,9 @@ module Sequel
   # closed when the block exits.  For example:
   #
   #   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
+  # 
+  # For details, see the {"Connecting to a Database" guide}[link:files/doc/opening_databases_rdoc.html].
+  # To set up a master/slave or sharded database connection, see the {"Master/Slave Databases and Sharding" guide}[link:files/doc/sharding_rdoc.html].
   def self.connect(*args, &block)
     Database.connect(*args, &block)
   end
@@ -280,7 +286,6 @@ module Sequel
   
   require(%w"metaprogramming sql connection_pool exceptions dataset database timezones version")
   require(%w"schema_generator schema_methods schema_sql", 'database')
-  require(%w"actions convenience features graph prepared_statements query sql", 'dataset')
   require('core_sql') if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
 
   # Add the database adapter class methods to Sequel via metaprogramming

data/lib/sequel/database.rb

@@ -50,6 +50,10 @@ module Sequel
     # The default schema to use, generally should be nil.
     attr_accessor :default_schema
 
+    # Numeric specifying the duration beyond which queries are logged at warn
+    # level instead of info level.
+    attr_accessor :log_warn_duration
+
     # Array of SQL loggers to use for this database
     attr_accessor :loggers
     
@@ -82,13 +86,14 @@ module Sequel
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
       @loggers = Array(@opts[:logger]) + Array(@opts[:loggers])
+      self.log_warn_duration = @opts[:log_warn_duration]
       @opts[:disconnection_proc] ||= proc{|conn| disconnect_connection(conn)}
       block ||= proc{|server| connect(server)}
       @opts[:servers] = {} if @opts[:servers].is_a?(String)
       
-      @opts[:single_threaded] = @single_threaded = @opts.include?(:single_threaded) ? typecast_value_boolean(@opts[:single_threaded]) : @@single_threaded
+      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, @@single_threaded))
       @schemas = {}
-      @default_schema = opts.include?(:default_schema) ? @opts[:default_schema] : default_schema_default
+      @default_schema = @opts.fetch(:default_schema, default_schema_default)
       @prepared_statements = {}
       @transactions = []
       @identifier_input_method = nil
@@ -129,7 +134,7 @@ module Sequel
     end
     
     # Connects to a database.  See Sequel.connect.
-    def self.connect(conn_string, opts = {}, &block)
+    def self.connect(conn_string, opts = {})
       case conn_string
       when String
         if match = /\A(jdbc|do):/o.match(conn_string)
@@ -157,18 +162,17 @@ module Sequel
         m[k.to_sym] = v
         m
       end
-      if block
-        result = nil
-        begin
-          result = yield(db = c.new(opts))
-        ensure
+      begin
+        db = c.new(opts)
+        db.test_connection if opts[:test] && db.send(:typecast_value_boolean, opts[:test])
+        result = yield(db) if block_given?
+      ensure
+        if block_given?
           db.disconnect if db
           ::Sequel::DATABASES.delete(db)
         end
-        result
-      else
-        c.new(opts)
       end
+      block_given? ? result : db
     end
     
     # The method to call on identifiers going into the database
@@ -389,7 +393,7 @@ module Sequel
     def identifier_input_method
       case @identifier_input_method
       when nil
-        @identifier_input_method = @opts.include?(:identifier_input_method) ? @opts[:identifier_input_method] : (@@identifier_input_method.nil? ? identifier_input_method_default : @@identifier_input_method)
+        @identifier_input_method = @opts.fetch(:identifier_input_method, (@@identifier_input_method.nil? ? identifier_input_method_default : @@identifier_input_method))
         @identifier_input_method == "" ? nil : @identifier_input_method
       when ""
         nil
@@ -408,7 +412,7 @@ module Sequel
     def identifier_output_method
       case @identifier_output_method
       when nil
-        @identifier_output_method = @opts.include?(:identifier_output_method) ? @opts[:identifier_output_method] : (@@identifier_output_method.nil? ? identifier_output_method_default : @@identifier_output_method)
+        @identifier_output_method = @opts.fetch(:identifier_output_method, (@@identifier_output_method.nil? ? identifier_output_method_default : @@identifier_output_method))
         @identifier_output_method == "" ? nil : @identifier_output_method
       when ""
         nil
@@ -435,11 +439,25 @@ module Sequel
       schema_utility_dataset.literal(v)
     end
 
-    # Log a message at level info to all loggers.  All SQL logging
-    # goes through this method.
+    # Log a message at level info to all loggers.
     def log_info(message, args=nil)
-      message = "#{message}; #{args.inspect}" if args
-      @loggers.each{|logger| logger.info(message)}
+      log_each(:info, args ? "#{message}; #{args.inspect}" : message)
+    end
+
+    # Yield to the block, logging any errors at error level to all loggers,
+    # and all other queries with the duration at warn or info level.
+    def log_yield(sql, args=nil)
+      return yield if @loggers.empty?
+      sql = "#{sql}; #{args.inspect}" if args
+      start = Time.now
+      begin
+        yield
+      rescue => e
+        log_each(:error, "#{e.class}: #{e.message.strip}: #{sql}")
+        raise
+      ensure
+        log_duration(Time.now - start, sql) unless e
+      end
     end
 
     # Remove any existing loggers and just use the given logger.
@@ -456,7 +474,7 @@ module Sequel
     # Returns true if the database quotes identifiers.
     def quote_identifiers?
       return @quote_identifiers unless @quote_identifiers.nil?
-      @quote_identifiers = @opts.include?(:quote_identifiers) ? @opts[:quote_identifiers] : (@@quote_identifiers.nil? ? quote_identifiers_default : @@quote_identifiers)
+      @quote_identifiers = @opts.fetch(:quote_identifiers, (@@quote_identifiers.nil? ? quote_identifiers_default : @@quote_identifiers))
     end
     
     # Dynamically remove existing servers from the connection pool. Intended for
@@ -818,8 +836,19 @@ module Sequel
     # 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)
+      log_yield(sql){conn.send(connection_execute_method, sql)}
+    end
+
+    # Log message with message prefixed by duration at info level, or
+    # warn level if duration is greater than log_warn_duration.
+    def log_duration(duration, message)
+      log_each((lwd = log_warn_duration and duration >= lwd) ? :warn : :info, "(#{sprintf('%0.6fs', duration)}) #{message}")
+    end
+
+    # Log message at level (which should be :error, :warn, or :info)
+    # to all loggers.
+    def log_each(level, message)
+      @loggers.each{|logger| logger.send(level, message)}
     end
 
     # Return a dataset that uses the default identifier input and output methods
@@ -924,11 +953,11 @@ module Sequel
         :boolean
       when /\A(real|float|double( precision)?)\z/io
         :float
-      when /\A(((numeric|decimal)(\(\d+,\d+\))?)|(small)?money)\z/io
-        :decimal
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+)\))?)|(?:small)?money)\z/io
+        $1 && $1 == '0' ? :integer : :decimal
       when /bytea|blob|image|(var)?binary/io
         :blob
-      when /\Aenum/
+      when /\Aenum/io
         :enum
       end
     end