sequel_core 1.4.0 → 1.5.0

data/lib/sequel_core/adapters/odbc.rb

@@ -41,6 +41,10 @@ module Sequel
         ODBC::Dataset.new(self, opts)
       end
     
+      # ODBC returns native statement objects, which must be dropped if
+      # you call execute manually, or you will get warnings.  See the
+      # fetch_rows method source code for an example of how to drop
+      # the statements.
       def execute(sql)
         @logger.info(sql) if @logger
         @pool.hold do |conn|
@@ -59,6 +63,10 @@ module Sequel
     class Dataset < Sequel::Dataset
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
+      ODBC_TIMESTAMP_FORMAT = "{ts '%Y-%m-%d %H:%M:%S'}".freeze
+      ODBC_TIMESTAMP_AFTER_SECONDS =
+        ODBC_TIMESTAMP_FORMAT.index( '%S' ).succ - ODBC_TIMESTAMP_FORMAT.length
+      ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
       
       def literal(v)
         case v
@@ -66,6 +74,15 @@ module Sequel
           BOOL_TRUE
         when false
           BOOL_FALSE
+        when Time
+          formatted = v.strftime(ODBC_TIMESTAMP_FORMAT)
+          if v.usec >= 1000
+            msec = ( v.usec.to_f / 1000 ).round
+            formatted.insert ODBC_TIMESTAMP_AFTER_SECONDS, ".#{msec}"
+          end
+          formatted
+        when Date
+          v.strftime(ODBC_DATE_FORMAT)
         else
           super
         end
@@ -135,43 +152,6 @@ module Sequel
         end
       end
       
-      def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          s = @db.execute sql
-          begin
-            @columns = s.columns(true).map {|c| c.name.to_sym}
-            rows = s.fetch_all
-            rows.each {|r| yield array_tuples_make_row(r)}
-          ensure
-            s.drop unless s.nil? rescue nil
-          end
-        end
-        self
-      end
-      
-      def array_tuples_make_row(row)
-        row.keys = @columns
-        row.each_with_index do |v, idx|
-          # When fetching a result set, the Ruby ODBC driver converts all ODBC 
-          # SQL types to an equivalent Ruby type; with the exception of
-          # SQL_TYPE_DATE, SQL_TYPE_TIME and SQL_TYPE_TIMESTAMP.
-          #
-          # The conversions below are consistent with the mappings in
-          # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
-          case v
-          when ::ODBC::TimeStamp
-            row[idx] = DateTime.new(v.year, v.month, v.day, v.hour, v.minute, v.second)
-          when ::ODBC::Time
-            now = DateTime.now
-            row[idx] = Time.gm(now.year, now.month, now.day, v.hour, v.minute, v.second)
-          when ::ODBC::Date
-            row[idx] = Date.new(v.year, v.month, v.day)
-          end
-        end
-        row
-      end
-      
-
       def insert(*values)
         @db.do insert_sql(*values)
       end
@@ -186,4 +166,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/adapters/openbase.rb

@@ -58,22 +58,6 @@ module Sequel
         self
       end
       
-      def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          result = @db.execute sql
-          begin
-            @columns = result.column_infos.map {|c| c.name.to_sym}
-            result.each do |r|
-              r.keys = @columns
-              yield r
-            end
-          ensure
-            # cursor.close
-          end
-        end
-        self
-      end
-      
       def insert(*values)
         @db.do insert_sql(*values)
       end
@@ -87,4 +71,4 @@ module Sequel
       end
     end
   end
-end
+end

data/lib/sequel_core/adapters/oracle.rb

@@ -100,24 +100,6 @@ module Sequel
         self
       end
       
-      def array_tuples_fetch_rows(sql, &block)
-        @db.synchronize do
-          cursor = @db.execute sql
-          begin
-            @columns = cursor.get_col_names.map {|c| c.downcase.to_sym}
-            raw_rnum_index = columns.index(:raw_rnum_)
-            while r = cursor.fetch
-              r.delete_at(raw_rnum_index) if raw_rnum_index
-              r.keys =  columns.delete_if{|x| x == :raw_rnum_}
-              yield r
-            end
-          ensure
-            cursor.close
-          end
-        end
-        self
-      end
-      
       def insert(*values)
         @db.do insert_sql(*values)
       end
@@ -195,4 +177,4 @@ module Sequel
       alias sql select_sql
     end
   end
-end
+end

data/lib/sequel_core/adapters/postgres.rb

@@ -328,16 +328,21 @@ module Sequel
 
       def index_definition_sql(table_name, index)
         index_name = index[:name] || default_index_name(table_name, index[:columns])
-        if index[:full_text]
+        expr = "(#{literal(index[:columns])})"
+        unique = "UNIQUE " if index[:unique]
+        index_type = index[:type]
+        filter = index[:where] || index[:filter]
+        filter = " WHERE #{expression_list(filter)}" if filter
+        case index_type
+        when :full_text
           lang = index[:language] ? "#{literal(index[:language])}, " : ""
           cols = index[:columns].map {|c| literal(c)}.join(" || ")
-          expr = "gin(to_tsvector(#{lang}#{cols}))"
-          "CREATE INDEX #{index_name} ON #{table_name} USING #{expr}"
-        elsif index[:unique]
-          "CREATE UNIQUE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
-        else
-          "CREATE INDEX #{index_name} ON #{table_name} (#{literal(index[:columns])})"
+          expr = "(to_tsvector(#{lang}#{cols}))"
+          index_type = :gin
+        when :spatial
+          index_type = :gist
         end
+        "CREATE #{unique}INDEX #{index_name} ON #{table_name} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
       end
     
       def drop_table_sql(name)
@@ -346,6 +351,9 @@ module Sequel
     end
   
     class Dataset < Sequel::Dataset
+      
+      PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
+
       def quote_column_ref(c); "\"#{c}\""; end
       
       def literal(v)
@@ -354,6 +362,8 @@ module Sequel
           v
         when String, Fixnum, Float, TrueClass, FalseClass
           PGconn.quote(v)
+        when Time
+          "#{v.strftime(PG_TIMESTAMP_FORMAT)}.#{sprintf("%06d",v.usec)}'"
         else
           super
         end
@@ -433,7 +443,7 @@ module Sequel
     
       # Locks the table with the specified mode.
       def lock(mode, &block)
-        sql = LOCK % [@opts[:from], mode]
+        sql = LOCK % [source_list(@opts[:from]), mode]
         @db.synchronize do
           if block # perform locking inside a transaction and yield to block
             @db.transaction {@db.execute(sql); yield}
@@ -450,11 +460,11 @@ module Sequel
         # postgresql 8.2 introduces support for insert
         columns = literal(columns)
         values = values.map {|r| "(#{literal(r)})"}.join(COMMA_SEPARATOR)
-        ["INSERT INTO #{@opts[:from]} (#{columns}) VALUES #{values}"]
+        ["INSERT INTO #{source_list(@opts[:from])} (#{columns}) VALUES #{values}"]
       end
 
       def insert(*values)
-        @db.execute_insert(insert_sql(*values), @opts[:from],
+        @db.execute_insert(insert_sql(*values), source_list(@opts[:from]),
           values.size == 1 ? values.first : values)
       end
     
@@ -506,56 +516,6 @@ module Sequel
         eval("lambda {|r| {#{kvs.join(COMMA_SEPARATOR)}}}")
       end
 
-      def array_tuples_fetch_rows(sql, &block)
-        @db.execute(sql) do |q|
-          conv = array_tuples_row_converter(q)
-          q.each {|r| yield conv[r]}
-        end
-      end
-      
-      @@array_tuples_converters_mutex = Mutex.new
-      @@array_tuples_converters = {}
-
-      def array_tuples_row_converter(result)
-        @columns = []; translators = []
-        result.fields.each_with_index do |f, idx|
-          @columns << f.to_sym
-          translators << PG_TYPES[result.type(idx)]
-        end
-        
-        # create result signature and memoize the converter
-        sig = [@columns, translators].hash
-        @@array_tuples_converters_mutex.synchronize do
-          @@array_tuples_converters[sig] ||= array_tuples_compile_converter(@columns, translators)
-        end
-      end
-    
-      def array_tuples_compile_converter(columns, translators)
-        tr = []
-        columns.each_with_index do |column, idx|
-          if !AUTO_TRANSLATE and t = translators[idx]
-            tr << "if (v = r[#{idx}]); r[#{idx}] = v.#{t}; end"
-          end
-        end
-        eval("lambda {|r| r.keys = columns; #{tr.join(';')}; r}")
-      end
-
-      def array_tuples_transform_load(r)
-        a = []; a.keys = []
-        r.each_pair do |k, v|
-          a[k] = (tt = @transform[k]) ? tt[0][v] : v
-        end
-        a
-      end
-
-      # Applies the value transform for data saved to the database.
-      def array_tuples_transform_save(r)
-        a = []; a.keys = []
-        r.each_pair do |k, v|
-          a[k] = (tt = @transform[k]) ? tt[1][v] : v
-        end
-        a
-      end
     end
   end
 end

data/lib/sequel_core/adapters/sqlite.rb

@@ -14,6 +14,7 @@ module Sequel
           @opts[:database] = ':memory:'
         end
         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|
@@ -131,6 +132,8 @@ module Sequel
     end
     
     class Dataset < Sequel::Dataset
+      def quote_column_ref(c); "`#{c}`"; end
+
       def literal(v)
         case v
         when Time
@@ -142,7 +145,7 @@ module Sequel
 
       def insert_sql(*values)
         if (values.size == 1) && values.first.is_a?(Sequel::Dataset)
-          "INSERT INTO #{@opts[:from]} #{values.first.sql};"
+          "INSERT INTO #{source_list(@opts[:from])} #{values.first.sql};"
         else
           super(*values)
         end
@@ -160,13 +163,6 @@ module Sequel
         end
       end
       
-      def array_tuples_fetch_rows(sql, &block)
-        @db.execute_select(sql) do |result|
-          @columns = result.columns.map {|c| c.to_sym}
-          result.each {|r| r.keys = @columns; block[r]}
-        end
-      end
-    
       def insert(*values)
         @db.execute_insert insert_sql(*values)
       end

data/lib/sequel_core/connection_pool.rb

@@ -0,0 +1,150 @@
+require 'thread'
+
+# A ConnectionPool manages access to database connections by keeping
+# multiple connections and giving threads exclusive access to each
+# connection.
+class ConnectionPool
+  attr_reader :mutex
+  
+  # The maximum number of connections.
+  attr_reader :max_size
+  
+  # The proc used to create a new connection.
+  attr_accessor :connection_proc
+  
+  attr_reader :available_connections, :allocated, :created_count
+
+  # 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(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(10)
+  #   pool.connection_proc = proc {MyConnection.new(opts)}
+  def initialize(max_size = 4, &block)
+    @max_size = max_size
+    @mutex = Mutex.new
+    @connection_proc = block
+
+    @available_connections = []
+    @allocated = {}
+    @created_count = 0
+  end
+  
+  # Returns the number of created connections.
+  def size
+    @created_count
+  end
+  
+  # Assigns a connection to the current thread, yielding 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 available, Pool#hold will block until a connection
+  # is available.
+  def hold
+    t = Thread.current
+    if (conn = owned_connection(t))
+      return yield(conn)
+    end
+    while !(conn = acquire(t))
+      sleep 0.001
+    end
+    begin
+      yield conn
+    ensure
+      release(t)
+    end
+  rescue Exception => e
+    # if the error is not a StandardError it is converted into RuntimeError.
+    raise e.is_a?(StandardError) ? e : e.message
+  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)
+      @mutex.synchronize do
+        @available_connections << @allocated[thread]
+        @allocated.delete(thread)
+      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.
+class SingleThreadedPool
+  attr_reader :conn
+  attr_writer :connection_proc
+  
+  # Initializes the instance with the supplied block as the connection_proc.
+  def initialize(&block)
+    @connection_proc = block
+  end
+  
+  # Yields the connection to the supplied block. This method simulates the
+  # ConnectionPool#hold API.
+  def hold
+    @conn ||= @connection_proc.call
+    yield @conn
+  rescue Exception => e
+    # if the error is not a StandardError it is converted into RuntimeError.
+    raise e.is_a?(StandardError) ? e : e.message
+  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