rdbi 0.9.0 → 0.9.1

data/lib/rdbi/result.rb

@@ -35,7 +35,6 @@
 # RDBI::Result#fetch or more explicitly with the RDBI::Result#as call.
 #
 class RDBI::Result
-  extend MethLab
   include Enumerable
 
   # The RDBI::Schema structure associated with this result.
@@ -59,19 +58,23 @@ class RDBI::Result
   # The binds used in the statement that yielded this Result.
   attr_reader :binds
 
-  # FIXME async
-  inline(:complete, :complete?) { true }
+  # See RDBI::Statement#rewindable_result.
+  attr_reader :rewindable_result
 
-  ##
-  # :attr_reader: has_data
-  #
-  # Does this result have data?
 
-  ##
-  # :attr_reader: has_data?
-  #
+  # :nodoc: FIXME async
+  def complete
+    true
+  end
+
+  alias complete? complete
+  
   # Does this result have data?
-  inline(:has_data, :has_data?) { @data.size > 0 }
+  def has_data
+    @data.size > 0
+  end
+
+  alias has_data? has_data
 
   #
   # Creates a new RDBI::Result. Please refer to RDBI::Statement#new_execution
@@ -86,10 +89,11 @@ class RDBI::Result
     @sth            = sth
     @binds          = binds
     @type_hash      = type_hash
-    @mutex          = Mutex.new
     @driver         = RDBI::Result::Driver::Array
     @fetch_handle   = nil
-    as(@driver)
+
+    configure_rewindable
+    configure_driver(@driver)
   end
 
   #
@@ -106,6 +110,8 @@ class RDBI::Result
     @schema         = res.instance_variable_get(:@schema)
     @result_count   = res.instance_variable_get(:@result_count)
     @affected_count = res.instance_variable_get(:@affected_count)
+
+    configure_rewindable
   end
 
   #
@@ -125,7 +131,15 @@ class RDBI::Result
   end
 
   #
-  # Coerce the underlying result to an array, fetching all values.
+  # Is this result empty?
+  #
+  def empty?
+    @data.empty?
+  end
+
+  #
+  # Coerce the underlying result to an array, fetching all values. Same as
+  # setting RDBI::Result#rewindable_result.
   #
   def coerce_to_array
     @data.coerce_to_array
@@ -153,13 +167,18 @@ class RDBI::Result
   #
   # Any additional arguments will be passed to the driver's constructor.
   #
+  # This will force a rewind even if +rewindable_result+ is false.
+  #
   def as(driver_klass, *args)
 
     driver_klass  = RDBI::Util.class_from_class_or_symbol(driver_klass, RDBI::Result::Driver)
 
+    rr = @data.rewindable_result
+    @data.rewindable_result = true
     @data.rewind
+    @data.rewindable_result = rr
     @driver       = driver_klass
-    @fetch_handle = driver_klass.new(self, *args)
+    configure_driver(@driver, *args)
   end
 
   #
@@ -213,6 +232,20 @@ class RDBI::Result
     @fetch_handle.fetch(row_count)
   end
 
+  #
+  # returns the first result in the set.
+  #
+  def first
+    @data.first
+  end
+
+  #
+  # returns the last result in the set.
+  #
+  def last
+    @data.last
+  end
+
   alias read fetch
 
   #
@@ -235,7 +268,6 @@ class RDBI::Result
                 else
                   @data.fetch(row_count)
                 end
-    RDBI::Util.deep_copy(final_res)
   end
 
   #
@@ -251,6 +283,19 @@ class RDBI::Result
     @binds  = nil
     @schema = nil
   end
+
+  protected
+
+  def configure_driver(driver_klass, *args)
+    @fetch_handle = driver_klass.new(self, *args)
+  end
+
+  def configure_rewindable
+    @rewindable_result = @sth.rewindable_result
+    if self.rewindable_result
+      @data.coerce_to_array
+    end
+  end
 end
 
 #
@@ -289,7 +334,6 @@ class RDBI::Result::Driver
   #
   def initialize(result, *args)
     @result = result
-    @result.rewind
   end
 
   #
@@ -297,26 +341,48 @@ class RDBI::Result::Driver
   # type converted array.
   #
   def fetch(row_count)
-    ary = (@result.raw_fetch(row_count) || []).enum_for.with_index.map do |item, i|
-      convert_row(item)
+    rows = RDBI::Util.format_results(row_count, (@result.raw_fetch(row_count) || []))
+
+    if rows.nil?
+      return rows 
+    elsif [:first, :last].include?(row_count)
+      return convert_row(rows)
+    else
+      result = []
+      rows.each do |row| 
+        result << convert_row(row)
+      end
     end
+    return result
+  end
+
+  #
+  # Returns the first result in the set.
+  #
+  def first
+    return fetch(:first)
+  end
 
-    RDBI::Util.format_results(row_count, ary)
+  #
+  # Returns the last result in the set.
+  #
+  # +Warning+: Depending on your database and drivers, calling this could have
+  # serious memory and performance implications!
+  #
+  def last
+    return fetch(:last)
   end
 
-  # convert an entire row of data with the specified result map (see
-  # RDBI::Type)
+  protected
+
   def convert_row(row)
-    newrow = []
-    (row || []).each_with_index do |x, i|
-      newrow.push(convert_item(x, @result.schema.columns[i]))
+    return [] if row.nil?
+    
+    row.each_with_index do |x, i|
+      row[i] = RDBI::Type::Out.convert(x, @result.schema.columns[i], @result.type_hash)
     end
-    return newrow
-  end
 
-  # convert a single item (row element) with the specified result map.
-  def convert_item(item, column)
-    RDBI::Type::Out.convert(item, column, @result.type_hash)
+    return row
   end
 end
 
@@ -399,4 +465,48 @@ class RDBI::Result::Driver::Struct < RDBI::Result::Driver
   end
 end
 
+# 
+# Yields YAML representations of rows, each as an array keyed by the column
+# name (as symbol, not string).
+#
+# For example, a table:
+#
+#   create table foo (i integer, x varchar);
+#   insert into foo (i, x) values (1, "bar");
+#   insert into foo (i, x) values (2, "foo");
+#   insert into foo (i, x) values (3, "quux");
+#
+# With a query as such:
+#
+#   dbh.execute("select * from foo").as(:YAML).fetch(:all)
+#
+# Will yield:
+#
+#   --- 
+#   - :i: 1
+#     :x: bar 
+#   - :i: 2
+#     :x: foo
+#   - :i: 3 
+#     :x: quux
+#
+class RDBI::Result::Driver::YAML < RDBI::Result::Driver
+  def initialize(result, *args)
+    super
+    RDBI::Util.optional_require('yaml')
+  end
+
+  def fetch(row_count)
+    column_names = @result.schema.columns.map(&:name)
+
+    if [:first, :last].include?(row_count)
+      Hash[column_names.zip(@result.raw_fetch(row_count)[0])].to_yaml
+    else
+      @result.raw_fetch(row_count).collect do |row|
+        Hash[column_names.zip(row)]
+      end.to_yaml
+    end
+  end
+end
+
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/lib/rdbi/statement.rb

@@ -83,14 +83,10 @@
 # may be possible.
 #
 class RDBI::Statement
-  extend MethLab
-
   # the RDBI::Database handle that created this statement.
   attr_reader :dbh
   # The query this statement was created for.
   attr_reader :query
-  # A mutex for locked operations. Basically a cached copy of Mutex.new.
-  attr_reader :mutex
   # The input type map provided during statement creation -- used for binding.
   attr_reader :input_type_map
 
@@ -98,68 +94,81 @@ class RDBI::Statement
   # :attr_reader: last_result
   #
   # The last RDBI::Result this statement yielded.
-  attr_threaded_accessor :last_result
+  attr_accessor :last_result
 
   ##
-  # :attr_reader: finished
+  # :attr_reader: rewindable_result
   #
-  # Has this statement been finished?
+  # Allows the user to request a fully rewindable result, allowing the use of
+  # fetching the last item, direct indexing, and rewinding.
+  #
+  # This can be a huge performance impact and thus should be used with great
+  # caution.
+  #
+  # Cascades from RDBI::Database#rewindable_result and through
+  # RDBI::Result#rewindable_result.
+  #
+  attr_accessor :rewindable_result
 
   ##
-  # :attr_reader: finished?
+  # :attr_reader: finished
   #
   # Has this statement been finished?
 
-  inline(:finished, :finished?)   { @finished  }
+  # Has this statement been finished?
+
+  attr_reader :finished
+  alias finished? finished
 
-  ##
-  # :attr_reader: driver
-  #
   # The RDBI::Driver object that this statement belongs to.
+  def driver
+    dbh.driver
+  end
 
-  inline(:driver)                 { dbh.driver }
+  class << self
+    def input_type_map
+      @input_type_map ||= RDBI::Type.create_type_hash(RDBI::Type::In)
+    end
+  end
 
   #
   # Initialize a statement handle, given a text query and the RDBI::Database
   # handle that created it.
   #
   def initialize(query, dbh)
-    @query = query
-    @dbh   = dbh
-    @mutex = Mutex.new
-    @finished = false
-    @input_type_map = RDBI::Type.create_type_hash(RDBI::Type::In)
+    @query                 = query
+    @dbh                   = dbh
+    @finished              = false
+    @input_type_map        = self.class.input_type_map
 
-    @dbh.open_statements.push(self)
+    self.rewindable_result = dbh.rewindable_result
+    @dbh.open_statements[self.object_id] = self
+  end
+
+  def prep_finalizer(&block)
+    if block
+      @finish_block = block
+      ObjectSpace.define_finalizer(self, lambda do |x| 
+        block.call
+      end)
+    end
   end
 
   #
   # Execute the statement with the supplied binds.
   #
   def execute(*binds)
-    raise StandardError, "you may not execute a finished handle" if @finished
-
-    # XXX if we ever support some kind of hash type, this'll get ugly.
-    hashes, binds = binds.partition { |x| x.kind_of?(Hash) }
+    binds = pre_execute(*binds)
 
-    if hashes
-      hashes.collect! do |hash|
-        newhash = { }
-
-        hash.each do |key, value|
-          newhash[key] = RDBI::Type::In.convert(value, @input_type_map)
-        end
-
-        newhash
-      end
-    end
+    cursor, schema, type_map = new_execution(*binds)
+    cursor.rewindable_result = self.rewindable_result
+    self.last_result = RDBI::Result.new(self, binds, cursor, schema, type_map)
+  end
 
-    binds = (hashes || []) + binds.collect { |x| RDBI::Type::In.convert(x, @input_type_map) } 
+  def execute_modification(*binds)
+    binds = pre_execute(*binds)
 
-    mutex.synchronize do
-      exec_args = *new_execution(*binds)
-      self.last_result = RDBI::Result.new(self, binds, *exec_args)
-    end
+    return new_modification(*binds)
   end
 
   #
@@ -170,10 +179,9 @@ class RDBI::Statement
   # 'super' as their last statement.
   #
   def finish
-    mutex.synchronize do
-      dbh.open_statements.reject! { |x| x.object_id == self.object_id }
-      @finished = true
-    end
+    @finish_block.call if @finish_block
+    @dbh.open_statements.delete(self.object_id)
+    @finished = true
   end
 
   ##
@@ -196,9 +204,29 @@ class RDBI::Statement
   # to this call) to RDBI::Result.new.
   #
 
-  inline(:new_execution) do |*args|
+  def new_execution
+    raise NoMethodError, "this method is not implemented in this driver"
+  end
+
+  def new_modification(*binds)
     raise NoMethodError, "this method is not implemented in this driver"
   end
+
+  protected
+
+  def pre_execute(*binds)
+    raise StandardError, "you may not execute a finished handle" if @finished
+
+    if binds[0].kind_of?(Hash)
+      binds[0].each do |key, value|
+        binds[0][key] = RDBI::Type::In.convert(value, @input_type_map)
+      end
+    else
+      binds.collect! { |x| RDBI::Type::In.convert(x, @input_type_map) } 
+    end
+
+    return binds
+  end
 end
 
 # vim: syntax=ruby ts=2 et sw=2 sts=2

data/lib/rdbi/types.rb

@@ -115,16 +115,17 @@ module RDBI::Type
 
   # Shorthand for creating a new +TypeLib::FilterList+.
   def self.filterlist(*ary)
-    TypeLib::FilterList.new([Filters::NULL, *ary])
+    [Filters::NULL, *ary]
   end
 
   # Shorthand to duplicate the +DEFAULTS+ hash from a module. Most frequently
   # used to get a copy of the RDBI::Type::In and RDBI::Type::Out type maps.
   def self.create_type_hash(klass)
     hash = { }
-    klass::DEFAULTS.each do |key, value|
+    orig = klass::DEFAULTS
+    orig.keys.each do |key|
       flist = filterlist()
-      value.each do |filter|
+      orig[key].each do |filter|
         flist << filter
       end
       hash[key] = flist
@@ -140,12 +141,12 @@ module RDBI::Type
   #
   module Out
     DEFAULTS = {
-      :integer     => RDBI::Type.filterlist(Filters::STR_TO_INT),
-      :decimal     => RDBI::Type.filterlist(Filters::STR_TO_DEC),
-      :datetime    => RDBI::Type.filterlist(TypeLib::Canned.build_strptime_filter(DEFAULT_STRFTIME_FILTER)),
-      :timestamp   => RDBI::Type.filterlist(TypeLib::Canned.build_strptime_filter(DEFAULT_STRFTIME_FILTER)),
-      :boolean     => RDBI::Type.filterlist(Filters::TO_BOOLEAN),
-      :default     => RDBI::Type.filterlist()
+      :integer     => [Filters::STR_TO_INT],
+      :decimal     => [Filters::STR_TO_DEC],
+      :datetime    => [TypeLib::Canned.build_strptime_filter(DEFAULT_STRFTIME_FILTER)],
+      :timestamp   => [TypeLib::Canned.build_strptime_filter(DEFAULT_STRFTIME_FILTER)],
+      :boolean     => [Filters::TO_BOOLEAN],
+      :default     => []
     }
 
     #
@@ -159,7 +160,7 @@ module RDBI::Type
         fl = type_hash[:default]
       end
 
-      fl.execute(obj)
+      TypeLib.execute_filterlist(fl, obj)
     end
   end
 
@@ -171,14 +172,14 @@ module RDBI::Type
   #
   module In
     DEFAULTS = {
-      Integer    => RDBI::Type.filterlist(Filters::FROM_INTEGER),
-      Fixnum     => RDBI::Type.filterlist(Filters::FROM_INTEGER),
-      Float      => RDBI::Type.filterlist(Filters::FROM_NUMERIC),
-      BigDecimal => RDBI::Type.filterlist(Filters::FROM_DECIMAL),
-      DateTime   => RDBI::Type.filterlist(Filters::FROM_DATETIME),
-      TrueClass  => RDBI::Type.filterlist(Filters::FROM_BOOLEAN),
-      FalseClass => RDBI::Type.filterlist(Filters::FROM_BOOLEAN),
-      :default   => RDBI::Type.filterlist()
+      Integer    => [Filters::FROM_INTEGER],
+      Fixnum     => [Filters::FROM_INTEGER],
+      Float      => [Filters::FROM_NUMERIC],
+      BigDecimal => [Filters::FROM_DECIMAL],
+      DateTime   => [Filters::FROM_DATETIME],
+      TrueClass  => [Filters::FROM_BOOLEAN],
+      FalseClass => [Filters::FROM_BOOLEAN],
+      :default   => []
     }
 
     #
@@ -192,7 +193,7 @@ module RDBI::Type
         fl = type_hash[:default]
       end
 
-      fl.execute(obj)
+      TypeLib.execute_filterlist(fl, obj)
     end
   end
 end