sequel 2.2.0 → 2.3.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -0,0 +1,138 @@
+require 'sqlite3'
+require 'sequel_core/adapters/shared/sqlite'
+
+module Sequel
+  module SQLite
+    class Database < Sequel::Database
+      include ::Sequel::SQLite::DatabaseMethods
+      
+      set_adapter_scheme :sqlite
+      
+      def self.uri_to_options(uri) # :nodoc:
+        { :database => (uri.host.nil? && uri.path == '/') ? nil : "#{uri.host}#{uri.path}" }
+      end
+
+      private_class_method :uri_to_options
+
+      def connect
+        @opts[:database] = ':memory:' if @opts[:database].blank?
+        db = ::SQLite3::Database.new(@opts[:database])
+        db.busy_timeout(@opts.fetch(:timeout, 5000))
+        db.type_translation = true
+        # fix for timestamp translation
+        db.translator.add_translator("timestamp") do |t, v|
+          v =~ /^\d+$/ ? Time.at(v.to_i) : Time.parse(v) 
+        end 
+        db
+      end
+      
+      def dataset(opts = nil)
+        SQLite::Dataset.new(self, opts)
+      end
+      
+      def disconnect
+        @pool.disconnect {|c| c.close}
+      end
+    
+      def execute(sql)
+        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)
+        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)
+        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)
+        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 transaction(&block)
+        @pool.hold do |conn|
+          if conn.transaction_active?
+            return yield(conn)
+          end
+          begin
+            result = nil
+            conn.transaction {result = yield(conn)}
+            result
+          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_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
+    end
+    
+    class Dataset < Sequel::Dataset
+      include ::Sequel::SQLite::DatasetMethods
+      
+      EXPLAIN = 'EXPLAIN %s'.freeze
+      
+      def explain
+        res = []
+        @db.result_set(EXPLAIN % select_sql(opts), nil) {|r| res << r}
+        res
+      end
+
+      def fetch_rows(sql)
+        @db.execute_select(sql) do |result|
+          @columns = result.columns.map {|c| c.to_sym}
+          column_count = @columns.size
+          result.each do |values|
+            row = {}
+            column_count.times {|i| row[@columns[i]] = values[i]}
+            yield row
+          end
+        end
+      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
+      end
+    end
+  end
+end

data/lib/sequel_core/connection_pool.rb

@@ -0,0 +1,194 @@
+# A ConnectionPool manages access to database connections by keeping
+# multiple connections and giving threads exclusive access to each
+# connection.
+class Sequel::ConnectionPool
+  # A hash of connections currently being used, key is the Thread,
+  # value is the connection.
+  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 mutex that protects access to the other internal vairables.  You must use
+  # this if you want to manipulate the variables safely.
+  attr_reader :mutex
+  
+
+  # 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(: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(:max_connections=>10)
+  #   pool.connection_proc = proc {MyConnection.new(opts)}
+  #
+  # 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_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 = {}
+    @created_count = 0
+    @timeout = opts[:pool_timeout] || 5
+    @sleep_time = opts[:pool_sleep_time] || 0.001
+    @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
+  end
+  
+  # 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.
+  #
+  # 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
+    begin
+      t = Thread.current
+      time = Time.new
+      timeout = time + @timeout
+      sleep_time = @sleep_time
+      if conn = owned_connection(t)
+        return yield(conn)
+      end
+      until conn = acquire(t)
+        raise(::Sequel::Error::PoolTimeoutError) if Time.new > timeout
+        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
+  end
+  
+  # Removes all connection currently available, optionally yielding each 
+  # connection to the given block. This method has the effect of 
+  # disconnecting from the database. Once a connection is requested using
+  # #hold, the connection pool creates new connections to the database.
+  def disconnect(&block)
+    @mutex.synchronize do
+      @available_connections.each {|c| block[c]} if block
+      @available_connections = []
+      @created_count = @allocated.size
+    end
+  end
+  
+  private
+
+  # Returns the connection owned by the supplied thread, if any.
+  def owned_connection(thread)
+    @mutex.synchronize{@allocated[thread]}
+  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
+  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
+  
+  # Releases the connection assigned to the supplied thread.
+  def release(thread, conn)
+    @mutex.synchronize do
+      @allocated.delete(thread)
+      @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 Sequel::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.
+  #
+  # 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
+    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
+  # #hold, the connection is reestablished.
+  def disconnect(&block)
+    block[@conn] if block && @conn
+    @conn = nil
+  end
+end

data/lib/sequel_core/core_ext.rb

@@ -0,0 +1,203 @@
+if RUBY_VERSION < '1.9.0'
+  class Hash
+    alias key index
+  end
+end
+
+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)
+    meta_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)
+    meta_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)
+    meta_eval{attr_reader(*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 or DateTime object, depending on the
+  # value of Sequel.datetime_class
+  def to_sequel_time
+    begin
+      Sequel.datetime_class.parse(self)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid time 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