sequel_core 1.5.1 → 2.0.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -10,9 +10,7 @@ module Sequel
       end
 
       def connect
-        if @opts[:database].nil? || @opts[:database].empty?
-          @opts[:database] = ':memory:'
-        end
+        @opts[:database] = ':memory:' if @opts[:database].blank?
         db = ::SQLite3::Database.new(@opts[:database])
         db.busy_timeout(@opts.fetch(:timeout, 5000))
         db.type_translation = true
@@ -38,31 +36,39 @@ module Sequel
       end
     
       def execute(sql)
-        @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.execute_batch(sql); conn.changes}
-      rescue RuntimeError => e
-        raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        begin
+          log_info(sql)
+          @pool.hold {|conn| conn.execute_batch(sql); conn.changes}
+        rescue SQLite3::Exception => e
+          raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        end
       end
       
       def execute_insert(sql)
-        @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.execute(sql); conn.last_insert_row_id}
-      rescue RuntimeError => e
-        raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        begin
+          log_info(sql)
+          @pool.hold {|conn| conn.execute(sql); conn.last_insert_row_id}
+        rescue SQLite3::Exception => e
+          raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        end
       end
       
       def single_value(sql)
-        @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.get_first_value(sql)}
-      rescue RuntimeError => e
-        raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        begin
+          log_info(sql)
+          @pool.hold {|conn| conn.get_first_value(sql)}
+        rescue SQLite3::Exception => e
+          raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        end
       end
       
       def execute_select(sql, &block)
-        @logger.info(sql) if @logger
-        @pool.hold {|conn| conn.query(sql, &block)}
-      rescue RuntimeError => e
-        raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        begin
+          log_info(sql)
+          @pool.hold {|conn| conn.query(sql, &block)}
+        rescue SQLite3::Exception => e
+          raise Error::InvalidStatement, "#{sql}\r\n#{e.message}"
+        end
       end
       
       def pragma_get(name)
@@ -124,20 +130,64 @@ module Sequel
             result = nil
             conn.transaction {result = yield(conn)}
             result
-          rescue => e
-            raise e unless Error::Rollback === e
+          rescue ::Exception => e
+            raise (SQLite3::Exception === e ? Error.new(e.message) : e) unless Error::Rollback === e
+          end
+        end
+      end
+      
+      private
+      def connection_pool_default_options
+        o = super.merge(:pool_reuse_connections=>:always, :pool_convert_exceptions=>false)
+        # Default to only a single connection if a memory database is used,
+        # because otherwise each connection will get a separate database
+        o[:max_connections] = 1 if @opts[:database] == ':memory:' || @opts[:database].blank?
+        o
+      end
+
+      SCHEMA_TYPE_RE = /\A(\w+)\((\d+)\)\z/
+      def schema_parse_table(table_name, opts)
+        rows = self["PRAGMA table_info('#{::SQLite3::Database.quote(table_name.to_s)}')"].collect do |row|
+          row.delete(:cid)
+          row[:column] = row.delete(:name)
+          row[:allow_null] = row.delete(:notnull).to_i == 0 ? 'YES' : 'NO'
+          row[:default] = row.delete(:dflt_value)
+          row[:primary_key] = row.delete(:pk).to_i == 1 ? true : false 
+          row[:db_type] = row.delete(:type)
+          if m = SCHEMA_TYPE_RE.match(row[:db_type])
+            row[:db_type] = m[1]
+            row[:max_chars] = m[2].to_i
+          else
+             row[:max_chars] = nil
           end
+          row[:numeric_precision] = nil
+          row
         end
+        schema_parse_rows(rows)
+      end
+
+      def schema_parse_tables(opts)
+        schemas = {}
+        tables.each{|table| schemas[table] = schema_parse_table(table, opts)}
+        schemas
       end
     end
     
     class Dataset < Sequel::Dataset
-      def quote_column_ref(c); "`#{c}`"; end
+      def quoted_identifier(c)
+        "`#{c}`"
+      end
 
       def literal(v)
         case v
+        when LiteralString
+          v
+        when String
+          "'#{::SQLite3::Database.quote(v)}'"
         when Time
           literal(v.iso8601)
+        when Date, DateTime
+          literal(v.to_s)
         else
           super
         end

data/lib/sequel_core/connection_pool.rb

@@ -1,70 +1,118 @@
-require 'thread'
-
 # A ConnectionPool manages access to database connections by keeping
 # multiple connections and giving threads exclusive access to each
 # connection.
 class ConnectionPool
-  attr_reader :mutex
+  # An array of connections currently being used
+  attr_reader :allocated
+  
+  # An array of connections opened but not currently used
+  attr_reader :available_connections
+  
+  # The proc used to create a new database connection.
+  attr_accessor :connection_proc
   
+  # The total number of connections opened, should
+  # be equal to available_connections.length +
+  # allocated.length
+  attr_reader :created_count
+  alias_method :size, :created_count
+
   # The maximum number of connections.
   attr_reader :max_size
   
-  # The proc used to create a new connection.
-  attr_accessor :connection_proc
+  # The mutex that protects access to the other internal vairables.  You must use
+  # this if you want to manipulate the variables safely.
+  attr_reader :mutex
   
-  attr_reader :available_connections, :allocated, :created_count
 
   # Constructs a new pool with a maximum size. If a block is supplied, it
   # is used to create new connections as they are needed.
   #
-  #   pool = ConnectionPool.new(10) {MyConnection.new(opts)}
+  #   pool = ConnectionPool.new(:max_connections=>10) {MyConnection.new(opts)}
   #
   # The connection creation proc can be changed at any time by assigning a 
   # Proc to pool#connection_proc.
   #
-  #   pool = ConnectionPool.new(10)
+  #   pool = ConnectionPool.new(:max_connections=>10)
   #   pool.connection_proc = proc {MyConnection.new(opts)}
-  def initialize(max_size = 4, &block)
-    @max_size = max_size
+  #
+  # The connection pool takes the following options:
+  #
+  # * :max_connections - The maximum number of connections the connection pool
+  #   will open (default 4)
+  # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
+  #   to RuntimeError exceptions (default true)
+  # * :pool_reuse_connections - Which strategy to follow in regards to reusing connections:
+  #   * :always - Always reuse a connection that belongs to the same thread
+  #   * :allow - Only reuse a connection that belongs to the same thread if
+  #     another cannot be acquired immediately (default)
+  #   * :last_resort - Only reuse a connection that belongs to the same thread if
+  #     the pool timeout has expired
+  #   * :never - Never reuse a connection that belongs to the same thread
+  # * :pool_sleep_time - The amount of time to sleep before attempting to acquire
+  #   a connection again (default 0.001)
+  # * :pool_timeout - The amount of seconds to wait to acquire a connection
+  #   before raising a PoolTimeoutError (default 5)
+  def initialize(opts = {}, &block)
+    @max_size = opts[:max_connections] || 4
     @mutex = Mutex.new
     @connection_proc = block
 
     @available_connections = []
-    @allocated = {}
+    @allocated = []
     @created_count = 0
+    @timeout = opts[:pool_timeout] || 5
+    @sleep_time = opts[:pool_sleep_time] || 0.001
+    @reuse_connections = opts[:pool_reuse_connections] || :allow
+    @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
   end
   
-  # Returns the number of created connections.
-  def size
-    @created_count
-  end
-  
-  # Assigns a connection to the current thread, yielding the connection
-  # to the supplied block.
+  # Chooses the first available connection, or if none are available,
+  # creates a new connection.  Passes the connection to the supplied block:
   # 
   #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
   # 
-  # Pool#hold is re-entrant, meaning it can be called recursively in
-  # the same thread without blocking.
+  # Pool#hold can be re-entrant, meaning it can be called recursively in
+  # the same thread without blocking if the :pool_reuse_connections option
+  # was set to :always or :allow.  Depending on the :pool_reuse_connections
+  # option you may get the connection currently used by the thread or a new connection.
   #
-  # If no connection is available, Pool#hold will block until a connection
-  # is available.
+  # If no connection is immediately available and the pool is already using the maximum
+  # number of connections, Pool#hold will block until a connection
+  # is available or the timeout expires.  If the timeout expires before a
+  # connection can be acquired, a Sequel::Error::PoolTimeoutError is 
+  # raised.
   def hold
-    t = Thread.current
-    if (conn = owned_connection(t))
-      return yield(conn)
-    end
-    while !(conn = acquire(t))
-      sleep 0.001
-    end
     begin
-      yield conn
-    ensure
-      release(t)
+      t = Thread.current
+      time = Time.new
+      timeout = time + @timeout
+      sleep_time = @sleep_time
+      reuse = @reuse_connections
+      if (reuse == :always) && (conn = owned_connection(t))
+        return yield(conn)
+      end
+      reuse = reuse == :allow ? true : false
+      until conn = acquire(t)
+        if reuse && (conn = owned_connection(t))
+          return yield(conn)
+        end
+        if Time.new > timeout
+          if (@reuse_connections == :last_resort) && (conn = owned_connection(t))
+            return yield(conn)
+          end
+          raise(::Sequel::Error::PoolTimeoutError)
+        end
+        sleep sleep_time
+      end
+      begin
+        yield conn
+      ensure
+        release(t, conn)
+      end
+    rescue Exception => e
+      raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
     end
-  rescue Exception => e
-    # if the error is not a StandardError it is converted into RuntimeError.
-    raise e.is_a?(StandardError) ? e : e.message
   end
   
   # Removes all connection currently available, optionally yielding each 
@@ -80,65 +128,84 @@ class ConnectionPool
   end
   
   private
-    # Returns the connection owned by the supplied thread, if any.
-    def owned_connection(thread)
-      @mutex.synchronize {@allocated[thread]}
+
+  # Returns the connection owned by the supplied thread, if any.
+  def owned_connection(thread)
+    @mutex.synchronize do 
+      x = @allocated.assoc(thread)
+      x[1] if x
     end
-    
-    # Assigns a connection to the supplied thread, if one is available.
-    def acquire(thread)
-      @mutex.synchronize do
-        if conn = available
-          @allocated[thread] = conn
-        end
+  end
+  
+  # Assigns a connection to the supplied thread, if one is available.
+  def acquire(thread)
+    @mutex.synchronize do
+      if conn = available
+        @allocated << [thread, conn]
+        conn
       end
     end
-    
-    # Returns an available connection. If no connection is available,
-    # tries to create a new connection.
-    def available
-      @available_connections.pop || make_new
-    end
-    
-    # Creates a new connection if the size of the pool is less than the
-    # maximum size.
-    def make_new
-      if @created_count < @max_size
-        @created_count += 1
-        @connection_proc ? @connection_proc.call : \
-          (raise Error, "No connection proc specified")
-      end
+  end
+  
+  # Returns an available connection. If no connection is available,
+  # tries to create a new connection.
+  def available
+    @available_connections.pop || make_new
+  end
+  
+  # Creates a new connection if the size of the pool is less than the
+  # maximum size.
+  def make_new
+    if @created_count < @max_size
+      @created_count += 1
+      @connection_proc ? @connection_proc.call : \
+        (raise Error, "No connection proc specified")
     end
-    
-    # Releases the connection assigned to the supplied thread.
-    def release(thread)
-      @mutex.synchronize do
-        @available_connections << @allocated[thread]
-        @allocated.delete(thread)
-      end
+  end
+  
+  # Releases the connection assigned to the supplied thread.
+  def release(thread, conn)
+    @mutex.synchronize do
+      @allocated.delete([thread, conn])
+      @available_connections << conn
     end
+  end
 end
 
 # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
 # in single-threaded applications. ConnectionPool imposes a substantial
 # performance penalty, so SingleThreadedPool is used to gain some speed.
+#
+# Note that using a single threaded pool with some adapters can cause
+# errors in certain cases, see Sequel.single_threaded=.
 class SingleThreadedPool
+  # The single database connection for the pool
   attr_reader :conn
+
+  # The proc used to create a new database connection
   attr_writer :connection_proc
   
   # Initializes the instance with the supplied block as the connection_proc.
-  def initialize(&block)
+  #
+  # The single threaded pool takes the following options:
+  #
+  # * :pool_convert_exceptions - Whether to convert non-StandardError based exceptions
+  #   to RuntimeError exceptions (default true)
+  def initialize(opts={}, &block)
     @connection_proc = block
+    @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
   end
   
   # Yields the connection to the supplied block. This method simulates the
   # ConnectionPool#hold API.
   def hold
-    @conn ||= @connection_proc.call
-    yield @conn
-  rescue Exception => e
-    # if the error is not a StandardError it is converted into RuntimeError.
-    raise e.is_a?(StandardError) ? e : e.message
+    begin
+      @conn ||= @connection_proc.call
+      yield @conn
+    rescue Exception => e
+      # if the error is not a StandardError it is converted into RuntimeError.
+      raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
+    end
   end
   
   # Disconnects from the database. Once a connection is requested using

data/lib/sequel_core/core_ext.rb

@@ -1,66 +1,201 @@
-# Enumerable extensions.
-module Enumerable
-  # Invokes the specified method for each item, along with the supplied
-  # arguments.
-  def send_each(sym, *args)
-    each {|i| i.send(sym, *args)}
-  end
-end
-
-# Range extensions
-class Range
-  # Returns the interval between the beginning and end of the range.
-  def interval
-    last - first
-  end
-end
-
-# Object extensions
-class Object
-  # Returns true if the object is a object of one of the classes
-  def is_one_of?(*classes)
-    classes.each {|c| return c if is_a?(c)}
-    nil
-  end
-
-  # Objects are blank if they respond true to empty?
-  def blank?
-    nil? || (respond_to?(:empty?) && empty?)
-  end
-end
-
-class Numeric
-  # Numerics are never blank (not even 0)
-  def blank?
-    false
-  end
-end
-
-class NilClass
-  # nil is always blank
-  def blank?
-    true
-  end
-end
-
-class TrueClass
-  # true is never blank
-  def blank?
-    false
-  end
-end
-
-class FalseClass
-  # false is always blank
-  def blank?
-    true
-  end
-end
-
-class String
-  BLANK_STRING_REGEXP = /\A\s*\z/
-  # Strings are blank if they are empty or include only whitespace
-  def blank?
-    empty? || BLANK_STRING_REGEXP.match(self)
-  end
-end
+# This file includes augmentations to the core ruby classes the Sequel uses,
+# which are unrelated to the creation of SQL.  It includes common
+# idioms to reduce the amount of code duplication.
+
+class Array
+  # True if the array is not empty and all of its elements are
+  # arrays of size 2.  This is used to determine if the array
+  # could be a specifier of conditions, used similarly to a hash
+  # but allowing for duplicate keys.
+  #
+  #    hash.to_a.all_two_pairs? # => true unless hash is empty
+  def all_two_pairs?
+    !empty? && all?{|i| (Array === i) && (i.length == 2)}
+  end
+
+  # Removes and returns the last member of the array if it is a hash. Otherwise,
+  # an empty hash is returned This method is useful when writing methods that
+  # take an options hash as the last parameter. For example:
+  #
+  #   def validate_each(*args, &block)
+  #     opts = args.extract_options!
+  #     ...
+  #   end
+  def extract_options!
+    last.is_a?(Hash) ? pop : {}
+  end
+end
+
+module Enumerable
+  # Invokes the specified method for each item, along with the supplied
+  # arguments.
+  def send_each(sym, *args)
+    each{|i| i.send(sym, *args)}
+  end
+end
+
+class FalseClass
+  # false is always blank
+  def blank?
+    true
+  end
+end
+
+# Add some metaprogramming methods to avoid class << self
+class Module
+  # Defines an instance method within a class/module
+  def class_def(name, &block)
+    class_eval{define_method(name, &block)}
+  end 
+
+  private
+
+  # Define instance method(s) that calls class method(s) of the
+  # same name. Replaces the construct:
+  #
+  #   define_method(meth){self.class.send(meth)}
+  def class_attr_reader(*meths)
+    meths.each{|meth| define_method(meth){self.class.send(meth)}}
+  end
+
+  # Create an alias for a singleton/class method.
+  # Replaces the construct:
+  #
+  #   class << self
+  #     alias_method to, from
+  #   end
+  def metaalias(to, from)
+    metaclass.instance_eval{alias_method to, from}
+  end
+  
+  # Make a singleton/class attribute accessor method(s).
+  # Replaces the construct:
+  #
+  #   class << self
+  #     attr_accessor *meths
+  #   end
+  def metaattr_accessor(*meths)
+    metaclass.instance_eval{attr_accessor(*meths)}
+  end
+
+  # Make a singleton/class method(s) private.
+  # Make a singleton/class attribute reader method(s).
+  # Replaces the construct:
+  #
+  #   class << self
+  #     attr_reader *meths
+  #   end
+  def metaattr_reader(*meths)
+    metaclass.instance_eval{attr_reader(*meths)}
+  end
+
+  # Make a singleton/class method(s) private.
+  # Replaces the construct:
+  #
+  #   class << self
+  #     private *meths
+  #   end
+  def metaprivate(*meths)
+    metaclass.instance_eval{private(*meths)}
+  end
+end
+
+# Helpers from Metaid and a bit more
+class Object
+  # Objects are blank if they respond true to empty?
+  def blank?
+    respond_to?(:empty?) && empty?
+  end
+
+  # Returns true if the object is an instance of one of the classes
+  def is_one_of?(*classes)
+    !!classes.find{|c| is_a?(c)}
+  end
+
+  # Add methods to the object's metaclass
+  def meta_def(name, &block)
+    meta_eval{define_method(name, &block)}
+  end 
+
+  # Evaluate the block in the context of the object's metaclass
+  def meta_eval(&block)
+    metaclass.instance_eval(&block)
+  end 
+
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self
+      self
+    end 
+  end 
+end
+
+class NilClass
+  # nil is always blank
+  def blank?
+    true
+  end
+end
+
+class Numeric
+  # Numerics are never blank (not even 0)
+  def blank?
+    false
+  end
+end
+
+class Range
+  # Returns the interval between the beginning and end of the range.
+  #
+  # For exclusive ranges, is one less than the inclusive range:
+  #
+  #   (0..10).interval # => 10
+  #   (0...10).interval # => 9
+  #
+  # Only works for numeric ranges, for other ranges the result is undefined,
+  # and the method may raise an error.
+  def interval
+    last - first - (exclude_end? ? 1 : 0)
+  end
+end
+
+class String
+  # Strings are blank if they are empty or include only whitespace
+  def blank?
+    strip.empty?
+  end
+
+  # Converts a string into a Date object.
+  def to_date
+    begin
+      Date.parse(self)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid date value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a DateTime object.
+  def to_datetime
+    begin
+      DateTime.parse(self)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid date value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Time object.
+  def to_time
+    begin
+      Time.parse(self)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
+    end
+  end
+end
+
+class TrueClass
+  # true is never blank
+  def blank?
+    false
+  end
+end