og 0.24.0 → 0.25.0

data/lib/og/store/sqlite.rb

@@ -14,19 +14,19 @@ require 'og/store/sql'
 
 class SQLite3::ResultSet
   alias_method :blank?, :eof?
-  
+
   def each_row
     each do |row|
       yield(row, 0)
     end
   end
-  
+
   def first_value
     val = self.next[0]
     close
     return val
-  end  
-  
+  end
+
   alias_method :fields, :columns
 end
 
@@ -39,11 +39,12 @@ module Og
 class SqliteStore < SqlStore
 
   # Override if needed.
-  
+
   def self.db_filename(options)
+    options[:name] ||= 'data'
     "#{options[:name]}.db"
   end
-  
+
   def self.destroy(options)
     begin
       FileUtils.rm(db_filename(options))  
@@ -53,6 +54,9 @@ class SqliteStore < SqlStore
     end
   end
 
+  # Initialize the Sqlite store.
+  # This store provides a default name.
+  
   def initialize(options)
     super
     @conn = SQLite3::Database.new(self.class.db_filename(options))
@@ -62,9 +66,9 @@ class SqliteStore < SqlStore
     @conn.close
     super
   end
-  
+
   def enchant(klass, manager)
-    if klass.ann.this.primary_key.symbol == :oid
+    if klass.ann.self.primary_key.symbol == :oid
       unless klass.properties.include? :oid
         klass.property :oid, Fixnum, :sql => 'integer PRIMARY KEY'
       end
@@ -91,12 +95,12 @@ class SqliteStore < SqlStore
     @conn.transaction if @transaction_nesting < 1
     @transaction_nesting += 1
   end
-  
+
   def commit
     @transaction_nesting -= 1
     @conn.commit if @transaction_nesting < 1
   end
-  
+
   def rollback
     @transaction_nesting -= 1
     @conn.rollback if @transaction_nesting < 1
@@ -117,18 +121,18 @@ private
     fields = fields_for_class(klass)
 
     sql = "CREATE TABLE #{klass::OGTABLE} (#{fields.join(', ')}"
-    
+
     # Create table constraints.
-    
-    if constraints = klass.ann.this[:sql_constraint]
+
+    if constraints = klass.ann.self[:sql_constraint]
       sql << ", #{constraints.join(', ')}"
     end
-    
+
     sql << ");"
-    
+
     # Create indices.
-    
-    if indices = klass.ann.this[:index]
+
+    if indices = klass.ann.self[:index]
       for data in indices
         idx, options = *data
         idx = idx.to_s
@@ -150,11 +154,11 @@ private
         raise
       end
     end
-    
+
     # Create join tables if needed. Join tables are used in
     # 'many_to_many' relations.
-    
-     if join_tables = klass.ann.this[:join_tables]
+
+    if join_tables = klass.ann.self[:join_tables]
       for info in join_tables
         begin
           create_join_table_sql(info).each do |sql|
@@ -176,13 +180,13 @@ private
   def create_field_map(klass)
     res = @conn.query "SELECT * FROM #{klass::OGTABLE} LIMIT 1"
     map = {}
-    
+
     fields = res.columns
 
     res.fields.size.times do |i|
       map[fields[i].intern] = i
     end
-  
+
     return map
   ensure
     res.close if res
@@ -197,15 +201,15 @@ private
       props << Property.new(:symbol => :ogtype, :klass => String)
       values << ", '#{klass}'"
     end
-    
+
     sql = "INSERT INTO #{klass::OGTABLE} (#{props.collect {|p| field_for_property(p)}.join(',')}) VALUES (#{values})"
 
     klass.class_eval %{ 
       def og_insert(store)
-        #{Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :pre) if klass.respond_to?(:advices)}
         store.query("#{sql}").close
         @#{pk} = store.last_insert_rowid        
-        #{Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
+        #{Glue::Aspects.gen_advice_code(:og_insert, klass.advices, :post) if klass.respond_to?(:advices)}
       end
     }
   end

data/lib/og/validation.rb

@@ -14,34 +14,41 @@ module Validation
     cattr_accessor :invalid_relation, 'Invalid relations'
   end
 
-  module MetaLanguage 
-
-    # Validate the value of this attribute is unique
-    # for this class.
+  module ClassMethods 
+    
+    # Validates that the given field(s) contain unique values.
+    # Ensures that if a record is found with a matching value,
+    # that it is the same record, allowing updates.
     #
     # The Og libraries are required for this methdod to 
     # work. You can override this method if you want to
     # use another OR mapping library.
     #
+    # === Example
+    #
+    # validate_unique :param, :msg => 'Value is already in use'
     #--
     # TODO: :unique should implicitly generate 
     # validate_unique.
     #++
-
+    
     def validate_unique(*params)
-      c = { 
-        :msg => Glue::Validation::Errors.not_unique, 
-        :on => :save 
+      c = {
+        :on => :save
       }
       c.update(params.pop) if params.last.is_a?(Hash)
 
-      for name in params
-        # FIXME: improve the generated code.
+      for name in params do
+        c[:msg] ||= "#{self.name} with this #{name} already exists"
+
         code = %{
-          others = obj.class.find_by_#{name}(obj.#{name})
-          unless (others.is_a?(Array) and others.empty?)
-            errors.add(:#{name}, '#{c[:msg]}')
-          end;
+          others = obj.class.send(:find_by_#{name}, obj.send(:#{name}))
+  
+          unless others.empty?
+            if (others.size != 1) or (others[0].oid != obj.oid)
+              errors.add(:#{name}, '#{c[:msg]}')
+            end
+          end
         }
 
         validations! << [code, c[:on]]
@@ -75,3 +82,6 @@ module Validation
 end 
 
 end
+
+# * George Moschovitis <gm@navel.gr>
+# * Bryan Soto

data/lib/{vendor → og/vendor}/kbserver.rb

@@ -11,7 +11,7 @@ port = 44444
 puts 'Initializing database server and indexes...'
 
 # Create an instance of the database.
-db = KirbyBase.new(:server)
+db = KirbyBase.new(:server) 
 
 DRb.start_service('druby://:44444', db)
 

data/lib/{vendor → og/vendor}/kirbybase.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'time'
 require 'drb'
 require 'csv'
 require 'fileutils'
@@ -83,6 +84,31 @@ require 'yaml'
 #   :manager, :person (where :manager is the field name, and :person is the
 #   name of a table).  See the docs for the specifics or ask Hal. :)
 #
+# 2005-11-13:: Version 2.4
+# * Added a new column type: :Time.  Thanks to George Moschovitis for coding
+#   this enhancement.
+# * Added more functionality to Memo and Blob fields.  They are no longer
+#   just read-only.  You can now also write to them from KirbyBase.  The
+#   interface for Memo and Blob fields has changed because of this.
+# * Added the ability to specify, when you initialize a database connection,
+#   a base directory where memo/blob fields will be stored.
+# * Changed the way indexes are handled by KBTable in client/server mode.
+#   Now, when KBTable grabs an index from KBEngine, it will hold onto it and
+#   re-use it unless it has been modified since the last time it grabbed it.
+#   This speeds up subsequent queries on the same index.
+# * Removed the restriction that the child table had to exist before you
+#   could define a Link_many field in #create_table.  I did this so that
+#   it would possible to now define many-to-many links.  See the example in
+#   the distribution.  This also goes for Lookup fields.
+# * Added two sample scripts:  kbserverctl.rb and kbserver_daemon.rb, that
+#   show how to set up a KirbyBase server process as a Windows Service.
+#   Thanks to Daniel Berger for his excellent package, win32-service.
+# * Thouroughly revised the manual.  I used the excellent text document
+#   formatter, AsciiDoc.  Many thanks to Stuart Rackham for developing this
+#   great tool.
+# * Fixed a bug in KBTable#clear that was causing the recno counter not to
+#   be reset.  Thanks to basi for this.
+#
 #---------------------------------------------------------------------------
 # KirbyBase
 #---------------------------------------------------------------------------
@@ -91,7 +117,7 @@ class KirbyBase
 
     attr_reader :engine
 
-    attr_accessor(:connect_type, :host, :port, :path, :ext)
+    attr_accessor(:connect_type, :host, :port, :path, :ext, :memo_blob_path)
 
     #-----------------------------------------------------------------------
     # initialize
@@ -107,14 +133,17 @@ class KirbyBase
     #          (Only valid if connect_type is :client.)
     # *path*:: String specifying path to location of database tables.
     # *ext*:: String specifying extension of table files.
+    # *memo_blob_path*:: String specifying path to location of memo/blob
+    #                    files.
     #
     def initialize(connect_type=:local, host=nil, port=nil, path='./',
-     ext='.tbl')
+     ext='.tbl', memo_blob_path='./')
         @connect_type = connect_type
         @host = host
         @port = port
         @path = path
         @ext = ext
+        @memo_blob_path = memo_blob_path
 
         # See if user specified any method arguments via a code block.
         yield self if block_given?
@@ -122,7 +151,7 @@ class KirbyBase
         # After the yield, make sure the user doesn't change any of these
         # instance variables.
         class << self
-            private(:connect_type=, :host=, :path=, :ext=)
+            private(:connect_type=, :host=, :path=, :ext=, :memo_blob_path=)
         end
 
         # Did user supply full and correct arguments to method?
@@ -134,6 +163,7 @@ class KirbyBase
          @port.nil?
         raise "Invalid path!" if @path.nil?
         raise "Invalid extension!" if @ext.nil?
+        raise "Invalid memo/blob path!" if @memo_blob_path.nil?
 
         @table_hash = {}
 
@@ -144,6 +174,7 @@ class KirbyBase
             @engine = @server.engine
             @path = @server.path
             @ext = @server.ext
+            @memo_blob_path = @server.memo_blob_path
         else
             @engine = KBEngine.create_called_from_database_instance(self)
         end
@@ -230,8 +261,8 @@ class KirbyBase
             return @table_hash[name]
         else
             @table_hash[name] = \
-             KBTable.create_called_from_database_instance(self,
-             name, File.join(@path, name.to_s + @ext))
+             KBTable.create_called_from_database_instance(self, name, 
+              File.join(@path, name.to_s + @ext))
             return @table_hash[name]
         end
     end
@@ -445,6 +476,13 @@ class KBEngine
         @recno_indexes.delete(tablename)
     end
 
+    #-----------------------------------------------------------------------
+    # update_recno_index
+    #-----------------------------------------------------------------------
+    def update_recno_index(table, recno, fpos)
+        @recno_indexes[table.name].update_index_rec(recno, fpos)
+    end
+
     #-----------------------------------------------------------------------
     # recno_index_exists?
     #-----------------------------------------------------------------------
@@ -508,20 +546,6 @@ class KBEngine
         end
     end
 
-    #-----------------------------------------------------------------------
-    # index_exists?
-    #-----------------------------------------------------------------------
-    def index_exists?(table, index_fields)
-        @indexes.include?("#{table.name}_#{index_fields.join('_')}".to_sym)
-    end
-
-    #-----------------------------------------------------------------------
-    # update_recno_index
-    #-----------------------------------------------------------------------
-    def update_recno_index(table, recno, fpos)
-        @recno_indexes[table.name].update_index_rec(recno, fpos)
-    end
-
     #-----------------------------------------------------------------------
     # update_to_indexes
     #-----------------------------------------------------------------------
@@ -532,6 +556,13 @@ class KBEngine
         end
     end
 
+    #-----------------------------------------------------------------------
+    # index_exists?
+    #-----------------------------------------------------------------------
+    def index_exists?(table, index_fields)
+        @indexes.include?("#{table.name}_#{index_fields.join('_')}".to_sym)
+    end
+
     #-----------------------------------------------------------------------
     # get_index
     #-----------------------------------------------------------------------
@@ -539,6 +570,13 @@ class KBEngine
         return @indexes["#{table.name}_#{index_name}".to_sym].get_idx
     end
 
+    #-----------------------------------------------------------------------
+    # get_index_timestamp
+    #-----------------------------------------------------------------------
+    def get_index_timestamp(table, index_name)
+        return @indexes["#{table.name}_#{index_name}".to_sym].get_timestamp
+    end
+
     #-----------------------------------------------------------------------
     # get_recno_index
     #-----------------------------------------------------------------------
@@ -686,6 +724,19 @@ class KBEngine
         return get_recs(table).size
     end
 
+    #-----------------------------------------------------------------------
+    # reset_recno_ctr
+    #-----------------------------------------------------------------------
+    def reset_recno_ctr(table)
+        with_write_locked_table(table) do |fptr|
+            last_rec_no, rest_of_line = get_header_record(table, fptr
+             ).split('|', 2)
+            write_header_record(table, fptr, 
+             ['%06d' % 0, rest_of_line].join('|'))
+            return true
+        end
+    end
+
     #-----------------------------------------------------------------------
     # get_header_vars
     #-----------------------------------------------------------------------
@@ -769,8 +820,11 @@ class KBEngine
             # Skip header rec.
             fptr.readline
 
-            recnos.collect { |r| [recno_idx[r], r]
-             }.sort.each do |r|
+            # Take all the recnos you want to get, add the file positions
+            # to them, and sort by file position, so that when we seek 
+            # through the physical file we are going in ascending file
+            # position order, which should be fastest.
+            recnos.collect { |r| [recno_idx[r], r] }.sort.each do |r|
                 fptr.seek(r[0])
                 line = fptr.readline
                 line.chomp!
@@ -1079,29 +1133,53 @@ class KBEngine
     end
 
     #-----------------------------------------------------------------------
-    # get_memo
+    # read_memo_file
     #-----------------------------------------------------------------------
-    def get_memo(filepath)
+    def read_memo_file(filepath)
         begin
-            f = File.new(filepath)
-            return f.readlines
+            f = File.new(File.join(@db.memo_blob_path, filepath))
+            return f.read
         ensure
             f.close
         end
     end
 
     #-----------------------------------------------------------------------
-    # get_blob
+    # write_memo_file
     #-----------------------------------------------------------------------
-    def get_blob(filepath)
+    def write_memo_file(filepath, contents)
         begin
-            f = File.new(filepath, 'rb')
+            f = File.new(File.join(@db.memo_blob_path, filepath), 'w')
+            f.write(contents)
+        ensure
+            f.close
+        end
+    end
+
+    #-----------------------------------------------------------------------
+    # read_blob_file
+    #-----------------------------------------------------------------------
+    def read_blob_file(filepath)
+        begin
+            f = File.new(File.join(@db.memo_blob_path, filepath), 'rb')
             return f.read
         ensure
             f.close
         end
     end
 
+    #-----------------------------------------------------------------------
+    # write_blob_file
+    #-----------------------------------------------------------------------
+    def write_blob_file(filepath, contents)
+        begin
+            f = File.new(File.join(@db.memo_blob_path, filepath), 'wb')
+            f.write(contents)
+        ensure
+            f.close
+        end
+    end
+    
 
     #-----------------------------------------------------------------------
     # PRIVATE METHODS
@@ -1217,17 +1295,6 @@ class KBEngine
         end
     end
 
-    #-----------------------------------------------------------------------
-    # reset_rec_no_ctr
-    #-----------------------------------------------------------------------
-    def reset_rec_no_ctr(table, fptr)
-        last_rec_no, rest_of_line = get_header_record(table, fptr).split(
-         '|', 2)
-        write_header_record(table, fptr, ['%06d' % 0, rest_of_line].join(
-         '|'))
-        return true
-    end
-
     #-----------------------------------------------------------------------
     # incr_rec_no_ctr
     #-----------------------------------------------------------------------
@@ -1344,10 +1411,10 @@ module KBTypeConversionsMixin
             else
                 return true
             end
+        when :Time
+            return Time.parse(s)    
         when :Date
             return Date.parse(s)
-        when :Time
-            return Time.parse(s)
         when :DateTime
             return DateTime.parse(s)
         when :YAML
@@ -1370,9 +1437,13 @@ module KBTypeConversionsMixin
                 return YAML.load(s)
             end
         when :Memo
-            return KBMemo.new(@tbl.db, s)
+            memo = KBMemo.new(@tbl.db, s)
+            memo.read_from_file
+            return memo
         when :Blob
-            return KBBlob.new(@tbl.db, s)
+            blob = KBBlob.new(@tbl.db, s)
+            blob.read_from_file
+            return blob
         else
             raise "Invalid field type: %s" % data_type
         end
@@ -1391,7 +1462,7 @@ class KBTable
     private_class_method :new
 
     VALID_FIELD_TYPES = [:String, :Integer, :Float, :Boolean, :Date, :Time,
-                         :DateTime, :Memo, :ResultSet, :YAML]
+                         :DateTime, :Memo, :Blob, :ResultSet, :YAML]
 
     VALID_INDEX_TYPES = [:String, :Integer, :Float, :Boolean, :Date, :Time,
                          :DateTime]
@@ -1452,6 +1523,8 @@ class KBTable
         @filename = filename
         @encrypted = false
         @lookup_key = :recno
+        @idx_timestamps = {}
+        @idx_arrs = {}
 
         # Alias delete_all to clear method.
         alias delete_all clear
@@ -1547,6 +1620,14 @@ class KBTable
         # Check the field values to make sure they are proper types.
         validate_input(input_rec)
 
+        if @field_types.include?(:Memo)
+            input_rec.each_value { |r| r.write_to_file if r.is_a?(KBMemo) }
+        end
+                        
+        if @field_types.include?(:Blob)
+            input_rec.each_value { |r| r.write_to_file if r.is_a?(KBBlob) }
+        end
+                        
         return @db.engine.insert_record(self, @field_names.zip(@field_types
          ).collect do |fn, ft|
             convert_to_string(ft, input_rec.fetch(fn, ''))
@@ -1624,6 +1705,14 @@ class KBTable
         # type.
         validate_input(update_rec)
 
+        if @field_types.include?(:Memo)
+            update_rec.each_value { |r| r.write_to_file if r.is_a?(KBMemo) }
+        end
+                        
+        if @field_types.include?(:Blob)
+            update_rec.each_value { |r| r.write_to_file if r.is_a?(KBBlob) }
+        end
+                        
         updated_recs = []
 
         # For each one of the recs that matched the update query, apply the
@@ -1680,7 +1769,7 @@ class KBTable
         delete { true }
         pack
 
-        @db.engine.reset_recno_ctr if reset_recno_ctr
+        @db.engine.reset_recno_ctr(self) if reset_recno_ctr
     end
 
     #-----------------------------------------------------------------------
@@ -1794,12 +1883,15 @@ class KBTable
     # *csv_filename*:: filename of csv file to import.
     #
     def import_csv(csv_filename)
+        records_inserted = 0
         tbl_rec = @table_class.new(self)
 
         CSV.open(csv_filename, 'r') do |row|
             tbl_rec.populate([nil] + row)
             insert(tbl_rec)
+            records_inserted += 1
         end
+        return records_inserted
     end
 
     #-----------------------------------------------------------------------
@@ -1813,7 +1905,7 @@ class KBTable
     def create_indexes
         # Create the recno index.  A recno index always gets created even if
         # there are no user-defined indexes for the table.
-        @db.engine.init_recno_index(self)
+        @db.engine.init_recno_index(self) 
 
         # There can be up to 5 different indexes on a table.  Any of these
         # indexes can be single or compound.
@@ -1830,7 +1922,7 @@ class KBTable
             next if index_col_names.empty?
 
             # Create this index on the engine.
-            @db.engine.init_index(self, index_col_names)
+            @db.engine.init_index(self, index_col_names) 
 
             # For each index found, add an instance method for it so that
             # it can be used for #selects.
@@ -1844,7 +1936,10 @@ class KBTable
                  [:#{index_col_names.join(',:')}], filter, select_cond)
             end
             END_OF_STRING
-            self.class.class_eval(select_meth_str)
+            self.class.class_eval(select_meth_str) unless @db.server?
+            
+            @idx_timestamps[index_col_names.join('_')] = nil
+            @idx_arrs[index_col_names.join('_')] = nil
         end
     end
 
@@ -1893,14 +1988,11 @@ class KBTable
                     END_OF_STRING
                 else
                     begin
-                        @db.get_table(lookup_table)
-                    rescue RuntimeError
-                        raise "Must create child table first when using " +
-                         "'Lookup'"
-                    end
-
-                    if @db.get_table(lookup_table).respond_to?(
-                     'select_by_%s_index' % key_field)
+                        unless @db.get_table(lookup_table).respond_to?(
+                         'select_by_%s_index' % key_field)
+                            raise RuntimeError
+                        end
+                        
                         get_meth_str = <<-END_OF_STRING
                         def #{field_name}
                             table = @tbl.db.get_table(:#{lookup_table})
@@ -1908,7 +2000,7 @@ class KBTable
                              r.#{key_field} == @#{field_name} }.first
                         end
                         END_OF_STRING
-                    else
+                    rescue RuntimeError
                         get_meth_str = <<-END_OF_STRING
                         def #{field_name}
                             table = @tbl.db.get_table(:#{lookup_table})
@@ -1926,14 +2018,11 @@ class KBTable
                 link_table, link_field = rest.split('.')
 
                 begin
-                    @db.get_table(link_table)
-                rescue RuntimeError
-                    raise "Must create child table first when using " +
-                     "'Link_many'"
-                end
-
-                if @db.get_table(link_table).respond_to?(
-                 'select_by_%s_index' % link_field)
+                    unless @db.get_table(link_table).respond_to?(
+                     'select_by_%s_index' % link_field)
+                        raise RuntimeError
+                    end
+                    
                     get_meth_str = <<-END_OF_STRING
                     def #{field_name}
                         table = @tbl.db.get_table(:#{link_table})
@@ -1941,7 +2030,7 @@ class KBTable
                          r.send(:#{link_field}) == @#{lookup_field} }
                     end
                     END_OF_STRING
-                else
+                rescue RuntimeError
                     get_meth_str = <<-END_OF_STRING
                     def #{field_name}
                         table = @tbl.db.get_table(:#{link_table})
@@ -2011,7 +2100,11 @@ class KBTable
                  ).gsub("|", '&pipe;')
             else
                 return x
-            end
+            end  
+        when :Memo
+            return x.filepath
+        when :Blob
+            return x.filepath
         else
             return x.to_s
         end
@@ -2103,9 +2196,15 @@ class KBTable
 
             next if data[f].nil?
             case @field_types[@field_names.index(f)]
-            when /:String|:Memo|:Blob/
+            when /:String|:Blob/
                 raise 'Invalid String value for: %s' % f unless \
                  data[f].respond_to?(:to_str)
+            when :Memo
+                raise 'Invalid Memo value for: %s' % f unless \
+                 data[f].is_a?(KBMemo) 
+            when :Blob
+                raise 'Invalid Blob value for: %s' % f unless \
+                 data[f].is_a?(KBBlob) 
             when :Boolean
                 raise 'Invalid Boolean value for: %s' % f unless \
                  data[f].is_a?(TrueClass) or data[f].kind_of?(FalseClass)
@@ -2115,12 +2214,12 @@ class KBTable
             when :Float
                 raise 'Invalid Float value for: %s' % f unless \
                  data[f].respond_to?(:to_f)
+            when :Time
+                raise 'Invalid Time value for: %s' % f unless \
+                 data[f].is_a?(Time)     
             when :Date
                 raise 'Invalid Date value for: %s' % f unless \
                  data[f].is_a?(Date)
-            when :Time
-                raise 'Invalid Time value for: %s' % f unless \
-                 data[f].is_a?(Time)
             when :DateTime
                 raise 'Invalid DateTime value for: %s' % f unless \
                  data[f].is_a?(DateTime)
@@ -2241,7 +2340,28 @@ class KBTable
         idx_struct = Struct.new(*(index_fields + [:recno]))
 
         begin
-            @db.engine.get_index(self, index_fields.join('_')).each do |rec|
+            if @db.client?
+                # If client, check to see if the copy of the index we have
+                # is up-to-date.  If it is not up-to-date, grab a new copy
+                # of the index array from the engine.
+                unless @idx_timestamps[index_fields.join('_')] == \
+                 @db.engine.get_index_timestamp(self, index_fields.join(
+                 '_'))
+                    @idx_timestamps[index_fields.join('_')] = \
+                     @db.engine.get_index_timestamp(self, index_fields.join(
+                     '_'))
+                     
+                    @idx_arrs[index_fields.join('_')] = \
+                     @db.engine.get_index(self, index_fields.join('_'))
+                end
+            else
+                # If running single-user, grab the index array from the 
+                # engine.
+                @idx_arrs[index_fields.join('_')] = \
+                 @db.engine.get_index(self, index_fields.join('_'))
+            end
+
+            @idx_arrs[index_fields.join('_')].each do |rec|
                 good_matches << rec[-1] if select_cond.call(
                  idx_struct.new(*rec))
             end
@@ -2327,14 +2447,23 @@ end
 # KBMemo
 #---------------------------------------------------------------------------
 class KBMemo
-    attr_reader :filepath, :memo
+    attr_accessor :filepath, :contents
 
     #-----------------------------------------------------------------------
     # initialize
     #-----------------------------------------------------------------------
-    def initialize(db, filepath)
+    def initialize(db, filepath, contents='')
+        @db = db
         @filepath = filepath
-        @memo = db.engine.get_memo(@filepath)
+        @contents = contents
+    end
+    
+    def read_from_file
+        @contents = @db.engine.read_memo_file(@filepath)
+    end
+    
+    def write_to_file
+        @db.engine.write_memo_file(@filepath, @contents)
     end
 end
 
@@ -2342,14 +2471,23 @@ end
 # KBBlob
 #---------------------------------------------------------------------------
 class KBBlob
-    attr_reader :filepath, :blob
+    attr_accessor :filepath, :contents
 
     #-----------------------------------------------------------------------
     # initialize
     #-----------------------------------------------------------------------
-    def initialize(db, filepath)
+    def initialize(db, filepath, contents='')
+        @db = db
         @filepath = filepath
-        @blob = db.engine.get_blob(@filepath)
+        @contents = contents
+    end
+    
+    def read_from_file
+        @contents = @db.engine.read_blob_file(@filepath)
+    end
+
+    def write_to_file
+        @db.engine.write_blob_file(@filepath, @contents)
     end
 end
 
@@ -2366,6 +2504,7 @@ class KBIndex
     # initialize
     #-----------------------------------------------------------------------
     def initialize(table, index_fields)
+        @last_update = Time.new
         @idx_arr = []
         @table = table
         @index_fields = index_fields
@@ -2382,6 +2521,13 @@ class KBIndex
         return @idx_arr
     end
 
+    #-----------------------------------------------------------------------
+    # get_timestamp
+    #-----------------------------------------------------------------------
+    def get_timestamp
+        return @last_update
+    end
+
     #-----------------------------------------------------------------------
     # rebuild
     #-----------------------------------------------------------------------
@@ -2429,8 +2575,10 @@ class KBIndex
         # Here's how we break out of the loop...
         rescue EOFError
         end
+        
+        @last_update = Time.new
     end
-
+    
     #-----------------------------------------------------------------------
     # add_index_rec
     #-----------------------------------------------------------------------
@@ -2438,6 +2586,8 @@ class KBIndex
         @idx_arr << @col_poss.zip(@col_types).collect do |col_pos, col_type|
             convert_to(col_type, rec[col_pos])
          end + [rec.first.to_i]
+         
+        @last_update = Time.new 
     end
 
     #-----------------------------------------------------------------------
@@ -2446,6 +2596,7 @@ class KBIndex
     def delete_index_rec(recno)
         i = @idx_arr.rassoc(recno.to_i)
         @idx_arr.delete_at(@idx_arr.index(i)) unless i.nil?
+        @last_update = Time.new
     end
 
     #-----------------------------------------------------------------------