sequel_core 2.2.0 → 3.8.0

data/lib/sequel_core/adapters/sqlite.rb

@@ -1,270 +0,0 @@
-require 'sqlite3'
-
-module Sequel
-  module SQLite
-    class Database < Sequel::Database
-      set_adapter_scheme :sqlite
-    
-      def serial_primary_key_options
-        {:primary_key => true, :type => :integer, :auto_increment => true}
-      end
-
-      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 disconnect
-        @pool.disconnect {|c| c.close}
-      end
-    
-      def dataset(opts = nil)
-        SQLite::Dataset.new(self, opts)
-      end
-      
-      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
-    
-      def tables
-        self[:sqlite_master].filter(TABLES_FILTER).map {|r| r[:name].to_sym}
-      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 pragma_get(name)
-        single_value("PRAGMA #{name}")
-      end
-      
-      def pragma_set(name, value)
-        execute("PRAGMA #{name} = #{value}")
-      end
-      
-      AUTO_VACUUM = {'0' => :none, '1' => :full, '2' => :incremental}.freeze
-      
-      def auto_vacuum
-        AUTO_VACUUM[pragma_get(:auto_vacuum)]
-      end
-      
-      def auto_vacuum=(value)
-        value = AUTO_VACUUM.index(value) || (raise Error, "Invalid value for auto_vacuum option. Please specify one of :none, :full, :incremental.")
-        pragma_set(:auto_vacuum, value)
-      end
-      
-      SYNCHRONOUS = {'0' => :off, '1' => :normal, '2' => :full}.freeze
-      
-      def synchronous
-        SYNCHRONOUS[pragma_get(:synchronous)]
-      end
-      
-      def synchronous=(value)
-        value = SYNCHRONOUS.index(value) || (raise Error, "Invalid value for synchronous option. Please specify one of :off, :normal, :full.")
-        pragma_set(:synchronous, value)
-      end
-      
-      TEMP_STORE = {'0' => :default, '1' => :file, '2' => :memory}.freeze
-      
-      def temp_store
-        TEMP_STORE[pragma_get(:temp_store)]
-      end
-      
-      def temp_store=(value)
-        value = TEMP_STORE.index(value) || (raise Error, "Invalid value for temp_store option. Please specify one of :default, :file, :memory.")
-        pragma_set(:temp_store, value)
-      end
-      
-      def alter_table_sql(table, op)
-        case op[:op]
-        when :add_column
-          "ALTER TABLE #{table} ADD #{column_definition_sql(op)}"
-        when :add_index
-          index_definition_sql(table, op)
-        when :drop_column
-          columns_str = (schema_parse_table(table, {}).map {|c| c[0] } - (Array === op[:name] ? op[:name] : [op[:name]])).join(",")
-          sql  = "BEGIN TRANSACTION;\n"
-          sql += "CREATE TEMPORARY TABLE #{table}_backup(#{columns_str});\n"
-          sql += "INSERT INTO #{table}_backup SELECT #{columns_str} FROM #{table};\n"
-          sql += "DROP TABLE #{table};\n"
-          sql += "CREATE TABLE #{table}(#{columns_str});\n"
-          sql += "INSERT INTO #{table} SELECT #{columns_str} FROM #{table}_backup;\n"
-          sql += "DROP TABLE #{table}_backup;\n"
-          sql += "COMMIT;\n"
-        else
-          raise Error, "Unsupported ALTER TABLE operation"
-        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
-
-      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 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
-      end
-
-      def complex_expression_sql(op, args)
-        case op
-        when :~, :'!~', :'~*', :'!~*'
-          raise Error, "SQLite does not support pattern matching via regular expressions"
-        when :LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE'
-          # SQLite is case insensitive for ASCII, and non case sensitive for other character sets
-          "#{'NOT ' if [:'NOT LIKE', :'NOT ILIKE'].include?(op)}(#{literal(args.at(0))} LIKE #{literal(args.at(1))})"
-        else
-          super(op, args)
-        end
-      end
-
-      def insert_sql(*values)
-        if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
-          "INSERT INTO #{source_list(@opts[:from])} #{values.first.sql};"
-        else
-          super(*values)
-        end
-      end
-
-      def fetch_rows(sql, &block)
-        @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]}
-            block.call(row)
-          end
-        end
-      end
-      
-      def insert(*values)
-        @db.execute_insert insert_sql(*values)
-      end
-    
-      def update(*args, &block)
-        @db.execute update_sql(*args, &block)
-      end
-    
-      def delete(opts = nil)
-        # check if no filter is specified
-        unless (opts && opts[:where]) || @opts[:where]
-          @db.transaction do
-            unfiltered_count = count
-            @db.execute delete_sql(opts)
-            unfiltered_count
-          end
-        else
-          @db.execute delete_sql(opts)
-        end
-      end
-      
-      EXPLAIN = 'EXPLAIN %s'.freeze
-
-      def explain
-        res = []
-        @db.result_set(EXPLAIN % select_sql(opts), nil) {|r| res << r}
-        res
-      end
-    end
-  end
-end

data/lib/sequel_core/connection_pool.rb

@@ -1,194 +0,0 @@
-# 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