epugh-sequel 0.0.0

data/lib/sequel/adapters/utils/date_format.rb

@@ -0,0 +1,21 @@
+# Module containing overrides for Sequel's standard date/time literalization
+# to use the SQL standrd.  The SQL standard is used by fewer databases than
+# the defacto standard (which is just a normal string).
+module Sequel::Dataset::SQLStandardDateFormat
+  private
+
+  # Use SQL standard syntax for Date
+  def literal_date(v)
+    v.strftime("DATE '%Y-%m-%d'") 
+  end
+    
+  # Use SQL standard syntax for DateTime
+  def literal_datetime(v)
+    v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+  end
+
+  # Use SQL standard syntax for Time
+  def literal_time(v)
+    v.strftime("TIMESTAMP '%Y-%m-%d %H:%M:%S'")
+  end
+end

data/lib/sequel/adapters/utils/stored_procedures.rb

@@ -0,0 +1,75 @@
+module Sequel 
+  class Dataset
+    module StoredProcedureMethods
+      SQL_QUERY_TYPE = Hash.new{|h,k| h[k] = k}
+      SQL_QUERY_TYPE[:first] = SQL_QUERY_TYPE[:all] = :select
+      
+      # The name of the stored procedure to call
+      attr_accessor :sproc_name
+      
+      # Call the prepared statement
+      def call(*args, &block)
+        @sproc_args = args
+        case @sproc_type
+        when :select, :all
+          all(&block)
+        when :first
+          first
+        when :insert
+          insert
+        when :update
+          update
+        when :delete
+          delete
+        end
+      end
+      
+      # Programmer friendly string showing this is a stored procedure,
+      # showing the name of the procedure.
+      def inspect
+        "<#{self.class.name}/StoredProcedure name=#{@sproc_name}>"
+      end
+      
+      # Set the type of the sproc and override the corresponding _sql
+      # method to return the empty string (since the result will be
+      # ignored anyway).
+      def sproc_type=(type)
+        @sproc_type = type
+        meta_def("#{sql_query_type}_sql"){|*a| ''}
+      end
+      
+      private
+      
+      # The type of query (:select, :insert, :delete, :update).
+      def sql_query_type
+        SQL_QUERY_TYPE[@sproc_type]
+      end
+    end
+  
+    module StoredProcedures
+      # For the given type (:select, :first, :insert, :update, or :delete),
+      # run the database stored procedure with the given name with the given
+      # arguments.
+      def call_sproc(type, name, *args)
+        prepare_sproc(type, name).call(*args)
+      end
+      
+      # Transform this dataset into a stored procedure that you can call
+      # multiple times with new arguments.
+      def prepare_sproc(type, name)
+        sp = clone
+        prepare_extend_sproc(sp)
+        sp.sproc_type = type
+        sp.sproc_name = name
+        sp
+      end
+      
+      private
+      
+      # Extend the dataset with the stored procedure methods.
+      def prepare_extend_sproc(ds)
+        ds.extend(StoredProcedureMethods)
+      end
+    end
+  end
+end

data/lib/sequel/adapters/utils/unsupported.rb

@@ -0,0 +1,62 @@
+class Sequel::Dataset
+  # This module should be included in the dataset class for all databases that
+  # don't support INTERSECT or EXCEPT.
+  module UnsupportedIntersectExcept
+    # Raise an Error if EXCEPT is used
+    def except(ds, all=false)
+      raise(Sequel::Error, "EXCEPT not supported")
+    end
+
+    # Raise an Error if INTERSECT is used
+    def intersect(ds, all=false)
+      raise(Sequel::Error, "INTERSECT not supported")
+    end
+    
+    private
+    
+    # Since EXCEPT and INTERSECT are not supported, and order shouldn't matter
+    # when UNION is used, don't worry about parantheses.  This may potentially
+    # give incorrect results if UNION ALL is used.
+    def select_compounds_sql(sql, opts)
+      return unless opts[:compounds]
+      opts[:compounds].each do |type, dataset, all|
+        sql << " #{type.to_s.upcase}#{' ALL' if all} #{subselect_sql(dataset)}"
+      end
+    end
+  end
+
+  # This module should be included in the dataset class for all databases that
+  # don't support INTERSECT ALL or EXCEPT ALL.
+  module UnsupportedIntersectExceptAll
+    # Raise an Error if EXCEPT is used
+    def except(ds, all=false)
+      raise(Sequel::Error, "EXCEPT ALL not supported") if all
+      super(ds)
+    end
+
+    # Raise an Error if INTERSECT is used
+    def intersect(ds, all=false)
+      raise(Sequel::Error, "INTERSECT ALL not supported") if all
+      super(ds)
+    end
+  end
+
+  # This module should be included in the dataset class for all databases that
+  # don't support IS [NOT] (TRUE|FALSE)
+  module UnsupportedIsTrue
+    # Use an = construct instead of IS and an != OR IS NULL construct instead of IS NOT.
+    def complex_expression_sql(op, args)
+      case op
+      when :IS, :'IS NOT'
+        isnot = op != :IS
+        return super if (v1 = args.at(1)).nil?
+        v0 = literal(args.at(0))
+        s = "(#{v0} #{'!' if isnot}= #{literal(v1)})"
+        s = "(#{s} OR (#{v0} IS NULL))" if isnot
+        s
+      else
+        super(op, args)
+      end
+    end
+  end
+end

data/lib/sequel/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.rb

@@ -0,0 +1,204 @@
+%w'bigdecimal bigdecimal/util date enumerator thread time uri yaml'.each do |f|
+  require f
+end
+
+# 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.  For example:
+#
+#   Sequel.sqlite('blog.db'){|db| puts db.users.count}  
+#
+# Sequel converts the column type tinyint to a boolean by default,
+# you can override the conversion to use tinyint as an integer:
+#
+#   Sequel.convert_tinyint_to_bool = false
+#
+# 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: 
+#
+#   Sequel.convert_two_digit_years = false
+#
+# Sequel can use either Time or DateTime for times returned from the
+# database.  It defaults to Time.  To change it to DateTime, use:
+#
+#   Sequel.datetime_class = DateTime
+#
+# Sequel currently does not use instance_eval for virtual row blocks by default
+# (e.g. the block passed to Dataset#filter, #select, #order and other similar
+# methods).  If you want to use instance_eval for these blocks, don't have any
+# block arguments, and set:
+#
+#   Sequel.virtual_row_instance_eval = true
+#
+# When this is set, you can do:
+#
+#   dataset.filter{|o| o.column > 0} # no instance_eval
+#   dataset.filter{column > 0}       # instance eval
+#
+# When the virtual_row_instance_eval is false, using a virtual row block without a block
+# argument will generate a deprecation message.
+#
+# The option to not use instance_eval for a block with no arguments will be removed in a future version.
+# If you have any virtual row blocks that you don't want to use instance_eval for,
+# make sure the blocks have block arguments.
+module Sequel
+  @convert_tinyint_to_bool = true
+  @convert_two_digit_years = true
+  @datetime_class = Time
+  @virtual_row_instance_eval = false
+  
+  class << self
+    attr_accessor :convert_tinyint_to_bool, :convert_two_digit_years, :datetime_class, :virtual_row_instance_eval
+  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}  
+  def self.connect(*args, &block)
+    Database.connect(*args, &block)
+  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 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 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
+  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 a string into a Date object.
+  def self.string_to_date(s)
+    begin
+      Date.parse(s, Sequel.convert_two_digit_years)
+    rescue => e
+      raise 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 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 Error::InvalidValue, "Invalid #{datetime_class} value '#{self}' (#{e.message})"
+    end
+  end
+
+  # Converts a string into a Time object.
+  def self.string_to_time(s)
+    begin
+      Time.parse(s)
+    rescue => e
+      raise Error::InvalidValue, "Invalid Time value '#{self}' (#{e.message})"
+    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")
+    end
+  end
+
+  private_class_method :adapter_method, :def_adapter_method
+  
+  require(%w"metaprogramming sql core_sql connection_pool exceptions dataset migration database object_graph version deprecated")
+  require(%w"schema_generator schema_methods schema_sql", 'database')
+  require(%w"convenience prepared_statements sql", 'dataset')
+
+  # Add the database adapter class methods to Sequel via metaprogramming
+  def_adapter_method(*Database::ADAPTERS)
+end