Adding support for read only queries.

CHANGELOG.rdoc

@@ -5,7 +5,10 @@ Below is a complete listing of changes for each revision of Oklahoma Mixer.
 == 0.4.0
 
 * Added the read_only?() method
-* Added error handling for table queries
+* Added error handling for Table Databases queries
+* Added support for Table Databases queries on read only databases
+* Added support for iteration blocks to Table Databases searches
+* Modified Table Databases blocks to yield tuples consistent with the iterators
 
 == 0.3.0
 

TODO.rdoc

@@ -4,8 +4,6 @@ The following is a list of planned expansions for Oklahoma Mixer in the order I
 intend to address them.
 
 1. Resolve minor issues
-  * Support a read only-version of all() without a block
-  * Make all() yield() like Hash#each (a key-value tuple)
   * Speed up counts (fetch keys only to prevent HashMap conversion)
   * Push :select down into all() call to speed up paginate()
 2. Include some higher level abstractions like mixed tables, queues, and shards

lib/oklahoma_mixer/array_list.rb

@@ -11,17 +11,12 @@ def initialize(pointer_or_size)
 
     attr_reader :pointer
 
-    def shift
-      value = C.read_from_func(:shift, @pointer)
-      block_given? ? yield(value) : value
-    end
+    include Enumerable
 
-    def map
-      values = [ ]
-      while value = shift
-        values << yield(value)
+    def each
+      (0...C.num(pointer)).each do |i|
+        yield C.read_from_func(:val, :no_free, @pointer, i)
       end
-      values
     end
 
     def push(*values)

lib/oklahoma_mixer/array_list/c.rb

@@ -12,10 +12,14 @@ module C  # :nodoc:
            :returns => :pointer
       func :name    => :del,
            :args    => :pointer
-
-      func :name    => :shift,
-           :args    => [:pointer, :pointer],
+
+      func :name    => :num,
+           :args    => :pointer,
+           :returns => :int
+      func :name    => :val,
+           :args    => [:pointer, :int, :pointer],
            :returns => :pointer
+
       func :name    => :push,
            :args    => [:pointer, :pointer, :int]
     end

lib/oklahoma_mixer/table_database.rb

@@ -114,7 +114,7 @@ def each
     def all(options = { }, &iterator)
       query(options) do |q|
         mode = results_mode(options)
-        if block_given?
+        if not iterator.nil? and not read_only?
           results  = self
           callback = lambda { |key_pointer, key_size, doc_map, _|
             if mode != :docs
@@ -125,9 +125,10 @@ def all(options = { }, &iterator)
               doc = map.to_hash { |string| cast_to_encoded_string(string) }
             end
             flags = case mode
-                    when :keys then yield(key)
-                    when :docs then yield(doc)
-                    else            yield(key, doc)
+                    when :keys then iterator[key]
+                    when :docs then iterator[doc]
+                    when :aoh  then iterator[doc.merge!(:primary_key => key)]
+                    else            iterator[[key, doc]]
                     end
             Array(flags).inject(0) { |returned_flags, flag|
               returned_flags | case flag.to_s
@@ -144,34 +145,16 @@ def all(options = { }, &iterator)
                                end
             }
           }
+          unless lib.qryproc(q.pointer, callback, nil)
+            error_code    = lib.ecode(@db)
+            error_message = lib.errmsg(error_code)
+            fail Error::QueryError,
+                 "#{error_message} (error code #{error_code})"
+          end
+          results
         else
-          results  = mode != :hoh ? [ ] : { }
-          callback = lambda { |key_pointer, key_size, doc_map, _|
-            if mode == :docs
-              results << cast_value_out(doc_map, :no_free)
-            else
-              key = cast_key_out(key_pointer.get_bytes(0, key_size))
-              case mode
-              when :keys
-                results << key
-              when :hoh
-                results[key] = cast_value_out(doc_map, :no_free)
-              when :aoh
-                results << cast_value_out(doc_map, :no_free).
-                           merge(:primary_key => key)
-              else
-                results << [key, cast_value_out(doc_map, :no_free)]
-              end
-            end
-            0
-          }
+          query_results(lib.qrysearch(q.pointer), mode, &iterator)
         end
-        unless lib.qryproc(q.pointer, callback, nil)
-          error_code    = lib.ecode(@db)
-          error_message = lib.errmsg(error_code)
-          fail Error::QueryError, "#{error_message} (error code #{error_code})"
-        end
-        results
       end
     end
 
@@ -196,7 +179,8 @@ def paginate(options)
       fail Error::QueryError, ":per_page must be >= 1" if results.per_page < 1
       results.total_entries = 0
       all( options.merge( :select => :keys_and_docs,
-                          :limit  => nil ) ) { |key, value|
+                          :return => :aoa,
+                          :limit  => nil ) ) do |key, value|
         if results.total_entries >= results.offset and
            results.size          <  results.per_page
           case mode
@@ -213,21 +197,21 @@ def paginate(options)
           end
         end
         results.total_entries += 1
-      }
+      end
       results
     end
 
-    def union(q, *queries)
-      search([q] + queries, lib::SEARCHES[:TDBMSUNION])
+    def union(q, *queries, &iterator)
+      search([q] + queries, lib::SEARCHES[:TDBMSUNION], &iterator)
     end
 
-    def intersection(q, *queries)
-      search([q] + queries, lib::SEARCHES[:TDBMSISECT])
+    def intersection(q, *queries, &iterator)
+      search([q] + queries, lib::SEARCHES[:TDBMSISECT], &iterator)
     end
     alias_method :isect, :intersection
 
-    def difference(q, *queries)
-      search([q] + queries, lib::SEARCHES[:TDBMSDIFF])
+    def difference(q, *queries, &iterator)
+      search([q] + queries, lib::SEARCHES[:TDBMSDIFF], &iterator)
     end
     alias_method :diff, :difference
 
@@ -365,42 +349,68 @@ def results_mode(options)
       end
     end
 
-    def search(queries, operation)
-      mode = results_mode(queries.first)
-      qs   = queries.map { |q| query(q) }
-      keys = ArrayList.new( Utilities.temp_pointer(qs.size) do |pointer|
-        pointer.write_array_of_pointer(qs.map { |q| q.pointer })
-        lib.metasearch(pointer, qs.size, operation)
-      end )
-      case mode
-      when :keys
-        keys.map { |key| cast_key_out(key) }
-      when :docs
-        keys.map { |key| self[cast_key_out(key)] }
-      when :hoh
-        results = { }
-        while key = keys.shift { |k| cast_key_out(k) }
-          results[key] = self[key]
+    def query_results(results, mode, &iterator)
+      keys = ArrayList.new(results)
+      if iterator.nil?
+        results  = mode == :hoh ? { } : [ ]
+        iterator = lambda do |key_and_value|
+          if mode == :hoh
+            results[key_and_value.first] = key_and_value.last
+          else
+            results << key_and_value
+          end
         end
-        results
-      when :aoh
-        keys.map { |key|
-          key = cast_key_out(key)
-          self[key].merge(:primary_key => key)
-        }
       else
-        keys.map { |key|
-          key = cast_key_out(key)
-          [key, self[key]]
-        }
+        results = self
+      end
+      keys.each do |key|
+        flags = Array( case mode
+        when :keys
+          iterator[cast_key_out(key)]
+        when :docs
+          iterator[self[cast_key_out(key)]]
+        when :aoh
+          k = cast_key_out(key)
+          iterator[self[k].merge!(:primary_key => k)]
+        else
+          k = cast_key_out(key)
+          v = self[k]
+          iterator[[k, v]]
+        end ).map { |flag| flag.to_s }
+        if flags.include? "delete"
+          if read_only?
+            warn "attempted delete from a read only query"
+          else
+            delete(key)
+          end
+        elsif v and flags.include? "update"
+          if read_only?
+            warn "attempted update from a read only query"
+          else
+            self[k] = v
+          end
+        end
+        break if flags.include? "break"
+      end
+      results
+    ensure
+      keys.free if keys
+    end
+
+    def search(queries, operation, &iterator)
+      qs = queries.map { |q| query(q) }
+      Utilities.temp_pointer(qs.size) do |pointer|
+        pointer.write_array_of_pointer(qs.map { |q| q.pointer })
+        query_results( lib.metasearch(pointer, qs.size, operation),
+                       results_mode(queries.first),
+                       &iterator)
       end
     ensure
       if qs
         qs.each do |q|
           q.free
         end
       end
-      keys.free if keys
     end
   end
 end

lib/oklahoma_mixer/table_database/c.rb

@@ -90,6 +90,9 @@ module C  # :nodoc:
            :args    => [:pointer, :string, INDEXES],
            :returns => :bool
 
+      func :name    => :qrysearch,
+           :args    => :pointer,
+           :returns => :pointer
       call :name    => :TDBQRYPROC,
            :args    => [:pointer, :int, :pointer, :pointer],
            :returns => :int