KirbyBase 2.5 → 2.5.1

data/README

@@ -1,4 +1,4 @@
-= KirbyBase 2.5
+= KirbyBase 2.5.1
 
 A small, plain-text, dbms written in Ruby.  It can be used either embedded 
 or client/server.  
@@ -26,8 +26,8 @@ See the examples directory for examples of how to use KirbyBase.
 * kirbybaserubymanual.html - documentation
 * kirbybase.rb - dbms library
 * kbserver.rb - multi-threaded database server script.
+* test directory - unit tests
 * examples directory - many example scripts demonstrating features.
-* doc directory - RDoc generated documentation in html format.
 * images directory - images used in manual.
 
 

data/bin/kbserver.rb

@@ -2,8 +2,6 @@
 
 require 'kirbybase'
 require 'drb'
-require 'benchmark'
-include Benchmark
 
 host = ''
 port = 44444

data/changes.txt

@@ -1,3 +1,21 @@
+2005-12-28:: Version 2.5.1
+* Fixed a bug that had broken encrypted tables.
+* Changed KBTable#pack method so that it raises an error if trying to
+  execute when :connect_type==:client.
+* Fixed a bug where it was possible to insert records missing a required
+  field if using a hash.  Thanks to Adam Shelly for this.
+* Fixed a bug that occurred when you tried to update records using a
+  block and you tried to reference a field in the current record inside
+  the block.  Much thanks to Assaph Mehr for reporting this.
+* Fixed a bug that allowed you to have duplicate column names.  Thanks to
+  Assaph Mehr for spotting this.
+* Changed the way KBTable#set works with memo/blob fields.
+* Started creating unit tests.
+* Changed the KBTable#clear method to return number of records deleted.
+  Thanks to Assaph Mehr for this enhancement.
+* Moved #build_header_string from KBEngine class to KirbyBase class.
+* Added KirbyBase::VERSION constant.
+
 2005-12-01:: Version 2.5
 * Fixed a subtle bug in KBTable#create_indexes.
 * Added the following new methods to KBTable:  add_index, drop_index,

data/examples/aaa_try_this_first/kbtest.rb

@@ -56,7 +56,7 @@ plane_tbl.insert { |r|
     r.country = 'USA'
     r.role = 'Bomber'
     r.speed = 315
-    r.range = 1400
+    r.range = r.speed * 3
     r.began_service = Date.new(1937, 5, 1)
     r.still_flying = true
 }
@@ -92,27 +92,25 @@ plane_tbl.insert('Zero', 'Japan', 'Fighter', 377, 912,
 # 1) Update record using a Hash, Struct, or an Array.
 plane_tbl.update(:speed => 405, :range => 1210) { |r| r.name == 'P-51' }
 
-# 2) Update record using a code block, via the set command.
-plane_tbl.update {|r| r.name == 'P-51'}.set {|r|
-    r.speed = 405
-    r.range = 1210
-}
-
-# 3) Update record using a Hash, Struct, or an Array, via the set
+# 2) Update record using a Hash, Struct, or an Array, via the set
 #    command.
 plane_tbl.update {|r| r.name == 'P-51'}.set(:speed => 405, :range => 1210)
 
-# 4) Update record by treating table as if it were a Hash and the keys were
+# 3) Update record by treating table as if it were a Hash and the keys were
 #    recno's.
 plane_tbl[2] = {:speed => 405, :range => 1210}
 
+# 4) Update record using a code block, via the set command.  Notice how you
+#    have access to the current record's values within the block.
+plane_tbl.update {|r| r.name == 'P-51'}.set {|r|
+    r.speed = r.speed+7
+    r.range = r.range-2
+}
+
 #--------------------- Delete Examples -------------------------------------
 # Delete 'FW-190' record.
 plane_tbl.delete { |r| r.name == 'FW-190' }
 
-# Remove deleted records from the table.
-plane_tbl.pack
-
 #---------------------- Select Example 0 -----------------------------------
 print_divider('Select Example 0')
 # Select all records, including all fields in result set.

data/examples/memo_test/memo_test.rb

@@ -54,10 +54,21 @@ rec = plane_tbl.select { |r| r.name == 'P-51' }.first
 
 # Grab the contents of the memo field and add a line to it.
 memo = rec.descr
-memo.contents += "This last line should show up if the memo was changed."
+memo.contents += "This last line should show up if the memo was changed.\n"
 
 # Now, update the record with the changed contents of the memo field.
 plane_tbl.update {|r| r.name == 'P-51'}.set(:descr => memo)
 
 # Do another select to show that the memo field indeed changed.
 puts plane_tbl.select { |r| r.name == 'P-51' }.first.descr.contents
+
+
+puts "\n\nNow we will change every record's memo field:\n\n"
+
+plane_tbl.update_all { |r|
+    r.descr.contents += "I have added a line to the %s memo.\n\n" % r.name
+}
+
+# Do another select to show that the memo field for each record has
+# indeed changed.
+plane_tbl.select.each { |r| puts r.descr.contents }

data/kirbybaserubymanual.html

@@ -262,8 +262,7 @@ div.exampleblock-content {
 <h1>KirbyBase Manual (Ruby Version)</h1>
 <span id="author">Jamey Cribbs</span><br />
 <span id="email"><tt>&lt;<a href="mailto:jcribbs@twmi.rr.com">jcribbs@twmi.rr.com</a>&gt;</tt></span><br />
-<span id="revision">version 2.5,</span>
-1 December 2005
+v2.5.1 December 2005
 </div>
 <div id="preamble">
 <div class="sectionbody">
@@ -307,6 +306,16 @@ div.exampleblock-content {
 </li>
 <li>
 <p>
+<a href="#encrypt">Turning on encryption</a>
+</p>
+</li>
+<li>
+<p>
+<a href="#record-class">Specifying a custom record class</a>
+</p>
+</li>
+<li>
+<p>
 <a href="#defaults">Specifying default values</a>
 </p>
 </li>
@@ -576,12 +585,12 @@ div.exampleblock-content {
 </li>
 <li>
 <p>
-<a href="#client-server-diagram">Client/Server memory space diagram</a>
+<a href="#single-user-diagram">Single-user memory space diagram</a>
 </p>
 </li>
 <li>
 <p>
-<a href="#single-user-diagram">Single-user memory space diagram</a>
+<a href="#client-server-diagram">Client/Server memory space diagram</a>
 </p>
 </li>
 <li>
@@ -605,7 +614,7 @@ Some of its features include:</p>
 <li>
 <p>
 Since KirbyBase is written in Ruby, it runs anywhere that Ruby runs. It
-is easy to distribute, since the entire dbms is in one (approx. 100k) code
+is easy to distribute, since the entire DBMS is in one (approx. 100k) code
 file.
 </p>
 </li>
@@ -653,7 +662,7 @@ language like SQL, you can express your query using Ruby code blocks.
 <li>
 <p>
 All inserted records have an auto-incrementing primary key that is
-guaranteed to uniquely identify the record throughout it's lifetime.
+guaranteed to uniquely identify the record throughout its lifetime.
 </p>
 </li>
 <li>
@@ -724,7 +733,7 @@ like this:</p>
 <pre><tt>db = KirbyBase.new(:client, 'localhost', 44444)</tt></pre>
 </div></div>
 <p>Of course, you would substitute your server's ip address and port number.</p>
-<p>To specify a different location other than the current directory for the
+<p>To specify a different location (other than the current directory) for the
 database files, you need to pass the location as an argument, like so:</p>
 <div class="listingblock">
 <div class="content">
@@ -737,13 +746,28 @@ a different extension, pass this as an argument, like so:</p>
 <div class="content">
 <pre><tt>db = KirbyBase.new(:local, nil, nil, './', '.dat')</tt></pre>
 </div></div>
+<p>To specify a different location other than the current directory for any
+memo/blob files, you need to pass the location as an argument, like so:</p>
+<div class="listingblock">
+<div class="content">
+<pre><tt>db = KirbyBase.new(:local, nil, './', '.tbl', './memos')</tt></pre>
+</div></div>
+<p>If you don't want KirbyBase to spend time initially creating all of the
+indexes for the tables in the database, you can pass false as the
+delay_index_creation argument:</p>
+<div class="listingblock">
+<div class="content">
+<pre><tt>db = KirbyBase.new(:local, nil, './', '.tbl', './', true)</tt></pre>
+</div></div>
+<p>KirbyBase will skip initial index creation and will create a table's
+indexes when the table is first referenced.</p>
 <p>You can also specify the arguments via a code block.  So, if you don't want
 to have to specify a bunch of arguments just to get to the one you want,
 put it in a code block attached to the method call.  You could re-code the
 previous example like so:</p>
 <div class="listingblock">
 <div class="content">
-<pre><tt>db = KirbyBase.new { |d| d.ext = '.dat' }</tt></pre>
+<pre><tt>db = KirbyBase.new { |d| d.delay_index_creation = true }</tt></pre>
 </div></div>
 </div>
 <h2><a id="creating-a-new-table"></a>Creating a new table</h2>
@@ -787,6 +811,7 @@ select, update, and delete queries, but you can't modify this field.</td>
 </tr></table>
 </div>
 </div></div>
+<h3><a id="encrypt"></a>Turning on encryption</h3>
 <p>You can also specify whether the table should be encrypted. This will save
 the table to disk encrypted (more like obfuscated) using a Vignere Cipher.
 This is similar to rot13, but it uses a key to determine character
@@ -799,6 +824,7 @@ encryption by using a code block attached to #create_table:</p>
     t.encrypt = true
 end</tt></pre>
 </div></div>
+<h3><a id="record-class"></a>Specifying a custom record class</h3>
 <p>You can also specify that you want records of the table to be returned to
 you as instances of a class. To do this, simply define a class before you
 call #create_table. This class needs to have an accessor for each fieldname
@@ -869,9 +895,11 @@ or specify nil as the value, KirbyBase stores this as an empty string
 (i.e. "") in the table's physical file, and returns it as a nil value when
 you do a #select.</p>
 <p>However, you can tell KirbyBase that you want a column to have a default
-value.  This will be applied whenever either no value or a nil value is
-specified for the field when <strong>inserting</strong> a record only.  When updating an
-existing record, defaults will not be applied.</p>
+value.  Only KBTable#insert is affected by default values.  Default values
+do not apply to updating a record.  So, for inserts, there are two cases
+where a default value, if one is specified, will be applied:  (1) if nil
+is specified for a field's value, and (2) if no value is specified for a
+field.</p>
 <p>For example, to specify that the category column has a default value, you
 would code:</p>
 <div class="listingblock">
@@ -884,7 +912,7 @@ would code:</p>
 cannot just simply say :String for the second half of the field definition.
 Instead, we have to pass a hash, with a :DataType item set to :String.
 Next, because we are specifying a default value, we have to include a hash
-item called :Default with it's value set to whatever we want the default to
+item called :Default with its value set to whatever we want the default to
 be.  The default value must be of a type that is valid for the column.</p>
 <h4><a id="requireds"></a>Required Fields</h4>
 <p>Normally, when you insert or update a record, if you don't specify a value
@@ -907,7 +935,7 @@ code:</p>
 cannot just simply say :String for the second half of the field definition.
 Instead, we have to pass a hash, with a :DataType item set to :String.
 Next, because we are specifying that a column is required, we have to
-include a hash item called :Required with it's value set to true.</p>
+include a hash item called :Required with its value set to true.</p>
 <h4><a id="creating-indexes"></a>Indexes</h4>
 <p>Indexes are in-memory arrays that have an entry that corresponds to each
 table record, but just holds the field values specified when the index was
@@ -931,7 +959,7 @@ For example, to create an index on firstname and lastname for a table called
 cannot just simply say :String for the second half of the field definition.
 Instead, we have to pass a hash, with a :DataType item set to :String.
 Next, because we are creating an index, we have to include a hash item
-called :Index with it's value set from 1 to 5.  For compound indexes, like
+called :Index with its value set from 1 to 5.  For compound indexes, like
 the one in the above example, we need to make sure that all fields in the
 index have the same number.  To have another index for a table, just make
 sure you increment the index number.  So, for example, if we wanted to have
@@ -961,9 +989,10 @@ wait the first time a table is referenced.  A user is more used to waiting
 for an application to properly initialize, so this initial delay, I thought,
 would feel more natural to the user, rather than a wait time in the middle
 of the application.</p>
-<p>Please let me know if this poses a problem for any of your applications.  I
-have some ideas that I could implement that would allow the developer to
-specify when indexes are created.</p>
+<p>If you find that this initial delay while indexes are created is
+un-acceptable, you can pass delay_index_creation=true to KirbyBase.new.
+This will bypass the initial index creation for all tables.  Indexes for an
+individual table will be created when the table is first referenced.</p>
 <p>This is also an excellent reason to use the client/server capabilities of
 KirbyBase.  In client/server mode, the database initialization processing is
 all done on the server, so, once this is done, any users starting their
@@ -1030,7 +1059,7 @@ You have a master table called :orders that holds one record for each
 customer order that is placed.  It has fields like: :order_id, :cust_id,
 :order_date, etc.</p>
 <p>Now, you also need a table that is going to have a record for each detail
-item type ordered.  Let's call it :order_items and some of it's fields would
+item type ordered.  Let's call it :order_items and some of its fields would
  be: :item_no, :qty, :order_id.</p>
 <p>Notice that the detail table has a field called :order_id.  This will hold
 the order_id linking it back to the :orders.order_id table.  If a customer
@@ -1062,7 +1091,7 @@ in the array above), equals the value of the :orders.order_id field (the
 first item of the array above).</p>
 <p>If you opened up the :orders table file in a text editor, you would notice
 that, for each record, the :items field is blank.  No data is ever stored in
- this field, since it's value is always computed at runtime.</p>
+ this field, since its value is always computed at runtime.</p>
 <h4><a id="creating-calculated-fields"></a>Calculated Fields</h4>
 <p>When you specify that a field is a Calculated field, you are telling
 KirbyBase to compute the value of the field at runtime, based on the code
@@ -1085,7 +1114,7 @@ Here's how you would define this table:</p>
 :qty field by the :price field.</p>
 <p>If you opened up the :purchases file in a text editor, you would notice
 that, for each record, the :total_cost field is blank.  No data is ever
-stored in this field, since it's value is always computed at runtime.</p>
+stored in this field, since its value is always computed at runtime.</p>
 </div>
 <h2><a id="obtaining-a-reference-to-an-existing-table"></a>Obtaining a reference to an existing table</h2>
 <div class="sectionbody">
@@ -1141,7 +1170,8 @@ plane_tbl.insert(rec)</tt></pre>
     r.speed = 315
     r.range = 1400
     r.began_service = Date.new(1937, 5, 1)
-    r.still_flying = true</tt></pre>
+    r.still_flying = true
+end</tt></pre>
 </div></div>
 <h3>Insert a record using an instance of the table's custom record class:</h3>
 <div class="listingblock">
@@ -1254,7 +1284,7 @@ indexes of a table.  So, you would code your select query like this:</p>
 <pre><tt>plane_tbl.select_by_speed_index { |r| r.speed &gt; 400 }</tt></pre>
 </div></div>
 <p>Notice that you simply insert the name of the field as part of the method
-name.  It's as simple as that.</p>
+name.  Its as simple as that.</p>
 <p>For compound indexes, you just need to specify the
 indexed field names in the select method in the same order as they are in
 the table. So, let's say you have indexed the :plane table on :country and
@@ -1310,6 +1340,7 @@ employee_tbl = db.create_table(:employee, :employee_id, {:DataType=&gt;:String,
     r.manager.firstname == 'John' and r.manager.lastname == 'Doe'
 end</tt></pre>
 </div></div>
+<p>Notice how the manager attribute is itself a Struct with its own members.</p>
 <p>To print out all departments including the manager's full name:</p>
 <div class="listingblock">
 <div class="content">
@@ -1330,7 +1361,7 @@ definitions from the earlier Link_many discussion:</p>
 order_items_tbl = db.create_table(:order_items, :item_no, :Integer,
  :qty, :Integer, :order_id, :Integer)</tt></pre>
 </div></div>
-<p>To print an order and all of it's associated detail items:</p>
+<p>To print an order and all of its associated detail items:</p>
 <div class="listingblock">
 <div class="content">
 <pre><tt>result = order_tbl.select { |r| r.order_id == 501 }.first
@@ -1349,7 +1380,7 @@ is an array of Struct objects (or instances of the class specified in
 record_class), each one representing a record that satisfied the selection
 criteria.</p>
 <p>Since each item in KBResultSet is a Struct object, you can easily reference
-it's members using field names. So, to print the name and speed of each
+its members using field names. So, to print the name and speed of each
 German plane in the table you would code:</p>
 <div class="listingblock">
 <div class="content">
@@ -1379,7 +1410,7 @@ the result set, and sort the result set by country (ascending) then speed
 </div></div>
 <p>You can also explicitly specify that a field be sorted in ascending order by
 putting a plus sign in front of it. This is not necessary, since ascending
-is the default, but it's there if you prefer to use it.</p>
+is the default, but its there if you prefer to use it.</p>
 <h3><a id="to-report"></a>Producing a report from a result set</h3>
 <p>Additionally, you can also transform the KBResultSet into a nicely formatted
 report, suitable for printing, by calling KBResultSet#to_report. To print
@@ -1486,7 +1517,7 @@ block that indicates which records are to be updated. Additionally, you must
 specify the fields to be updated and the new values for those fields.</p>
 <p>You can update records using a Hash, Struct, an Array, or an instance of a
 class you defined. For example, to change the P-51's speed to 405mph and
-it's range to 1210 miles, you could code:</p>
+its range to 1210 miles, you could code:</p>
 <div class="listingblock">
 <div class="content">
 <pre><tt>plane_tbl.update(:speed=&gt;405, :range=&gt;1210) { |r| r.name == 'P-51' }</tt></pre>
@@ -1769,7 +1800,7 @@ and the keys as recno's. You can update it using a Hash, Array, or Struct.</p>
 <div class="content">
 <pre><tt>plane_tbl[5]</tt></pre>
 </div></div>
-<p>You can quickly select an individual record, by passing it's recno to a
+<p>You can quickly select an individual record, by passing its recno to a
 table as if it were a hash.</p>
 <p>Returns a single record either in the form of a Struct or an instance of
 the table's custom record class, if specified.</p>
@@ -2139,7 +2170,7 @@ incremented. You can use this field in a maintenance script so that the
 table is packed whenever the deleted-records counter reaches, say, 5,000
 records.</p>
 <p>The third field in the header is the record_class field. If you specified a
-class when you created the table, it's name will show up here and records
+class when you created the table, its name will show up here and records
 returned from a #select will be instances of this class. The default is
 "Struct".</p>
 <p>The fourth field in the header is the :recno field. This field is
@@ -2157,7 +2188,7 @@ characters delimit records.</p>
 <div class="sectionbody">
 <p>There is a server script included in the distribution called kbserver.rb.
 This script uses DRb to turn KirbyBase into a client/server, multi-user
-dbms. This dbms server handles table locking for you so you don't have to
+DBMS. This DBMS server handles table locking for you so you don't have to
 worry about it.</p>
 </div>
 <h2><a id="tips-on-improving-performance"></a>Tips on improving performance</h2>
@@ -2182,7 +2213,7 @@ result in the same result set being returned:</p>
 </div></div>
 <h3>Create indexes on large tables</h3>
 <p>The larger a table becomes, the more sense it makes to create an index on
-one or more of it's fields.  Even though you take a hit when KirbyBase first
+one or more of its fields.  Even though you take a hit when KirbyBase first
  initializes because it has to create the index arrays, you make up for it
 after that in greatly improved query speeds.  I have noticed speed-ups of
 as much as 10x on large tables.</p>
@@ -2199,22 +2230,22 @@ This is even faster than selecting on a regularly indexed field, because the
  :recno index that KirbyBase creates for each table is actually a Hash, not
 an Array like all of the regular indexes.  So selects are even faster.</p>
 </div>
-<h2><a id="client-server-diagram"></a>Client/Server memory space diagram</h2>
+<h2><a id="single-user-diagram"></a>Single-user memory space diagram</h2>
 <div class="sectionbody">
 <div class="imageblock">
 <div class="content">
-<img src="images/client_server.png" alt="images/client_server.png"/>
+<img src="images/single_user.png" alt="images/single_user.png"/>
 </div>
-<div class="image-title">Figure: Client/Server (separate memory spaces) mode.</div>
+<div class="image-title">Figure: Single-user (embedded) mode.</div>
 </div>
 </div>
-<h2><a id="single-user-diagram"></a>Single-user memory space diagram</h2>
+<h2><a id="client-server-diagram"></a>Client/Server memory space diagram</h2>
 <div class="sectionbody">
 <div class="imageblock">
 <div class="content">
-<img src="images/single_user.png" alt="images/single_user.png"/>
+<img src="images/client_server.png" alt="images/client_server.png"/>
 </div>
-<div class="image-title">Figure: Single-user (embedded) mode.</div>
+<div class="image-title">Figure: Client/Server (separate memory spaces) mode.</div>
 </div>
 </div>
 <h2><a id="license"></a>License</h2>
@@ -2235,8 +2266,7 @@ an Array like all of the regular indexes.  So selects are even faster.</p>
 </div>
 <div id="footer">
 <div id="footer-text">
-Version 2.5<br />
-Last updated 01-Dec-2005 13:28:12 Eastern Daylight Time
+Last updated 28-Dec-2005 13:27:25 Eastern Daylight Time
 </div>
 </div>
 </body>

data/lib/kirbybase.rb

@@ -128,11 +128,215 @@ require 'yaml'
 #   speeds up database initialization at the cost of slower table
 #   initialization later.
 #
+# 2005-12-28:: Version 2.5.1
+# * Fixed a bug that had broken encrypted tables.
+# * Changed KBTable#pack method so that it raises an error if trying to
+#   execute when :connect_type==:client.
+# * Fixed a bug where it was possible to insert records missing a required
+#   field if using a hash.  Thanks to Adam Shelly for this.
+# * Fixed a bug that occurred when you tried to update records using a
+#   block and you tried to reference a field in the current record inside
+#   the block.  Much thanks to Assaph Mehr for reporting this.
+# * Fixed a bug that allowed you to have duplicate column names.  Thanks to
+#   Assaph Mehr for spotting this.
+# * Changed the way KBTable#set works with memo/blob fields.
+# * Started creating unit tests.
+# * Changed the KBTable#clear method to return number of records deleted.
+#   Thanks to Assaph Mehr for this enhancement.
+# * Moved #build_header_string from KBEngine class to KirbyBase class.
+# * Added KirbyBase::VERSION constant.
+#
+#
+#---------------------------------------------------------------------------
+# KBTypeConversionsMixin
+#---------------------------------------------------------------------------
+module KBTypeConversionsMixin
+    # Regular expression used to determine if field needs to be un-encoded.
+    UNENCODE_RE = /&(?:amp|linefeed|carriage_return|substitute|pipe);/
+
+    # Regular expression used to determine if field needs to be encoded.
+    ENCODE_RE = /&|\n|\r|\032|\|/
+
+    #-----------------------------------------------------------------------
+    # convert_to_native_type
+    #-----------------------------------------------------------------------
+    #++
+    # Return value converted from storage string to native field type.
+    #
+    def convert_to_native_type(data_type, s)
+        return nil if s.empty? or s.nil?
+
+        case data_type
+        when :String
+            if s =~ UNENCODE_RE
+                return s.gsub('&linefeed;', "\n").gsub('&carriage_return;',
+                 "\r").gsub('&substitute;', "\032").gsub('&pipe;', "|"
+                 ).gsub('&', "&")
+            else
+                return s
+            end
+        when :Integer
+            return s.to_i
+        when :Float
+            return s.to_f
+        when :Boolean
+            if ['false', 'False', nil, false].include?(s)
+                return false
+            else
+                return true
+            end
+        when :Time
+            return Time.parse(s)    
+        when :Date
+            return Date.parse(s)
+        when :DateTime
+            return DateTime.parse(s)
+        when :YAML
+            # This code is here in case the YAML field is the last
+            # field in the record.  Because YAML normally defines a
+            # nil value as "--- ", but KirbyBase strips trailing
+            # spaces off the end of the record, so if this is the
+            # last field in the record, KirbyBase will strip the
+            # trailing space off and make it "---".  When KirbyBase
+            # attempts to convert this value back using to_yaml,
+            # you get an exception.
+            if s == "---"
+                return nil
+            elsif s =~ UNENCODE_RE
+                y = s.gsub('&linefeed;', "\n").gsub('&carriage_return;',
+                 "\r").gsub('&substitute;', "\032").gsub('&pipe;', "|"
+                 ).gsub('&', "&")
+                return YAML.load(y)
+            else
+                return YAML.load(s)
+            end
+        when :Memo
+            memo = KBMemo.new(@tbl.db, s)
+            memo.read_from_file
+            return memo
+        when :Blob
+            blob = KBBlob.new(@tbl.db, s)
+            blob.read_from_file
+            return blob
+        else
+            raise "Invalid field type: %s" % data_type
+        end
+    end
+
+    #-----------------------------------------------------------------------
+    # convert_to_encoded_string
+    #-----------------------------------------------------------------------
+    #++
+    # Return value converted to encoded String object suitable for storage.
+    #
+    def convert_to_encoded_string(data_type, value)
+        case data_type
+        when :YAML
+            y = value.to_yaml
+            if y =~ ENCODE_RE
+                return y.gsub("&", '&').gsub("\n", '&linefeed;').gsub(
+                 "\r", '&carriage_return;').gsub("\032", '&substitute;'
+                 ).gsub("|", '&pipe;')
+            else
+                return y
+            end
+        when :String
+            if value =~ ENCODE_RE
+                return value.gsub("&", '&').gsub("\n", '&linefeed;'
+                 ).gsub("\r", '&carriage_return;').gsub("\032",
+                 '&substitute;').gsub("|", '&pipe;')
+            else
+                return value
+            end  
+        when :Memo
+            return value.filepath
+        when :Blob
+            return value.filepath
+        else
+            return value.to_s
+        end
+    end
+end
+
+
+#---------------------------------------------------------------------------
+# KBEncryptionMixin
+#---------------------------------------------------------------------------
+module KBEncryptionMixin
+    EN_STR = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
+     '0123456789.+-,$:|&;_ '
+    EN_STR_LEN = EN_STR.length
+    EN_KEY1 = ")2VER8GE\"87-E\n"           #*** DO NOT CHANGE ***
+    EN_KEY = EN_KEY1.unpack("u")[0]
+    EN_KEY_LEN = EN_KEY.length
+
+
+    #-----------------------------------------------------------------------
+    # encrypt_str
+    #-----------------------------------------------------------------------
+    #++
+    # Returns an encrypted string, using the Vignere Cipher.
+    #
+    def encrypt_str(s)
+        new_str = ''
+        i_key = -1
+        s.each_byte do |c|
+            if i_key < EN_KEY_LEN - 1
+                i_key += 1
+            else
+                i_key = 0
+            end
+
+            if EN_STR.index(c.chr).nil?
+                new_str << c.chr
+                next
+            end
+
+            i_from_str = EN_STR.index(EN_KEY[i_key]) + EN_STR.index(c.chr)
+            i_from_str = i_from_str - EN_STR_LEN if i_from_str >= EN_STR_LEN
+            new_str << EN_STR[i_from_str]
+        end
+        return new_str
+    end
+
+    #-----------------------------------------------------------------------
+    # unencrypt_str
+    #-----------------------------------------------------------------------
+    #++
+    # Returns an unencrypted string, using the Vignere Cipher.
+    #
+    def unencrypt_str(s)
+        new_str = ''
+        i_key = -1
+        s.each_byte do |c|
+            if i_key < EN_KEY_LEN - 1
+                i_key += 1
+            else
+                i_key = 0
+            end
+
+            if EN_STR.index(c.chr).nil?
+                new_str << c.chr
+                next
+            end
+
+            i_from_str = EN_STR.index(c.chr) - EN_STR.index(EN_KEY[i_key])
+            i_from_str = i_from_str + EN_STR_LEN if i_from_str < 0
+            new_str << EN_STR[i_from_str]
+        end
+        return new_str
+    end
+end
+
+
 #---------------------------------------------------------------------------
 # KirbyBase
 #---------------------------------------------------------------------------
 class KirbyBase
     include DRb::DRbUndumped
+    include KBTypeConversionsMixin
+
+    VERSION = "2.5.1"
 
     attr_reader :engine
 
@@ -155,7 +359,9 @@ class KirbyBase
     # *ext*:: String specifying extension of table files.
     # *memo_blob_path*:: String specifying path to location of memo/blob
     #                    files.
-    #
+    # *delay_index_creation*:: Boolean specifying whether to delay index
+    #                          creation for each table until that table is
+    #                          requested by user.
     def initialize(connect_type=:local, host=nil, port=nil, path='./',
      ext='.tbl', memo_blob_path='./', delay_index_creation=false)
         @connect_type = connect_type
@@ -210,29 +416,12 @@ class KirbyBase
         # happens when the table instance is first created, I go ahead and
         # create table instances right off the bat.
         #
-        # Also, I use to only execute the code below if this was either a
-        # single-user instance of KirbyBase or if client-server, I would
-        # only let the client-side KirbyBase instance create the table
-        # instances, since there was no need for the server-side KirbyBase
-        # instance to create table instances.  But, since I want indexes
-        # created at db initialization and the server's db instance might
-        # be initialized long before any client's db is initialized, I now
-        # let the server create table instances also.  This is strictly to
-        # get the indexes created, there is no other use for the table
-        # instances on the server side as they will never be used.
+        # Also, I let the server create table instances also.  This is
+        # strictly to get the indexes created, there is no other use for
+        # the table instances on the server side as they will never be used.
         # Everything should and does go through the table instances created
-        # on the client-side.
-        #
-        # Ok, I added back in a conditional flag that allows me to turn off
-        # index initialization if this is a server.  The reason I added this
-        # back in was that I was running into a problem when running a
-        # KirbyBase server as a win32 service.  When I tried to start the
-        # service, it kept bombing out saying that the application had not
-        # responded in a timely manner.  It appears to be because it was
-        # taking a few seconds to build the indexes when it initialized.
-        # When I deleted the index from the table, the service would start
-        # just fine.  I need to find out if I can set a timeout parameter
-        # when starting the win32 service.
+        # on the client-side.  You can turn this off by specifying true for
+        # the delay_index_creation argument.
         if server? and @delay_index_creation
         else    
             @engine.tables.each do |tbl|
@@ -336,12 +525,133 @@ class KirbyBase
         raise "No table name specified!" if t.name.nil?
         raise "No table field definitions specified!" if t.field_defs.nil?
 
-        @engine.new_table(t.name, t.field_defs, t.encrypt,
+        # Can't create a table that already exists!
+        raise "Table already exists!" if table_exists?(t.name)
+
+        raise 'Must have a field type for each field name' \
+         unless t.field_defs.size.remainder(2) == 0
+
+        # Check to make sure there are no duplicate field names.
+        temp_field_names = []
+        (0...t.field_defs.size).step(2) do |x|
+            temp_field_names << t.field_defs[x]
+        end
+        raise 'Duplicate field names are not allowed!' unless \
+         temp_field_names == temp_field_names.uniq
+            
+        temp_field_defs = []
+        (0...t.field_defs.size).step(2) do |x|
+            temp_field_defs << build_header_field_string(t.field_defs[x],
+             t.field_defs[x+1])
+        end
+
+        @engine.new_table(t.name, temp_field_defs, t.encrypt,
          t.record_class.to_s)
 
         return get_table(t.name)
     end
 
+    #-----------------------------------------------------------------------
+    # build_header_field_string
+    #-----------------------------------------------------------------------
+    def build_header_field_string(field_name_def, field_type_def)
+        # Put field name at start of string definition.
+        temp_field_def = field_name_def.to_s + ':'
+
+        # If field type is a hash, that means that it is not just a
+        # simple field.  Either is is a key field, it is being used in an
+        # index, it is a default value, it is a required field, it is a
+        # Lookup field, it is a Link_many field, or it is a Calculated
+        # field.  This next bit of code is to piece together a proper
+        # string so that it can be written out to the header rec.
+        if field_type_def.is_a?(Hash)
+            raise 'Missing :DataType key in field_type hash!' unless \
+             field_type_def.has_key?(:DataType)
+
+            temp_type = field_type_def[:DataType]
+
+            raise 'Invalid field type: %s' % temp_type unless \
+             KBTable.valid_field_type?(temp_type)
+
+            temp_field_def += field_type_def[:DataType].to_s
+
+            # Check if this field is a key for the table.
+            if field_type_def.has_key?(:Key)
+                temp_field_def += ':Key->true'
+            end
+            
+            # Check for Index definition.
+            if field_type_def.has_key?(:Index)
+                raise 'Invalid field type for index: %s' % temp_type \
+                 unless KBTable.valid_index_type?(temp_type)    
+
+                temp_field_def += ':Index->' + field_type_def[:Index].to_s
+            end
+                 
+            # Check for Default value definition.
+            if field_type_def.has_key?(:Default)
+                raise 'Cannot set default value for this type: ' + \
+                 '%s' % temp_type unless KBTable.valid_default_type?(
+                 temp_type)
+                
+                unless field_type_def[:Default].nil?
+                    raise 'Invalid default value ' + \
+                     '%s for column %s' % [field_type_def[:Default],
+                     field_name_def] unless KBTable.valid_data_type?(
+                     temp_type, field_type_def[:Default])
+
+                    temp_field_def += ':Default->' + \
+                     convert_to_encoded_string(temp_type,
+                     field_type_def[:Default])
+                end    
+            end
+            
+            # Check for Required definition.
+            if field_type_def.has_key?(:Required)
+                raise 'Required must be true or false!' unless \
+                 [true, false].include?(field_type_def[:Required])
+                
+                temp_field_def += \
+                 ':Required->%s' % field_type_def[:Required]
+            end
+            
+            # Check for Lookup field, Link_many field, Calculated field
+            # definition.
+            if field_type_def.has_key?(:Lookup)
+                if field_type_def[:Lookup].is_a?(Array)
+                    temp_field_def += \
+                     ':Lookup->%s.%s' % field_type_def[:Lookup]
+                else
+                    tbl = get_table(field_type_def[:Lookup])
+                    temp_field_def += \
+                     ':Lookup->%s.%s' % [field_type_def[:Lookup],
+                     tbl.lookup_key]
+                end
+            elsif field_type_def.has_key?(:Link_many)
+                raise 'Field type for Link_many field must be :ResultSet' \
+                 unless temp_type == :ResultSet
+                temp_field_def += \
+                 ':Link_many->%s=%s.%s' % field_type_def[:Link_many]
+            elsif field_type_def.has_key?(:Calculated)
+                temp_field_def += \
+                 ':Calculated->%s' % field_type_def[:Calculated]
+            end
+        else
+            if KBTable.valid_field_type?(field_type_def)
+                temp_field_def += field_type_def.to_s
+            elsif table_exists?(field_type_def)
+                tbl = get_table(field_type_def)
+                temp_field_def += \
+                 '%s:Lookup->%s.%s' % [tbl.field_types[
+                 tbl.field_names.index(tbl.lookup_key)], field_type_def,
+                 tbl.lookup_key]
+            else
+                raise 'Invalid field type: %s' % field_type_def
+            end
+        end
+        return temp_field_def
+    end
+
     #-----------------------------------------------------------------------
     # rename_table
     #-----------------------------------------------------------------------
@@ -352,12 +662,14 @@ class KirbyBase
     # *new_tablename*:: Symbol of new table name.
     #
     def rename_table(old_tablename, new_tablename)
+        raise "Cannot rename table running in client mode!" if client?
         raise "Table does not exist!" unless table_exists?(old_tablename)
         raise(ArgumentError, 'Existing table name must be a symbol!') \
          unless old_tablename.is_a?(Symbol)
         raise(ArgumentError, 'New table name must be a symbol!') unless \
          new_tablename.is_a?(Symbol)
         raise "Table already exists!" if table_exists?(new_tablename)
+
         @table_hash.delete(old_tablename)
         @engine.rename_table(old_tablename, new_tablename)
         get_table(new_tablename)
@@ -376,6 +688,7 @@ class KirbyBase
          tablename.is_a?(Symbol)
         raise "Table does not exist!" unless table_exists?(tablename)
         @table_hash.delete(tablename)
+
         return @engine.delete_table(tablename)
     end
 
@@ -397,90 +710,13 @@ class KirbyBase
 end
 
 
-#---------------------------------------------------------------------------
-# KBTypeConversionsMixin
-#---------------------------------------------------------------------------
-module KBTypeConversionsMixin
-    UNENCODE_RE = /&(?:amp|linefeed|carriage_return|substitute|pipe);/
-
-    #-----------------------------------------------------------------------
-    # convert_to
-    #-----------------------------------------------------------------------
-    def convert_to(data_type, s)
-        return nil if s.empty? or s.nil?
-
-        case data_type
-        when :String
-            if s =~ UNENCODE_RE
-                return s.gsub('&linefeed;', "\n").gsub('&carriage_return;',
-                 "\r").gsub('&substitute;', "\032").gsub('&pipe;', "|"
-                 ).gsub('&amp;', "&")
-            else
-                return s
-            end
-        when :Integer
-            return s.to_i
-        when :Float
-            return s.to_f
-        when :Boolean
-            if ['false', 'False', nil, false].include?(s)
-                return false
-            else
-                return true
-            end
-        when :Time
-            return Time.parse(s)    
-        when :Date
-            return Date.parse(s)
-        when :DateTime
-            return DateTime.parse(s)
-        when :YAML
-            # This code is here in case the YAML field is the last
-            # field in the record.  Because YAML normall defines a
-            # nil value as "--- ", but KirbyBase strips trailing
-            # spaces off the end of the record, so if this is the
-            # last field in the record, KirbyBase will strip the
-            # trailing space off and make it "---".  When KirbyBase
-            # attempts to convert this value back using to_yaml,
-            # you get an exception.
-            if s == "---"
-                return nil
-            elsif s =~ UNENCODE_RE
-                y = s.gsub('&linefeed;', "\n").gsub('&carriage_return;',
-                 "\r").gsub('&substitute;', "\032").gsub('&pipe;', "|"
-                 ).gsub('&amp;', "&")
-                return YAML.load(y)
-            else
-                return YAML.load(s)
-            end
-        when :Memo
-            memo = KBMemo.new(@tbl.db, s)
-            memo.read_from_file
-            return memo
-        when :Blob
-            blob = KBBlob.new(@tbl.db, s)
-            blob.read_from_file
-            return blob
-        else
-            raise "Invalid field type: %s" % data_type
-        end
-    end
-end
-
-
 #---------------------------------------------------------------------------
 # KBEngine
 #---------------------------------------------------------------------------
 class KBEngine
     include DRb::DRbUndumped
     include KBTypeConversionsMixin
-
-    EN_STR = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
-     '0123456789.+-,$:|&;_ '
-    EN_STR_LEN = EN_STR.length
-    EN_KEY1 = ")2VER8GE\"87-E\n"           #*** DO NOT CHANGE ***
-    EN_KEY = EN_KEY1.unpack("u")[0]
-    EN_KEY_LEN = EN_KEY.length
+    include KBEncryptionMixin
 
     # Make constructor private.
     private_class_method :new
@@ -546,6 +782,13 @@ class KBEngine
         @recno_indexes.include?(table.name)
     end
 
+    #-----------------------------------------------------------------------
+    # get_recno_index
+    #-----------------------------------------------------------------------
+    def get_recno_index(table)
+        return @recno_indexes[table.name].get_idx
+    end
+
     #-----------------------------------------------------------------------
     # init_index
     #-----------------------------------------------------------------------
@@ -633,13 +876,6 @@ class KBEngine
         return @indexes["#{table.name}_#{index_name}".to_sym].get_timestamp
     end
 
-    #-----------------------------------------------------------------------
-    # get_recno_index
-    #-----------------------------------------------------------------------
-    def get_recno_index(table)
-        return @recno_indexes[table.name].get_idx
-    end
-
     #-----------------------------------------------------------------------
     # table_exists?
     #-----------------------------------------------------------------------
@@ -648,107 +884,18 @@ class KBEngine
     end
 
     #-----------------------------------------------------------------------
-    # tables
-    #-----------------------------------------------------------------------
-    def tables
-        list = []
-        Dir.foreach(@db.path) { |filename|
-            list << File.basename(filename, '.*').to_sym if \
-             File.extname(filename) == @db.ext
-        }
-        return list
-    end
-
-    #-----------------------------------------------------------------------
-    # build_header_field_string
-    #-----------------------------------------------------------------------
-    def build_header_field_string(field_name_def, field_type_def)
-        # Put field name at start of string definition.
-        temp_field_def = field_name_def.to_s + ':'
-
-        # if field type is a hash, that means that it is not just a
-        # simple field.  Either is is being used in an index, it is a
-        # Lookup field, it is a Link_many field, or it is a Calculated
-        # field.  This next bit of code is to piece together a proper
-        # string so that it can be written out to the header rec.
-        if field_type_def.is_a?(Hash)
-            raise 'Missing :DataType key in field type hash!' unless \
-             field_type_def.has_key?(:DataType)
-
-            temp_type = field_type_def[:DataType]
-
-            raise 'Invalid field type: %s' % temp_type unless \
-             KBTable.valid_field_type?(temp_type)
-
-            temp_field_def += field_type_def[:DataType].to_s
-
-            if field_type_def.has_key?(:Key)
-                temp_field_def += ':Key->true'
-            end
-            
-            if field_type_def.has_key?(:Index)
-                raise 'Invalid field type for index: %s' % temp_type \
-                 unless KBTable.valid_index_type?(temp_type)    
-
-                temp_field_def += ':Index->' + field_type_def[:Index].to_s
-            end
-                 
-            if field_type_def.has_key?(:Default)
-                raise 'Cannot set default value for this type: ' + \
-                 '%s' % temp_type unless KBTable.valid_default_type?(
-                 temp_type)
-                
-                unless field_type_def[:Default].nil?
-                    temp_field_def += ':Default->' + \
-                     KBTable.convert_to_string(temp_type,
-                     field_type_def[:Default])
-                end    
-            end
-            
-            if field_type_def.has_key?(:Required)
-                raise 'Required must be true or false!' unless \
-                 [true, false].include?(field_type_def[:Required])
-                
-                temp_field_def += \
-                 ':Required->%s' % field_type_def[:Required]
-            end
-            
-            if field_type_def.has_key?(:Lookup)
-                if field_type_def[:Lookup].is_a?(Array)
-                    temp_field_def += \
-                     ':Lookup->%s.%s' % field_type_def[:Lookup]
-                else
-                    tbl = @db.get_table(field_type_def[:Lookup])
-                    temp_field_def += \
-                     ':Lookup->%s.%s' % [field_type_def[:Lookup],
-                     tbl.lookup_key]
-                end
-            elsif field_type_def.has_key?(:Link_many)
-                raise 'Field type for Link_many field must be :ResultSet' \
-                 unless temp_type == :ResultSet
-                temp_field_def += \
-                 ':Link_many->%s=%s.%s' % field_type_def[:Link_many]
-            elsif field_type_def.has_key?(:Calculated)
-                temp_field_def += \
-                 ':Calculated->%s' % field_type_def[:Calculated]
-            end
-        else
-            if KBTable.valid_field_type?(field_type_def)
-                temp_field_def += field_type_def.to_s
-            elsif @db.table_exists?(field_type_def)
-                tbl = @db.get_table(field_type_def)
-                temp_field_def += \
-                 '%s:Lookup->%s.%s' % [tbl.field_types[
-                 tbl.field_names.index(tbl.lookup_key)], field_type_def,
-                 tbl.lookup_key]
-            else
-                raise 'Invalid field type: %s' % field_type_def
-            end
-        end
-        return temp_field_def
-    end
-
-    #-----------------------------------------------------------------------
+    # tables
+    #-----------------------------------------------------------------------
+    def tables
+        list = []
+        Dir.foreach(@db.path) { |filename|
+            list << File.basename(filename, '.*').to_sym if \
+             File.extname(filename) == @db.ext
+        }
+        return list
+    end
+
+    #-----------------------------------------------------------------------
     # new_table
     #-----------------------------------------------------------------------
     #++
@@ -756,22 +903,11 @@ class KBEngine
     # called in your application, but only called by #create_table.
     #
     def new_table(name, field_defs, encrypt, record_class)
-        # Can't create a table that already exists!
-        raise "Table already exists!" if table_exists?(name)
-
-        raise 'Must have a field type for each field name' \
-         unless field_defs.size.remainder(2) == 0
-        temp_field_defs = []
-        (0...field_defs.size).step(2) do |x|
-            temp_field_defs << build_header_field_string(field_defs[x],
-             field_defs[x+1])
-        end
-
         # Header rec consists of last record no. used, delete count, and
         # all field names/types.  Here, I am inserting the 'recno' field
         # at the beginning of the fields.
         header_rec = ['000000', '000000', record_class, 'recno:Integer',
-         temp_field_defs].join('|')
+         field_defs].join('|')
 
         header_rec = 'Z' + encrypt_str(header_rec) if encrypt
 
@@ -788,9 +924,9 @@ class KBEngine
     #-----------------------------------------------------------------------
     def delete_table(tablename)
         with_write_lock(tablename) do
+            File.delete(File.join(@db.path, tablename.to_s + @db.ext))
             remove_indexes(tablename)
             remove_recno_index(tablename)
-            File.delete(File.join(@db.path, tablename.to_s + @db.ext))
             return true
         end
     end
@@ -807,8 +943,8 @@ class KBEngine
     #-----------------------------------------------------------------------
     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)
+            encrypted, header_line = get_header_record(table, fptr)
+            last_rec_no, rest_of_line = header_line.split('|', 2)
             write_header_record(table, fptr, 
              ['%06d' % 0, rest_of_line].join('|'))
             return true
@@ -820,7 +956,7 @@ class KBEngine
     #-----------------------------------------------------------------------
     def get_header_vars(table)
         with_table(table) do |fptr|
-            line = get_header_record(table, fptr)
+            encrypted, line = get_header_record(table, fptr)
 
             last_rec_no, del_ctr, record_class, *flds = line.split('|')
             field_names = flds.collect { |x| x.split(':')[0].to_sym }
@@ -838,10 +974,12 @@ class KBEngine
                             field_indexes[i] = y
                         elsif y =~ /Default/
                             field_defaults[i] = \
-                             convert_to(field_types[i], y.split('->')[1])
+                             convert_to_native_type(field_types[i],
+                              y.split('->')[1])
                         elsif y =~ /Required/
                             field_requireds[i] = \
-                             convert_to(:Boolean, y.split('->')[1])
+                             convert_to_native_type(:Boolean,
+                              y.split('->')[1])
                         else
                             field_extras[i][y.split('->')[0]] = \
                              y.split('->')[1]
@@ -849,7 +987,7 @@ class KBEngine
                     end
                 end
             end
-            return [table.encrypted?, last_rec_no.to_i, del_ctr.to_i,
+            return [encrypted, last_rec_no.to_i, del_ctr.to_i,
              record_class, field_names, field_types, field_indexes,
              field_defaults, field_requireds, field_extras]
         end
@@ -869,21 +1007,12 @@ class KBEngine
 
                 # Loop through table.
                 while true
-                    # Record current position in table.  Then read first
-                    # detail record.
+                    # Record current position in table.
                     fpos = fptr.tell
-                    line = fptr.readline
-                    line.chomp!
-                    line_length = line.length
-
-                    line = unencrypt_str(line) if encrypted
-                    line.strip!
+                    rec, line_length = line_to_rec(fptr.readline, encrypted)
 
-                    # If blank line (i.e. 'deleted'), skip it.
-                    next if line == ''
+                    next if rec.empty?
 
-                    # Split the line up into fields.
-                    rec = line.split('|', -1)
                     rec << fpos << line_length
                     recs << rec
                 end
@@ -912,18 +1041,10 @@ class KBEngine
             # 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!
-                line_length = line.length
-
-                line = unencrypt_str(line) if encrypted
-                line.strip!
+                rec, line_length = line_to_rec(fptr.readline, encrypted)
 
-                # If blank line (i.e. 'deleted'), skip it.
-                next if line == ''
+                next if rec.empty?
 
-                # Split the line up into fields.
-                rec = line.split('|', -1)
                 raise "Index Corrupt!" unless rec[0].to_i == r[1]
                 rec << r[0] << line_length
                 recs << rec
@@ -943,24 +1064,32 @@ class KBEngine
 
         with_table(table) do |fptr|
             fptr.seek(recno_idx[recno])
-            line = fptr.readline
-            line.chomp!
-            line_length = line.length
-
-            line = unencrypt_str(line) if encrypted
-            line.strip!
+            rec, line_length = line_to_rec(fptr.readline, encrypted)
 
-            return nil if line == ''
+            raise "Recno Index Corrupt for table %s!" % table.name if \
+             rec.empty?
 
-            # Split the line up into fields.
-            rec = line.split('|', -1)
+            raise "Recno Index Corrupt for table %s!" % table.name unless \
+             rec[0].to_i == recno
 
-            raise "Index Corrupt!" unless rec[0].to_i == recno
             rec << recno_idx[recno] << line_length
             return rec
         end
     end
 
+    #-----------------------------------------------------------------------
+    # line_to_rec
+    #-----------------------------------------------------------------------
+    def line_to_rec(line, encrypted)
+        line.chomp!
+        line_length = line.length
+        line = unencrypt_str(line) if encrypted
+        line.strip!
+
+        # Convert line to rec and return rec and line length.
+        return line.split('|', -1), line_length
+    end
+
     #-----------------------------------------------------------------------
     # insert_record
     #-----------------------------------------------------------------------
@@ -1130,17 +1259,13 @@ class KBEngine
     #-----------------------------------------------------------------------
     # add_column
     #-----------------------------------------------------------------------
-    def add_column(table, col_name, col_type, after)
-        temp_field_def = build_header_field_string(col_name, col_type)
-
-        if after.nil?
+    def add_column(table, field_def, after)
+        # Find the index position of where to insert the column, either at
+        # the end (-1) or after the field specified.
+        if after.nil? or table.field_names.last == after
             insert_after = -1
         else
-            if table.field_names.last == after
-                insert_after = -1
-            else
-                insert_after = table.field_names.index(after)+1
-            end
+            insert_after = table.field_names.index(after)+1
         end
 
         with_write_lock(table.name) do
@@ -1151,20 +1276,21 @@ class KBEngine
 
             if line[0..0] == 'Z'
                 header_rec = unencrypt_str(line[1..-1]).split('|')
-                if insert_after == -1
-                    header_rec.insert(insert_after, temp_field_def)
-                else
-                    header_rec.insert(insert_after+3, temp_field_def)
-                end
+            else
+                header_rec = line.split('|')
+            end
+
+            if insert_after == -1
+                header_rec.insert(insert_after, field_def)
+            else
+                # Need to account for recno ctr, delete ctr, record class.
+                header_rec.insert(insert_after+3, field_def)
+            end
+
+            if line[0..0] == 'Z'
                 new_fptr.write('Z' + encrypt_str(header_rec.join('|')) +
                  "\n")
             else
-                header_rec = line.split('|')
-                if insert_after == -1
-                    header_rec.insert(insert_after, temp_field_def)
-                else
-                    header_rec.insert(insert_after+3, temp_field_def)
-                end
                 new_fptr.write(header_rec.join('|') + "\n")
             end
 
@@ -1178,7 +1304,7 @@ class KBEngine
                         temp_line = line
                     end
 
-                    rec = temp_line.split('|')
+                    rec = temp_line.split('|', -1)
                     rec.insert(insert_after, '')
 
                     if table.encrypted?
@@ -1231,7 +1357,7 @@ class KBEngine
                         temp_line = line
                     end
 
-                    rec = temp_line.split('|')
+                    rec = temp_line.split('|', -1)
                     rec.delete_at(col_index)
 
                     if table.encrypted?
@@ -1697,10 +1823,12 @@ class KBEngine
     def get_header_record(table, fptr)
         fptr.seek(0)
 
-        if table.encrypted?
-            return unencrypt_str(fptr.readline[1..-1].chomp)
+        line = fptr.readline.chomp
+
+        if line[0..0] == 'Z'
+            return [true, unencrypt_str(line[1..-1])]
         else
-            return fptr.readline.chomp
+            return [false, line]
         end
     end
 
@@ -1708,8 +1836,8 @@ class KBEngine
     # incr_rec_no_ctr
     #-----------------------------------------------------------------------
     def incr_rec_no_ctr(table, fptr)
-        last_rec_no, rest_of_line = get_header_record(table, fptr).split(
-         '|', 2)
+        encrypted, header_line = get_header_record(table, fptr)
+        last_rec_no, rest_of_line = header_line.split('|', 2)
         last_rec_no = last_rec_no.to_i + 1
 
         write_header_record(table, fptr, ['%06d' % last_rec_no,
@@ -1723,8 +1851,8 @@ class KBEngine
     # incr_del_ctr
     #-----------------------------------------------------------------------
     def incr_del_ctr(table, fptr)
-        last_rec_no, del_ctr, rest_of_line = get_header_record(table,
-         fptr).split('|', 3)
+        encrypted, header_line = get_header_record(table, fptr)
+        last_rec_no, del_ctr, rest_of_line = header_line.split('|', 3)
         del_ctr = del_ctr.to_i + 1
 
         write_header_record(table, fptr, [last_rec_no, '%06d' % del_ctr,
@@ -1732,60 +1860,6 @@ class KBEngine
 
         return true
     end
-
-    #-----------------------------------------------------------------------
-    # encrypt_str
-    #-----------------------------------------------------------------------
-    def encrypt_str(s)
-        # Returns an encrypted string, using the Vignere Cipher.
-
-        new_str = ''
-        i_key = -1
-        s.each_byte do |c|
-            if i_key < EN_KEY_LEN - 1
-                i_key += 1
-            else
-                i_key = 0
-            end
-
-            if EN_STR.index(c.chr).nil?
-                new_str << c.chr
-                next
-            end
-
-            i_from_str = EN_STR.index(EN_KEY[i_key]) + EN_STR.index(c.chr)
-            i_from_str = i_from_str - EN_STR_LEN if i_from_str >= EN_STR_LEN
-            new_str << EN_STR[i_from_str]
-        end
-        return new_str
-    end
-
-    #-----------------------------------------------------------------------
-    # unencrypt_str
-    #-----------------------------------------------------------------------
-    def unencrypt_str(s)
-        # Returns an unencrypted string, using the Vignere Cipher.
-
-        new_str = ''
-        i_key = -1
-        s.each_byte do |c|
-            if i_key < EN_KEY_LEN - 1
-                i_key += 1
-            else
-                i_key = 0
-            end
-
-            if EN_STR.index(c.chr).nil?
-                new_str << c.chr
-                next
-            end
-
-            i_from_str = EN_STR.index(c.chr) - EN_STR.index(EN_KEY[i_key])
-            i_from_str = i_from_str + EN_STR_LEN if i_from_str < 0
-            new_str << EN_STR[i_from_str]
-        end
-        return new_str
-    end
 end
 
 
@@ -1794,6 +1868,7 @@ end
 #---------------------------------------------------------------------------
 class KBTable
     include DRb::DRbUndumped
+    include KBTypeConversionsMixin
 
     # Make constructor private.  KBTable instances should only be created
     # from KirbyBase#get_table.
@@ -1806,14 +1881,11 @@ class KBTable
     VALID_INDEX_TYPES = [:String, :Integer, :Float, :Boolean, :Date, :Time,
                          :DateTime]
 
-    # Regular expression used to determine if field needs to be
-    # encoded.
-    ENCODE_RE = /&|\n|\r|\032|\|/
-
-    attr_reader :filename, :name, :table_class, :db, :lookup_key
+    attr_reader :filename, :name, :table_class, :db, :lookup_key, \
+                           :last_rec_no, :del_ctr
 
     #-----------------------------------------------------------------------
-    # KBTable.valid_field_type
+    # KBTable.valid_field_type?
     #-----------------------------------------------------------------------
     #++
     # Return true if valid field type.
@@ -1825,64 +1897,64 @@ class KBTable
     end
 
     #-----------------------------------------------------------------------
-    # KBTable.valid_default_type
+    # KBTable.valid_data_type?
     #-----------------------------------------------------------------------
     #++
-    # Return true if valid default type.
+    # Return true if data is correct type, false otherwise.
     #
-    # *field_type*:: Symbol specifying field type.
+    # *data_type*:: Symbol specifying data type.
+    # *value*:: Value to convert to String.
     #
-    def KBTable.valid_default_type?(field_type)
-        VALID_DEFAULT_TYPES.include?(field_type)
+    def KBTable.valid_data_type?(data_type, value)
+        case data_type
+        when /:String|:Blob/
+            return false unless value.respond_to?(:to_str)
+        when :Memo
+            return false unless value.is_a?(KBMemo) 
+        when :Blob
+            return false unless value.is_a?(KBBlob) 
+        when :Boolean
+            return false unless value.is_a?(TrueClass) or value.is_a?(
+             FalseClass)
+        when :Integer
+            return false unless value.respond_to?(:to_int)
+        when :Float
+            return false unless value.respond_to?(:to_f)
+        when :Time
+            return false unless value.is_a?(Time)     
+        when :Date
+            return false unless value.is_a?(Date)
+        when :DateTime
+            return false unless value.is_a?(DateTime)
+        when :YAML
+            return false unless value.respond_to?(:to_yaml)
+        end
+    
+        return true
     end
 
     #-----------------------------------------------------------------------
-    # KBTable.valid_index_type
+    # KBTable.valid_default_type?
     #-----------------------------------------------------------------------
     #++
-    # Return true if valid index type.
+    # Return true if valid default type.
     #
     # *field_type*:: Symbol specifying field type.
     #
-    def KBTable.valid_index_type?(field_type)
-        VALID_INDEX_TYPES.include?(field_type)
+    def KBTable.valid_default_type?(field_type)
+        VALID_DEFAULT_TYPES.include?(field_type)
     end
 
     #-----------------------------------------------------------------------
-    # KBTable.convert_to_string
+    # KBTable.valid_index_type?
     #-----------------------------------------------------------------------
     #++
-    # Return value converted to String object.
+    # Return true if valid index type.
     #
-    # *data_type*:: Symbol specifying data type.
-    # *value*:: Value to convert to String.
+    # *field_type*:: Symbol specifying field type.
     #
-    def KBTable.convert_to_string(data_type, value)
-        case data_type
-        when :YAML
-            y = value.to_yaml
-            if y =~ ENCODE_RE
-                return y.gsub("&", '&amp;').gsub("\n", '&linefeed;').gsub(
-                 "\r", '&carriage_return;').gsub("\032", '&substitute;'
-                 ).gsub("|", '&pipe;')
-            else
-                return y
-            end
-        when :String
-            if value =~ ENCODE_RE
-                return value.gsub("&", '&amp;').gsub("\n", '&linefeed;'
-                 ).gsub("\r", '&carriage_return;').gsub("\032",
-                 '&substitute;').gsub("|", '&pipe;')
-            else
-                return value
-            end  
-        when :Memo
-            return value.filepath
-        when :Blob
-            return value.filepath
-        else
-            return value.to_s
-        end
+    def KBTable.valid_index_type?(field_type)
+        VALID_INDEX_TYPES.include?(field_type)
     end
 
     #-----------------------------------------------------------------------
@@ -2017,8 +2089,8 @@ class KBTable
         # Update the header variables.
         update_header_vars
 
-        # Convert input, which could be an array, a hash, or a Struct
-        # into a common format (i.e. hash).
+        # Convert input, which could be a proc, an array, a hash, or a
+        # Struct into a common format (i.e. hash).
         if data.empty?
             input_rec = convert_input_data(insert_proc)
         else
@@ -2028,36 +2100,35 @@ 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
-                        
-        
+        input_rec = Struct.new(*field_names).new(*field_names.zip(
+         @field_defaults).collect do |fn, fd|
+            if input_rec[fn].nil?
+                fd
+            else
+                input_rec[fn]
+            end
+        end)
 
-        return @db.engine.insert_record(self, @field_names.zip(@field_types,
-         @field_defaults).collect do |fn, ft, fd|
-            if input_rec.has_key?(fn)
-                if input_rec[fn].nil?
-                    if fd.nil?
-                        ''
-                    else
-                        KBTable.convert_to_string(ft, fd)
-                    end
-                else
-                    KBTable.convert_to_string(ft, input_rec[fn])
-                end
+        check_required_fields(input_rec)
+
+        check_against_input_for_specials(input_rec)
+
+        new_recno = @db.engine.insert_record(self, @field_names.zip(
+         @field_types).collect do |fn, ft|
+            if input_rec[fn].nil?
+                ''
             else
-                if fd.nil?
-                    ''
-                else
-                    KBTable.convert_to_string(ft, fd)
-                end
+                convert_to_encoded_string(ft, input_rec[fn])
             end
         end)
+
+        # If there are any associated memo/blob fields, save their values.
+        input_rec.each { |r| r.write_to_file if r.is_a?(KBMemo) } if \
+         @field_types.include?(:Memo)
+        input_rec.each { |r| r.write_to_file if r.is_a?(KBBlob) } if \
+         @field_types.include?(:Blob)
+                        
+        return new_recno
     end
 
     #-----------------------------------------------------------------------
@@ -2069,8 +2140,23 @@ class KBTable
     #
     # *updates*:: Hash or Struct containing updates.
     #
-    def update_all(*updates)
-        update(*updates) { true }
+    def update_all(*updates, &update_proc)
+        raise 'Cannot specify both a hash/array/struct and a ' + \
+         'proc for method #update_all!' unless updates.empty? or \
+         update_proc.nil?
+
+        raise 'Must specify either hash/array/struct or update ' + \
+         'proc for method #update_all!' if updates.empty? and \
+         update_proc.nil?
+
+        # Depending on whether the user supplied an array/hash/struct or a
+        # block as update criteria, we are going to call updates in one of
+        # two ways.
+        if updates.empty?
+            update { true }.set &update_proc
+        else
+            update(*updates) { true }
+        end
     end
 
     #-----------------------------------------------------------------------
@@ -2094,8 +2180,13 @@ class KBTable
         # return them in an array.
         result_set = get_matches(:update, @field_names, select_cond)
 
+        # If updates is empty, this means that the user must have specified
+        # the updates in KBResultSet#set, i.e.
+        # tbl.update {|r| r.recno == 1}.set(:name => 'Bob')
         return result_set if updates.empty?
 
+        # Call KBTable#set and pass it the records to be updated and the
+        # updated criteria.
         set(result_set, updates)
     end
 
@@ -2123,37 +2214,64 @@ class KBTable
     # *data*:: Hash, Struct, Proc containing updates.
     #
     def set(recs, data)
-        # Convert updates, which could be an array, a hash, or a Struct
-        # into a common format (i.e. hash).
-        update_rec = convert_input_data(data)
+        # If updates are not in the form of a Proc, convert updates, which
+        # could be an array, a hash, or a Struct into a common format (i.e.
+        # hash).
+        update_rec = convert_input_data(data) unless data.is_a?(Proc)
 
-        # Make sure all of the fields of the update rec are of the proper
-        # 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
         # updates to it and write it back to the database table.
         recs.each do |rec|
-            updated_rec = {}
-            updated_rec[:rec] = \
-             @field_names.zip(@field_types).collect do |fn, ft|
-                KBTable.convert_to_string(ft,
-                 update_rec.fetch(fn, rec.send(fn)))
-            end
-            updated_rec[:fpos] = rec.fpos
-            updated_rec[:line_length] = rec.line_length
-            updated_recs << updated_rec
-        end
+            temp_rec = rec.dup
+
+            if data.is_a?(Proc)
+                begin
+                    data.call(temp_rec)
+                rescue NoMethodError
+                    raise 'Invalid field name in code block: %s' % $!
+                end
+             else
+                @field_names.each { |fn| temp_rec[fn] = update_rec.fetch(fn,
+                 temp_rec.send(fn)) }
+            end
+
+            # Is the user trying to change something they shouldn't?
+            raise 'Cannot update recno field!' unless \
+             rec.recno == temp_rec.recno
+            raise 'Cannot update internal fpos field!' unless \
+             rec.fpos == temp_rec.fpos
+            raise 'Cannot update internal line_length field!' unless \
+             rec.line_length == temp_rec.line_length
+
+            # Are the data types of the updates correct?
+            validate_input(temp_rec)
+
+            check_required_fields(temp_rec)
+
+            check_against_input_for_specials(temp_rec)
+
+            # Apply updates to the record and add it to an array holding
+            # updated records.  We need the fpos and line_length because
+            # the engine will use them to determine where to write the
+            # update and whether the updated record will fit in the old
+            # record's spot.
+            updated_recs << { :rec => @field_names.zip(@field_types
+             ).collect { |fn, ft| convert_to_encoded_string(ft,
+             temp_rec.send(fn)) }, :fpos => rec.fpos,
+             :line_length => rec.line_length }
+ 
+
+            # Update any associated blob/memo fields.
+            temp_rec.each { |r| r.write_to_file if r.is_a?(KBMemo) } if \
+             @field_types.include?(:Memo)
+            temp_rec.each { |r| r.write_to_file if r.is_a?(KBBlob) } if \
+             @field_types.include?(:Blob)
+        end
+
+        # Take all of the update records and write them back out to the
+        # table's file.
         @db.engine.update_records(self, updated_recs)
 
         # Return the number of records updated.
@@ -2193,10 +2311,12 @@ class KBTable
     #                     be reset to 0.
     #
     def clear(reset_recno_ctr=true)
-        delete { true }
+        recs_deleted = delete { true }
         pack
 
         @db.engine.reset_recno_ctr(self) if reset_recno_ctr
+        update_header_vars
+        return recs_deleted
     end
 
     #-----------------------------------------------------------------------
@@ -2278,6 +2398,9 @@ class KBTable
     # Remove blank records from table, return total removed.
     #
     def pack
+        raise "Do not execute this method in client/server mode!" if \
+         @db.client?
+
         lines_deleted = @db.engine.pack_table(self)
 
         update_header_vars
@@ -2386,6 +2509,9 @@ class KBTable
 
         raise "Column name cannot be recno!" if col_name == :recno
         
+        raise "Column name already exists!" if @field_names.include?(
+         col_name)
+
         # Does this new column have field extras (i.e. Index, Lookup, etc.)
         if col_type.is_a?(Hash)
             temp_type = col_type[:DataType]
@@ -2396,7 +2522,9 @@ class KBTable
         raise 'Invalid field type: %s' % temp_type unless \
          KBTable.valid_field_type?(temp_type)
 
-        @db.engine.add_column(self, col_name, col_type, after)
+        field_def = @db.build_header_field_string(col_name, col_type)
+
+        @db.engine.add_column(self, field_def, after)
 
         # Need to reinitialize the table instance and associated indexes.
         @db.engine.remove_recno_index(@name)
@@ -2547,7 +2675,7 @@ class KBTable
             @db.engine.change_column_default_value(self, col_name, nil)
         else
             @db.engine.change_column_default_value(self, col_name,
-             KBTable.convert_to_string(
+             convert_to_encoded_string(
               @field_types[@field_names.index(col_name)], value))
         end
             
@@ -2716,13 +2844,16 @@ class KBTable
             END_OF_STRING
             set_meth_str = <<-END_OF_STRING
             def #{field_name}=(s)
-                @#{field_name} = convert_to(:#{field_type}, s)
+                @#{field_name} = convert_to_native_type(:#{field_type}, s)
             end
             END_OF_STRING
 
             # If this is a Lookup field, modify the get_method.
             if field_extra.has_key?('Lookup')
                 lookup_table, key_field = field_extra['Lookup'].split('.')
+
+                # If joining to recno field of lookup table use the
+                # KBTable[] method to get the record from the lookup table.
                 if key_field == 'recno'
                     get_meth_str = <<-END_OF_STRING
                     def #{field_name}
@@ -2741,7 +2872,7 @@ class KBTable
                         def #{field_name}
                             table = @tbl.db.get_table(:#{lookup_table})
                             return table.select_by_#{key_field}_index { |r|
-                             r.#{key_field} == @#{field_name} }.first
+                             r.#{key_field} == @#{field_name} }[0]
                         end
                         END_OF_STRING
                     rescue RuntimeError
@@ -2749,7 +2880,7 @@ class KBTable
                         def #{field_name}
                             table = @tbl.db.get_table(:#{lookup_table})
                             return table.select { |r|
-                             r.#{key_field} == @#{field_name} }.first
+                             r.#{key_field} == @#{field_name} }[0]
                         end
                         END_OF_STRING
                     end
@@ -2845,54 +2976,80 @@ class KBTable
     # Convert data passed to #input, #update, or #set to a common format.
     #
     def convert_input_data(values)
-        if values.class == Proc
-            tbl_struct = Struct.new(*@field_names[1..-1])
-            tbl_rec = tbl_struct.new
+        temp_hash = {}
+
+        # This only applies to Procs in #insert, Procs in #update are
+        # handled in #set.
+        if values.is_a?(Proc)
+            tbl_rec = Struct.new(*@field_names[1..-1]).new
             begin
                 values.call(tbl_rec)
             rescue NoMethodError
                 raise 'Invalid field name in code block: %s' % $!
             end
-            temp_hash = {}
-            @field_names[1..-1].collect { |f|
+
+            @field_names[1..-1].each do |f|
                 temp_hash[f] = tbl_rec[f] unless tbl_rec[f].nil?
-            }
-            return temp_hash
-        elsif values[0].class.to_s == @record_class or \
-         values[0].class == @table_class
-            temp_hash = {}
-            @field_names[1..-1].collect { |f|
-                temp_hash[f] = values[0].send(f) if values[0].respond_to?(f)
-            }
-            return temp_hash
-        elsif values[0].class == Hash
-            return values[0].dup
-        elsif values[0].kind_of?(Struct)
-            temp_hash = {}
-            @field_names[1..-1].collect { |f|
-                temp_hash[f] = values[0][f] if values[0].members.include?(
-                 f.to_s)
-            }
-            return temp_hash
-        elsif values[0].class == Array
-            raise ArgumentError, 'Must specify all fields in input array!' \
-             unless values[0].size == @field_names[1..-1].size
-            temp_hash = {}
-            @field_names[1..-1].collect { |f|
-                temp_hash[f] = values[0][@field_names.index(f)-1]
-            }
-            return temp_hash
-        elsif values.class == Array
+            end
+
+        # Is input data an instance of custom record class, Struct, or
+        # KBTableRec?
+        elsif values.first.is_a?(Object.full_const_get(@record_class)) or \
+         values.first.is_a?(Struct) or values.first.class == @table_class
+            @field_names[1..-1].each do |f|
+                temp_hash[f] = values.first.send(f) if \
+                 values.first.respond_to?(f)
+            end
+
+        # Is input data a hash?
+        elsif values.first.is_a?(Hash)
+            temp_hash = values.first.dup
+
+        # Is input data an array?
+        elsif values.is_a?(Array)
             raise ArgumentError, 'Must specify all fields in input array!' \
              unless values.size == @field_names[1..-1].size
-            temp_hash = {}
-            @field_names[1..-1].collect { |f|
+
+            @field_names[1..-1].each do |f|
                 temp_hash[f] = values[@field_names.index(f)-1]
-            }
-            return temp_hash
+            end
         else
             raise(ArgumentError, 'Invalid type for values container!')
         end
+
+        return temp_hash
+    end
+
+    #-----------------------------------------------------------------------
+    # check_required_fields
+    #-----------------------------------------------------------------------
+    #++
+    # Check that all required fields have values.
+    #
+    def check_required_fields(data)
+        @field_names[1..-1].each do |f|
+            raise(ArgumentError,
+             'A value for this field is required: %s' % f) if \
+             @field_requireds[@field_names.index(f)] and data[f].nil? 
+        end
+    end
+
+    #-----------------------------------------------------------------------
+    # check_against_input_for_specials
+    #-----------------------------------------------------------------------
+    #++
+    # Check that no special field types (i.e. calculated or link_many
+    # fields)
+    # have been given values.
+    #
+    def check_against_input_for_specials(data)
+        @field_names[1..-1].each do |f|
+            raise(ArgumentError,
+             'You cannot input a value for this field: %s' % f) if \
+             @field_extras[@field_names.index(f)].has_key?('Calculated') \
+             or @field_extras[@field_names.index(f)].has_key?('Link_many') \
+              and not data[f].nil? 
+        end
     end
 
     #-----------------------------------------------------------------------
@@ -2902,49 +3059,12 @@ class KBTable
     # Check input data to ensure proper data types.
     #
     def validate_input(data)
-        raise 'Cannot insert/update recno field!' if data.has_key?(:recno)
-
         @field_names[1..-1].each do |f|
-            next unless data.has_key?(f)
+            next if data[f].nil?
 
-            if data[f].nil?
-                raise 'A value for this field is required: %s' % f if \
-                 @field_requireds[@field_names.index(f)]
-                next                
-            end
-            
-            case @field_types[@field_names.index(f)]
-            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)
-            when :Integer
-                raise 'Invalid Integer value for: %s' % f unless \
-                 data[f].respond_to?(:to_int)
-            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 :DateTime
-                raise 'Invalid DateTime value for: %s' % f unless \
-                 data[f].is_a?(DateTime)
-            when :YAML
-                raise 'Invalid YAML value for: %s' % f unless \
-                 data[f].respond_to?(:to_yaml)
-            end
+            raise 'Invalid data %s for column %s' % [data[f], f] unless \
+             KBTable.valid_data_type?(@field_types[@field_names.index(f)],
+             data[f])
         end
     end
 
@@ -2963,6 +3083,9 @@ class KBTable
     #-----------------------------------------------------------------------
     # get_result_struct
     #-----------------------------------------------------------------------
+    #++
+    # Return Struct object that will hold result record.
+    #
     def get_result_struct(query_type, filter)
         case query_type
         when :select
@@ -2978,6 +3101,9 @@ class KBTable
     #-----------------------------------------------------------------------
     # create_result_rec
     #-----------------------------------------------------------------------
+    #++
+    # Return Struct/custom class populated with table row data.
+    #
     def create_result_rec(query_type, filter, result_struct, tbl_rec, rec)
         # If this isn't a select query or if it is a select query, but
         # the table record class is simply a Struct, then we will use
@@ -3036,11 +3162,11 @@ class KBTable
         # Loop through table.
         @db.engine.get_recs(self).each do |rec|
             tbl_rec.populate(rec)
-            next unless select_cond.call(tbl_rec) unless select_cond.nil?
+
+            next if select_cond and not select_cond.call(tbl_rec)
 
             match_array << create_result_rec(query_type, filter,
              result_struct, tbl_rec, rec)
-
         end
         return match_array
     end
@@ -3099,16 +3225,14 @@ class KBTable
     #
     def get_matches_by_recno_index(query_type, filter, select_cond)
         good_matches = []
-
         idx_struct = Struct.new(:recno)
 
         begin
             @db.engine.get_recno_index(self).each_key do |key|
-                good_matches << key if select_cond.call(
-                 idx_struct.new(key))
+                good_matches << key if select_cond.call(idx_struct.new(key))
             end
         rescue NoMethodError
-            raise "Field name in select block not part of index!"
+            raise "You can only use recno field in select block!"
         end
 
         return nil if good_matches.empty?
@@ -3150,7 +3274,6 @@ class KBTable
         tbl_rec = @table_class.new(self)
 
         @db.engine.get_recs_by_recno(self, recnos).each do |rec|
-
             next if rec.nil?
             tbl_rec.populate(rec)
 
@@ -3177,15 +3300,22 @@ class KBMemo
         @contents = contents
     end
     
+    #-----------------------------------------------------------------------
+    # read_from_file
+    #-----------------------------------------------------------------------
     def read_from_file
         @contents = @db.engine.read_memo_file(@filepath)
     end
     
+    #-----------------------------------------------------------------------
+    # write_to_file
+    #-----------------------------------------------------------------------
     def write_to_file
         @db.engine.write_memo_file(@filepath, @contents)
     end
 end
 
+
 #---------------------------------------------------------------------------
 # KBBlob
 #---------------------------------------------------------------------------
@@ -3201,10 +3331,16 @@ class KBBlob
         @contents = contents
     end
     
+    #-----------------------------------------------------------------------
+    # read_from_file
+    #-----------------------------------------------------------------------
     def read_from_file
         @contents = @db.engine.read_blob_file(@filepath)
     end
 
+    #-----------------------------------------------------------------------
+    # write_to_file
+    #-----------------------------------------------------------------------
     def write_to_file
         @db.engine.write_blob_file(@filepath, @contents)
     end
@@ -3216,8 +3352,7 @@ end
 #---------------------------------------------------------------------------
 class KBIndex
     include KBTypeConversionsMixin
-
-    UNENCODE_RE = /&(?:amp|linefeed|carriage_return|substitute|pipe);/
+    include KBEncryptionMixin
 
     #-----------------------------------------------------------------------
     # initialize
@@ -3277,7 +3412,8 @@ class KBIndex
                 # native types.
                 idx_rec = []
                 @col_poss.zip(@col_types).each do |col_pos, col_type|
-                    idx_rec << convert_to(col_type, rec[col_pos])
+                    idx_rec << convert_to_native_type(col_type,
+                     rec[col_pos])
                 end
 
                 # Were all the index fields for this record equal to NULL?
@@ -3303,7 +3439,7 @@ class KBIndex
     #-----------------------------------------------------------------------
     def add_index_rec(rec)
         @idx_arr << @col_poss.zip(@col_types).collect do |col_pos, col_type|
-            convert_to(col_type, rec[col_pos])
+            convert_to_native_type(col_type, rec[col_pos])
          end + [rec.first.to_i]
          
         @last_update = Time.new 
@@ -3332,7 +3468,7 @@ end
 # KBRecnoIndex
 #---------------------------------------------------------------------------
 class KBRecnoIndex
-#    include DRb::DRbUndumped
+    include KBEncryptionMixin
 
     #-----------------------------------------------------------------------
     # initialize
@@ -3345,7 +3481,7 @@ class KBRecnoIndex
     #-----------------------------------------------------------------------
     # get_idx
     #-----------------------------------------------------------------------
-    def get_idx        
+    def get_idx
         return @idx_hash
     end