viking-sequel 3.10.0

data/lib/sequel/connection_pool/single.rb

@@ -0,0 +1,29 @@
+# This is the fastest connection pool, since it isn't a connection pool at all.
+# It is just a wrapper around a single connection that uses the connection pool
+# API.
+class Sequel::SingleConnectionPool < Sequel::ConnectionPool  
+  # The SingleConnectionPool always has a size of 1 if connected
+  # and 0 if not.
+  def size
+    @conn ? 1 : 0
+  end
+  
+  # Disconnect the connection from the database.
+  def disconnect(opts=nil, &block)
+    block ||= @disconnection_proc
+    block.call(@conn) if block
+    @conn = nil
+  end
+  
+  # Yield the connection to the block.
+  def hold(server=nil)
+    begin
+      yield(@conn ||= make_new(DEFAULT_SERVER))
+    rescue Sequel::DatabaseDisconnectError
+      disconnect
+      raise
+    end
+  end
+
+  CONNECTION_POOL_MAP[[true, false]] = self
+end

data/lib/sequel/connection_pool/threaded.rb

@@ -0,0 +1,150 @@
+# A connection pool allowing multi-threaded access to a pool of connections.
+class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
+  # The maximum number of connections this pool will create (per shard/server
+  # if sharding).
+  attr_reader :max_size
+  
+  # An array of connections that are available for use by the pool.
+  attr_reader :available_connections
+  
+  # A hash with thread keys and connection values for currently allocated
+  # connections.
+  attr_reader :allocated
+
+  # The following additional options are respected:
+  # * :max_connections - The maximum number of connections the connection pool
+  #   will open (default 4)
+  # * :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)
+    super
+    @max_size = Integer(opts[:max_connections] || 4)
+    raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
+    @mutex = Mutex.new  
+    @available_connections = []
+    @allocated = {}
+    @timeout = Integer(opts[:pool_timeout] || 5)
+    @sleep_time = Float(opts[:pool_sleep_time] || 0.001)
+  end
+  
+  # The total number of connections opened for the given server, should
+  # be equal to available_connections.length + allocated.length.
+  def size
+    @allocated.length + @available_connections.length
+  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.  If connections are being used, they are scheduled to be
+  # disconnected as soon as they are returned to the pool.
+  # 
+  # Once a connection is requested using #hold, the connection pool
+  # creates new connections to the database.
+  def disconnect(opts={}, &block)
+    block ||= @disconnection_proc
+    sync do
+      @available_connections.each{|conn| block.call(conn)} if block
+      @available_connections.clear
+    end
+  end
+  
+  # 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::PoolTimeout is 
+  # raised.
+  def hold(server=nil)
+    t = Thread.current
+    if conn = owned_connection(t)
+      return yield(conn)
+    end
+    begin
+      unless conn = acquire(t)
+        time = Time.now
+        timeout = time + @timeout
+        sleep_time = @sleep_time
+        sleep sleep_time
+        until conn = acquire(t)
+          raise(::Sequel::PoolTimeout) if Time.now > timeout
+          sleep sleep_time
+        end
+      end
+      yield conn
+    rescue Sequel::DatabaseDisconnectError
+      @disconnection_proc.call(conn) if @disconnection_proc && conn
+      @allocated.delete(t)
+      conn = nil
+      raise
+    ensure
+      sync{release(t)} if conn
+    end
+  end
+  
+  private
+
+  # Assigns a connection to the supplied thread for the given server, if one
+  # is available. The calling code should NOT already have the mutex when
+  # calling this.
+  def acquire(thread)
+    sync do
+      if conn = available
+        @allocated[thread] = conn
+      end
+    end
+  end
+  
+  # Returns an available connection to the given server. If no connection is
+  # available, tries to create a new connection. The calling code should already
+  # have the mutex before calling this.
+  def available
+    @available_connections.pop || make_new(DEFAULT_SERVER)
+  end
+
+  # Alias the default make_new method, so subclasses can call it directly.
+  alias default_make_new make_new
+  
+  # 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. The calling code
+  # should already have the mutex before calling this.
+  def make_new(server)
+    if (n = size) >= @max_size
+      @allocated.keys.each{|t| release(t) unless t.alive?}
+      n = nil
+    end
+    super if (n || size) < @max_size
+  end
+  
+  # Returns the connection owned by the supplied thread for the given server,
+  # if any. The calling code should NOT already have the mutex before calling this.
+  def owned_connection(thread)
+    sync{@allocated[thread]}
+  end
+  
+  # Releases the connection assigned to the supplied thread and server. If the
+  # server or connection given is scheduled for disconnection, remove the
+  # connection instead of releasing it back to the pool.
+  # The calling code should already have the mutex before calling this.
+  def release(thread)
+    @available_connections << @allocated.delete(thread)
+  end
+
+  # Yield to the block while inside the mutex. The calling code should NOT
+  # already have the mutex before calling this.
+  def sync
+    @mutex.synchronize{yield}
+  end
+  
+  CONNECTION_POOL_MAP[[false, false]] = self
+end

data/lib/sequel/core.rb

@@ -0,0 +1,293 @@
+%w'bigdecimal date thread time uri'.each{|f| require f}
+
+# Top level module for Sequel
+#
+# There are some class methods that are added via metaprogramming, one for
+# each supported adapter.  For example:
+#
+#   DB = Sequel.sqlite # Memory database
+#   DB = Sequel.sqlite('blog.db')
+#   DB = Sequel.postgres('database_name', :user=>'user', 
+#          :password=>'password', :host=>'host', :port=>5432, 
+#          :max_connections=>10)
+#
+# If a block is given to these methods, it is passed the opened Database
+# object, which is closed (disconnected) when the block exits, just
+# like a block passed to connect.  For example:
+#
+#   Sequel.sqlite('blog.db'){|db| puts db[:users].count} 
+#
+# Sequel doesn't pay much attention to timezones by default, but you can set it
+# handle timezones if you want.  There are three separate timezone settings:
+#
+# * application_timezone - The timezone you want the application to use.  This is
+#   the timezone that incoming times from the database and typecasting are converted
+#   to.
+# * database_timezone - The timezone for storage in the database.  This is the
+#   timezone to which Sequel will convert timestamps before literalizing them
+#   for storage in the database.  It is also the timezone that Sequel will assume
+#   database timestamp values are already in (if they don't include an offset).
+# * typecast_timezone - The timezone that incoming data that Sequel needs to typecast
+#   is assumed to be already in (if they don't include an offset).
+#
+# You can set also set all three timezones to the same value at once via
+# Sequel.default_timezone=.
+#
+#   Sequel.application_timezone = :utc # or :local or nil
+#   Sequel.database_timezone = :utc # or :local or nil
+#   Sequel.typecast_timezone = :utc # or :local or nil
+#   Sequel.default_timezone = :utc # or :local or nil
+#
+# The only timezone values that are supported by default are :utc (convert to UTC),
+# :local (convert to local time), and nil (don't convert).  If you need to
+# convert to a specific timezone, or need the timezones being used to change based
+# on the environment (e.g. current user), you need to use an extension (and use
+# DateTime as the datetime_class).
+#
+# 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
+  @virtual_row_instance_eval = true
+  @require_thread = nil
+  
+  # Mutex used to protect file loading
+  @require_mutex = Mutex.new
+  
+  class << self
+    # Sequel converts two digit years in Dates and DateTimes by default,
+    # so 01/02/03 is interpreted at January 2nd, 2003, and 12/13/99 is interpreted
+    # as December 13, 1999. You can override this to treat those dates as
+    # January 2nd, 0003 and December 13, 0099, respectively, by setting this to false.
+    attr_accessor :convert_two_digit_years
+
+    # Sequel can use either Time or DateTime for times returned from the
+    # database.  It defaults to Time.  To change it to DateTime, set this to DateTime.
+    attr_accessor :datetime_class
+
+    attr_accessor :virtual_row_instance_eval
+    
+    # Alias to the standard version of require
+    alias k_require require
+
+    private
+
+    # Make thread safe requiring reentrant to prevent deadlocks.
+    def check_requiring_thread
+      t = Thread.current
+      return(yield) if @require_thread == t
+      @require_mutex.synchronize do
+        begin
+          @require_thread = t 
+          yield
+        ensure
+          @require_thread = nil
+        end
+      end
+    end
+  end
+
+  # Returns true if the passed object could be a specifier of conditions, false otherwise.
+  # Currently, Sequel considers hashes and arrays of all two pairs as
+  # condition specifiers.
+  def self.condition_specifier?(obj)
+    case obj
+    when Hash
+      true
+    when Array
+      !obj.empty? && obj.all?{|i| (Array === i) && (i.length == 2)}
+    else
+      false
+    end
+  end
+
+  # Creates a new database object based on the supplied connection string
+  # and optional arguments.  The specified scheme determines the database
+  # class used, and the rest of the string specifies the connection options.
+  # For example:
+  #
+  #   DB = Sequel.connect('sqlite:/') # Memory database
+  #   DB = Sequel.connect('sqlite://blog.db') # ./blog.db
+  #   DB = Sequel.connect('sqlite:///blog.db') # /blog.db
+  #   DB = Sequel.connect('postgres://user:password@host:port/database_name')
+  #   DB = Sequel.connect('sqlite:///blog.db', :max_connections=>10)
+  #
+  # If a block is given, it is passed the opened Database object, which is
+  # 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
+  
+  # Convert the exception to the given class.  The given class should be
+  # Sequel::Error or a subclass.  Returns an instance of klass with
+  # the message and backtrace of exception.
+  def self.convert_exception_class(exception, klass)
+    return exception if exception.is_a?(klass)
+    e = klass.new("#{exception.class}: #{exception.message}")
+    e.wrapped_exception = exception
+    e.set_backtrace(exception.backtrace)
+    e
+  end
+
+  # Load all Sequel extensions given.  Only loads extensions included in this
+  # release of Sequel, doesn't load external extensions.
+  #
+  #   Sequel.extension(:schema_dumper)
+  #   Sequel.extension(:pagination, :query)
+  def self.extension(*extensions)
+    extensions.each{|e| tsk_require "sequel/extensions/#{e}"}
+  end
+  
+  # Set the method to call on identifiers going into the database.  This affects
+  # the literalization of identifiers by calling this method on them before they are input.
+  # Sequel upcases identifiers in all SQL strings for most databases, so to turn that off:
+  #
+  #   Sequel.identifier_input_method = nil
+  # 
+  # to downcase instead:
+  #
+  #   Sequel.identifier_input_method = :downcase
+  #
+  # Other String instance methods work as well.
+  def self.identifier_input_method=(value)
+    Database.identifier_input_method = value
+  end
+  
+  # Set the method to call on identifiers coming out of the database.  This affects
+  # the literalization of identifiers by calling this method on them when they are
+  # retrieved from the database.  Sequel downcases identifiers retrieved for most
+  # databases, so to turn that off:
+  #
+  #   Sequel.identifier_output_method = nil
+  # 
+  # to upcase instead:
+  #
+  #   Sequel.identifier_output_method = :upcase
+  #
+  # Other String instance methods work as well.
+  def self.identifier_output_method=(value)
+    Database.identifier_output_method = value
+  end
+  
+  # Set whether to quote identifiers for all databases by default. By default,
+  # Sequel quotes identifiers in all SQL strings, so to turn that off:
+  #
+  #   Sequel.quote_identifiers = false
+  def self.quote_identifiers=(value)
+    Database.quote_identifiers = value
+  end
+  
+  # Require all given files which should be in the same or a subdirectory of
+  # this file.  If a subdir is given, assume all files are in that subdir.
+  def self.require(files, subdir=nil)
+    Array(files).each{|f| super("#{File.dirname(__FILE__)}/#{"#{subdir}/" if subdir}#{f}")}
+  end
+  
+  # Set whether to set the single threaded mode for all databases by default. By default,
+  # Sequel uses a threadsafe connection pool, which isn't as fast as the
+  # single threaded connection pool.  If your program will only have one thread,
+  # and speed is a priority, you may want to set this to true:
+  #
+  #   Sequel.single_threaded = true
+  def self.single_threaded=(value)
+    Database.single_threaded = value
+  end
+
+  # Converts the given string into a Date object.
+  def self.string_to_date(s)
+    begin
+      Date.parse(s, Sequel.convert_two_digit_years)
+    rescue => e
+      raise convert_exception_class(e, InvalidValue)
+    end
+  end
+
+  # Converts the given string into a Time or DateTime object, depending on the
+  # value of Sequel.datetime_class.
+  def self.string_to_datetime(s)
+    begin
+      if datetime_class == DateTime
+        DateTime.parse(s, convert_two_digit_years)
+      else
+        datetime_class.parse(s)
+      end
+    rescue => e
+      raise convert_exception_class(e, InvalidValue)
+    end
+  end
+
+  # Converts the given string into a Time object.
+  def self.string_to_time(s)
+    begin
+      Time.parse(s)
+    rescue => e
+      raise convert_exception_class(e, InvalidValue)
+    end
+  end
+
+  # Same as Sequel.require, but wrapped in a mutex in order to be thread safe.
+  def self.ts_require(*args)
+    check_requiring_thread{require(*args)}
+  end
+  
+  # Same as Kernel.require, but wrapped in a mutex in order to be thread safe.
+  def self.tsk_require(*args)
+    check_requiring_thread{k_require(*args)}
+  end
+
+  # If the supplied block takes a single argument,
+  # yield a new SQL::VirtualRow instance to the block
+  # argument.  Otherwise, evaluate the block in the context of a new
+  # SQL::VirtualRow instance.
+  def self.virtual_row(&block)
+    vr = SQL::VirtualRow.new
+    case block.arity
+    when -1, 0
+      vr.instance_eval(&block)
+    else
+      block.call(vr)
+    end  
+  end
+  
+  ### Private Class Methods ###
+
+  # Helper method that the database adapter class methods that are added to Sequel via
+  # metaprogramming use to parse arguments.
+  def self.adapter_method(adapter, *args, &block) # :nodoc:
+    raise(::Sequel::Error, "Wrong number of arguments, 0-2 arguments valid") if args.length > 2
+    opts = {:adapter=>adapter.to_sym}
+    opts[:database] = args.shift if args.length >= 1 && !(args[0].is_a?(Hash))
+    if Hash === (arg = args[0])
+      opts.merge!(arg)
+    elsif !arg.nil?
+      raise ::Sequel::Error, "Wrong format of arguments, either use (), (String), (Hash), or (String, Hash)"
+    end
+    connect(opts, &block)
+  end
+
+  # Method that adds a database adapter class method to Sequel that calls
+  # Sequel.adapter_method.
+  def self.def_adapter_method(*adapters) # :nodoc:
+    adapters.each do |adapter|
+      instance_eval("def #{adapter}(*args, &block); adapter_method('#{adapter}', *args, &block) end", __FILE__, __LINE__)
+    end
+  end
+
+  private_class_method :adapter_method, :def_adapter_method
+  
+  require(%w"metaprogramming sql connection_pool exceptions dataset database timezones version")
+  require(%w"schema_generator schema_methods schema_sql", 'database')
+  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
+  def_adapter_method(*Database::ADAPTERS)
+end