colincasey-sequel 2.10.0 → 2.10.1

data/lib/sequel_core/connection_pool.rb

@@ -0,0 +1,258 @@
+# A ConnectionPool manages access to database connections by keeping
+# multiple connections and giving threads exclusive access to each
+# connection.
+class Sequel::ConnectionPool
+  # The proc used to create a new database connection.
+  attr_accessor :connection_proc
+
+  # The proc used to disconnect a database connection.
+  attr_accessor :disconnection_proc
+
+  # 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)
+  # * :servers - A hash of servers to use.  Keys should be symbols.  If not
+  #   present, will use a single :default server.  The server name symbol will
+  #   be passed to the connection_proc.
+  def initialize(opts = {}, &block)
+    @max_size = opts[:max_connections] || 4
+    @mutex = Mutex.new
+    @connection_proc = block
+    @disconnection_proc = opts[:disconnection_proc]
+    @servers = [:default]
+    @servers += opts[:servers].keys - @servers if opts[:servers] 
+    @available_connections = Hash.new{|h,k| h[:default]}
+    @allocated = Hash.new{|h,k| h[:default]}
+    @created_count = Hash.new{|h,k| h[:default]}
+    @servers.each do |s|
+      @available_connections[s] = []
+      @allocated[s] = {}
+      @created_count[s] = 0
+    end
+    @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
+  
+  # A hash of connections currently being used for the given server, key is the
+  # Thread, value is the connection.
+  def allocated(server=:default)
+    @allocated[server]
+  end
+  
+  # An array of connections opened but not currently used, for the given
+  # server.
+  def available_connections(server=:default)
+    @available_connections[server]
+  end
+  
+  # The total number of connections opened for the given server, should
+  # be equal to available_connections.length + allocated.length
+  def created_count(server=:default)
+    @created_count[server]
+  end
+  alias size created_count
+  
+  # Chooses the first available connection to the given server, 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(server=:default)
+    begin
+      t = Thread.current
+      time = Time.new
+      timeout = time + @timeout
+      sleep_time = @sleep_time
+      if conn = owned_connection(t, server)
+        return yield(conn)
+      end
+      until conn = acquire(t, server)
+        raise(::Sequel::Error::PoolTimeoutError) if Time.new > timeout
+        sleep sleep_time
+      end
+      begin
+        yield conn
+      rescue Sequel::DatabaseDisconnectError => dde
+        remove(t, conn, server)
+        raise
+      ensure
+        release(t, conn, server) unless dde
+      end
+    rescue Exception => e
+      raise(@convert_exceptions && !e.is_a?(StandardError) ? RuntimeError.new(e.message) : e)
+    end
+  end
+  
+  # Removes all connection currently available on all servers, optionally
+  # yielding each connection to the given block. This method has the effect of 
+  # disconnecting from the database, assuming that no connections are currently
+  # being used. Once a connection is requested using #hold, the connection pool
+  # creates new connections to the database.
+  def disconnect(&block)
+    block ||= @disconnection_proc
+    @mutex.synchronize do
+      @available_connections.each do |server, conns|
+        conns.each{|c| block.call(c)} if block
+        conns.clear
+        set_created_count(server, allocated(server).length)
+      end
+    end
+  end
+  
+  private
+
+  # Assigns a connection to the supplied thread for the given server, if one
+  # is available.
+  def acquire(thread, server)
+    @mutex.synchronize do
+      if conn = available(server)
+        allocated(server)[thread] = conn
+      end
+    end
+  end
+  
+  # Returns an available connection to the given server. If no connection is
+  # available, tries to create a new connection.
+  def available(server)
+    available_connections(server).pop || make_new(server)
+  end
+  
+  # Creates a new connection to the given server if the size of the pool for
+  # the server is less than the maximum size of the pool.
+  def make_new(server)
+    if @created_count[server] < @max_size
+      raise(Sequel::Error, "No connection proc specified") unless @connection_proc
+      begin
+        conn = @connection_proc.call(server)
+      rescue Exception=>exception
+        e = Sequel::DatabaseConnectionError.new("#{exception.class} #{exception.message}")
+        e.set_backtrace(exception.backtrace)
+        raise e
+      end
+      raise(Sequel::DatabaseConnectionError, "Connection parameters not valid") unless conn
+      set_created_count(server, @created_count[server] + 1)
+      conn
+    end
+  end
+  
+  # Returns the connection owned by the supplied thread for the given server,
+  # if any.
+  def owned_connection(thread, server)
+    @mutex.synchronize{@allocated[server][thread]}
+  end
+  
+  # Releases the connection assigned to the supplied thread and server.
+  def release(thread, conn, server)
+    @mutex.synchronize do
+      allocated(server).delete(thread)
+      available_connections(server) << conn
+    end
+  end
+
+  # Removes the currently allocated connection from the connection pool.
+  def remove(thread, conn, server)
+    @mutex.synchronize do
+      allocated(server).delete(thread)
+      set_created_count(server, @created_count[server] - 1)
+      @disconnection_proc.call(conn) if @disconnection_proc
+    end
+  end
+
+  # Set the created count for the given server type
+  def set_created_count(server, value)
+    server = :default unless @created_count.include?(server)
+    @created_count[server] = value
+  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 proc used to create a new database connection
+  attr_writer :connection_proc
+  
+  # The proc used to disconnect a database connection.
+  attr_accessor :disconnection_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
+    @disconnection_proc = opts[:disconnection_proc]
+    @conns = {}
+    @convert_exceptions = opts.include?(:pool_convert_exceptions) ? opts[:pool_convert_exceptions] : true
+  end
+  
+  # The connection for the given server.
+  def conn(server=:default)
+    @conns[server]
+  end
+  
+  # Yields the connection to the supplied block for the given server.
+  # This method simulates the ConnectionPool#hold API.
+  def hold(server=:default)
+    begin
+      begin
+        yield(c = (@conns[server] ||= @connection_proc.call(server)))
+      rescue Sequel::DatabaseDisconnectError => dde
+        @conns.delete(server)
+        @disconnection_proc.call(c) if @disconnection_proc
+        raise
+      end
+    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 ||= @disconnection_proc
+    @conns.values.each{|conn| block.call(conn) if block}
+    @conns = {}
+  end
+end

data/lib/sequel_core/core_ext.rb

@@ -0,0 +1,217 @@
+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, caching the result in an instance variable.  Define
+  # standard attr_writer method for modifying that instance variable
+  def class_attr_overridable(*meths)
+    meths.each{|meth| class_eval("def #{meth}; !defined?(@#{meth}) ? (@#{meth} = self.class.#{meth}) : @#{meth} end")}
+    attr_writer(*meths) 
+    public(*meths) 
+    public(*meths.collect{|m|"#{m}="}) 
+  end
+
+  # 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, Sequel.convert_two_digit_years)
+    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, Sequel.convert_two_digit_years)
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid DateTime 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
+      if Sequel.datetime_class == DateTime
+        DateTime.parse(self, Sequel.convert_two_digit_years)
+      else
+        Sequel.datetime_class.parse(self)
+      end
+    rescue => e
+      raise Sequel::Error::InvalidValue, "Invalid #{Sequel.datetime_class} 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

data/lib/sequel_core/core_sql.rb

@@ -0,0 +1,202 @@
+class Array
+  # Return a Sequel::SQL::BooleanExpression created from this array, not matching any of the
+  # conditions.
+  def ~
+    sql_expr_if_all_two_pairs(:OR, true)
+  end
+
+  # Return a Sequel::SQL::CaseExpression with this array as the conditions and the given
+  # default value.
+  def case(default, expression = nil)
+    ::Sequel::SQL::CaseExpression.new(self, default, expression)
+  end
+
+  # Return a Sequel::SQL::Array created from this array.  Used if this array contains
+  # all two pairs and you want it treated as an SQL array instead of a ordered hash-like
+  # conditions.
+  def sql_array
+    ::Sequel::SQL::SQLArray.new(self)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this array, matching all of the
+  # conditions.
+  def sql_expr
+    sql_expr_if_all_two_pairs
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this array, matching none
+  # of the conditions.
+  def sql_negate
+    sql_expr_if_all_two_pairs(:AND, true)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this array, matching any of the
+  # conditions.
+  def sql_or
+    sql_expr_if_all_two_pairs(:OR)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression representing an SQL string made up of the
+  # concatenation of this array's elements.  If an argument is passed
+  # it is used in between each element of the array in the SQL
+  # concatenation.
+  def sql_string_join(joiner=nil)
+    if joiner
+      args = self.inject([]) do |m, a|
+        m << a
+        m << joiner
+      end
+      args.pop
+    else
+      args = self
+    end
+    args = args.collect{|a| a.is_one_of?(Symbol, ::Sequel::SQL::Expression, ::Sequel::LiteralString, TrueClass, FalseClass, NilClass) ? a : a.to_s}
+    ::Sequel::SQL::StringExpression.new(:'||', *args)
+  end
+
+  # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
+  # comments are removed, as well as excessive white-space.
+  def to_sql
+    map {|l| ((m = /^(.*)--/.match(l)) ? m[1] : l).chomp}.join(' '). \
+      gsub(/\/\*.*\*\//, '').gsub(/\s+/, ' ').strip
+  end
+
+  private
+
+  # Raise an error if this array is not made up of all two pairs, otherwise create a Sequel::SQL::BooleanExpression from this array.
+  def sql_expr_if_all_two_pairs(*args)
+    raise(Sequel::Error, 'Not all elements of the array are arrays of size 2, so it cannot be converted to an SQL expression') unless all_two_pairs?
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, *args)
+  end
+end
+
+class Hash
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching
+  # all of the conditions in this hash and the condition specified by
+  # the given argument.
+  def &(ce)
+    ::Sequel::SQL::BooleanExpression.new(:AND, self, ce)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching
+  # all of the conditions in this hash or the condition specified by
+  # the given argument.
+  def |(ce)
+    ::Sequel::SQL::BooleanExpression.new(:OR, self, ce)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this hash, not matching any of the
+  # conditions.
+  def ~
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR, true)
+  end
+
+  # Return a Sequel::SQL::CaseExpression with this hash as the conditions and the given
+  # default value.  Note that the order of the conditions will be arbitrary, so all
+  # conditions should be orthogonal.
+  def case(default, expression = nil)
+    ::Sequel::SQL::CaseExpression.new(to_a, default, expression)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching all of the
+  # conditions.
+  def sql_expr
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching none
+  # of the conditions.
+  def sql_negate
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :AND, true)
+  end
+
+  # Return a Sequel::SQL::BooleanExpression created from this hash, matching any of the
+  # conditions.
+  def sql_or
+    ::Sequel::SQL::BooleanExpression.from_value_pairs(self, :OR)
+  end
+end
+
+class String
+  include Sequel::SQL::AliasMethods
+  include Sequel::SQL::CastMethods
+
+  # Converts a string into an LiteralString, in order to override string
+  # literalization, e.g.:
+  #
+  #   DB[:items].filter(:abc => 'def').sql #=>
+  #     "SELECT * FROM items WHERE (abc = 'def')"
+  #
+  #   DB[:items].filter(:abc => 'def'.lit).sql #=>
+  #     "SELECT * FROM items WHERE (abc = def)"
+  #
+  def lit
+    Sequel::LiteralString.new(self)
+  end
+  alias_method :expr, :lit
+  
+  # Splits a string into separate SQL statements, removing comments
+  # and excessive white-space.
+  def split_sql
+    to_sql.split(';').map {|s| s.strip}
+  end
+
+  # Converts a string into an SQL string by removing comments.
+  # See also Array#to_sql.
+  def to_sql
+    split("\n").to_sql
+  end
+
+  # Returns a Blob that holds the same data as this string. Blobs provide proper
+  # escaping of binary data.
+  def to_sequel_blob
+    ::Sequel::SQL::Blob.new self
+  end
+  alias to_blob to_sequel_blob
+end
+
+class Symbol
+  include Sequel::SQL::QualifyingMethods
+  include Sequel::SQL::IdentifierMethods
+  include Sequel::SQL::AliasMethods
+  include Sequel::SQL::CastMethods
+  include Sequel::SQL::OrderMethods
+  include Sequel::SQL::BooleanMethods
+  include Sequel::SQL::NumericMethods
+  include Sequel::SQL::StringMethods
+  include Sequel::SQL::ComplexExpressionMethods
+  include Sequel::SQL::InequalityMethods if RUBY_VERSION < '1.9.0'
+
+  # If no argument is given, returns a Sequel::SQL::ColumnAll object specifying all
+  # columns for this table.
+  # If an argument is given, returns a Sequel::SQL::NumericExpression using the *
+  # (multiplication) operator with this and the given argument.
+  def *(ce=(arg=false;nil))
+    return super(ce) unless arg == false
+    Sequel::SQL::ColumnAll.new(self);
+  end
+
+  # Returns a Sequel::SQL::Function  with this as the function name,
+  # and the given arguments. This is aliased as Symbol#[] if ruby 1.9
+  # is not being used.  ruby 1.9 includes Symbol#[], and Sequel
+  # doesn't override methods defined by ruby itself.
+  def sql_function(*args)
+    Sequel::SQL::Function.new(self, *args)
+  end
+  alias_method(:[], :sql_function) if RUBY_VERSION < '1.9.0'
+
+  # If the given argument is an Integer or an array containing an Integer, returns
+  # a Sequel::SQL::Subscript with this column and the given arg.
+  # Otherwise returns a Sequel::SQL::BooleanExpression where this column (which should be boolean)
+  # or the given argument is true.
+  def |(sub)
+    return super unless (Integer === sub) || ((Array === sub) && sub.any?{|x| Integer === x})
+    Sequel::SQL::Subscript.new(self, Array(sub))
+  end
+  
+  # Delegate the creation of the resulting SQL to the given dataset,
+  # since it may be database dependent.
+  def to_column_ref(ds)
+    ds.symbol_to_column_ref(self)
+  end
+end