[Zodb-checkins] CVS: ZODB3/Doc/zodb - zodb.html:1.4 zodb.css:1.4 zeo.html:1.4 node8.html:1.4 node7.html:1.4 node6.html:1.4 node5.html:1.4 node3.html:1.4 node2.html:1.4 index.html:1.4 contents.html:1.4 about.html:1.4

Jeremy Hylton jeremy at zope.com
Tue Jan 6 23:11:58 EST 2004


Update of /cvs-repository/ZODB3/Doc/zodb
In directory cvs.zope.org:/tmp/cvs-serv21327/Doc/zodb

Modified Files:
	zodb.html zodb.css zeo.html node8.html node7.html node6.html 
	node5.html node3.html node2.html index.html contents.html 
	about.html 
Log Message:
Update the HTML from the Latex source.


=== ZODB3/Doc/zodb/zodb.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/zodb.html:1.3	Thu Oct  2 14:17:27 2003
+++ ZODB3/Doc/zodb/zodb.html	Tue Jan  6 23:11:57 2004
@@ -48,8 +48,8 @@
 <h1>ZODB/ZEO Programming Guide</h1>
 <p><b><font size="+2">A.M. Kuchling</font></b></p>
 <p><span class="email">amk at amk.ca</span></p>
-<p><strong>Release 0.2</strong><br />
-<strong>1 October 2003</strong></p>
+<p><strong>Release 0.3a2</strong><br />
+<strong>6 January 2004</strong></p>
 </center>
 </div>
 
@@ -77,16 +77,16 @@
 </ul>
 <LI><A href="node3.html#SECTION000320000000000000000">2.2 How ZODB Works</a>
 <LI><A href="node3.html#SECTION000330000000000000000">2.3 Opening a ZODB</a>
-<LI><A href="node3.html#SECTION000340000000000000000">2.4 Writing a Persistent Class</a>
-<LI><A href="node3.html#SECTION000350000000000000000">2.5 Rules for Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000340000000000000000">2.4 Using a ZODB Configuration File</a>
+<LI><A href="node3.html#SECTION000350000000000000000">2.5 Writing a Persistent Class</a>
+<LI><A href="node3.html#SECTION000360000000000000000">2.6 Rules for Writing Persistent Classes</a>
 <UL>
-<LI><A href="node3.html#SECTION000351000000000000000">2.5.1 Modifying Mutable Objects</a>
-<LI><A href="node3.html#SECTION000352000000000000000">2.5.2 Some Special Methods Don't Work</a>
-<LI><A href="node3.html#SECTION000353000000000000000">2.5.3 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></a>
+<LI><A href="node3.html#SECTION000361000000000000000">2.6.1 Modifying Mutable Objects</a>
+<LI><A href="node3.html#SECTION000362000000000000000">2.6.2 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></a>
 </ul>
-<LI><A href="node3.html#SECTION000360000000000000000">2.6 Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000370000000000000000">2.7 Writing Persistent Classes</a>
 <UL>
-<LI><A href="node3.html#SECTION000361000000000000000">2.6.1 Changing Instance Attributes</a>
+<LI><A href="node3.html#SECTION000371000000000000000">2.7.1 Changing Instance Attributes</a>
 </ul>
 </ul>
 <LI><A href="zeo.html">3 ZEO</a>
@@ -110,11 +110,12 @@
 </ul>
 <LI><A href="node6.html">5 Related Modules</a>
 <UL>
-<LI><A href="node6.html#SECTION000610000000000000000">5.1 <tt class="module">ZODB.PersistentMapping</tt></a>
-<LI><A href="node6.html#SECTION000620000000000000000">5.2 <tt class="module">ZODB.PersistentList</tt></a>
+<LI><A href="node6.html#SECTION000610000000000000000">5.1 <tt class="module">persistent.mapping.PersistentMapping</tt></a>
+<LI><A href="node6.html#SECTION000620000000000000000">5.2 <tt class="module">persistent.list.PersistentList</tt></a>
 <LI><A href="node6.html#SECTION000630000000000000000">5.3 BTrees Package</a>
 <UL>
 <LI><A href="node6.html#SECTION000631000000000000000">5.3.1 Total Ordering and Persistence</a>
+<LI><A href="node6.html#SECTION000632000000000000000">5.3.2 BTree Diagnostic Tools</a>
 </ul>
 </ul>
 <LI><A href="node7.html">A. Resources</a>
@@ -165,7 +166,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/zodb.css 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/zodb.css:1.3	Thu Oct  2 14:17:27 2003
+++ ZODB3/Doc/zodb/zodb.css	Tue Jan  6 23:11:57 2004
@@ -72,7 +72,7 @@
 
 div.warning             { background-color: #fffaf0;
                           border: thin solid black;
-                          padding: 1em 1em 0em 1em;
+                          padding: 1em;
                           margin-left: 2em;
                           margin-right: 2em; }
 
@@ -82,7 +82,7 @@
 
 div.note                { background-color: #fffaf0;
                           border: thin solid black;
-                          padding: 1em 1em 0em 1em;
+                          padding: 1em;
                           margin-left: 2em;
                           margin-right: 2em; }
 


=== ZODB3/Doc/zodb/zeo.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/zeo.html:1.3	Thu Oct  2 14:17:27 2003
+++ ZODB3/Doc/zodb/zeo.html	Tue Jan  6 23:11:57 2004
@@ -93,7 +93,7 @@
 object database.
 
 <P>
-ZEO consists of about 6000 lines of Python code, excluding tests.  The
+ZEO consists of about 12,000 lines of Python code, excluding tests.  The
 code is relatively small because it contains only code for a TCP/IP
 server, and for a new type of Storage, <tt class="class">ClientStorage</tt>.
 <tt class="class">ClientStorage</tt> simply makes remote procedure calls to the
@@ -107,7 +107,7 @@
 Any number of processes can create a <tt class="class">ClientStorage</tt>
 instance, and any number of threads in each process can be using that
 instance.  <tt class="class">ClientStorage</tt> aggressively caches objects
-locally, so in order to avoid using stale data.  The ZEO server sends
+locally, so in order to avoid using stale data the ZEO server sends
 an invalidation message to all the connected <tt class="class">ClientStorage</tt>
 instances on every write operation.  The invalidation message contains
 the object ID for each object that's been modified, letting the
@@ -123,8 +123,10 @@
 applications.  If every <tt class="class">ClientStorage</tt> is writing to the
 database all the time, this will result in a storm of invalidate
 messages being sent, and this might take up more processing time than
-the actual database operations themselves.<A NAME="tex2html1"
-  HREF="#foot433"><SUP>1</SUP></A>
+the actual database operations themselves. These messages are
+small and sent in batches, so there would need to be a lot of writes
+before it became a problem.
+
 <P>
 On the other hand, for applications that have few writes in comparison
 to the number of read accesses, this aggressive caching can be a major
@@ -158,7 +160,7 @@
 
 <P>
 The ZEO server software is included in ZODB3.  As with the rest of
-ZODB3, you'll need Python 2.1 or higher.
+ZODB3, you'll need Python 2.3 or higher.
 
 <P>
 
@@ -167,11 +169,11 @@
 </H3>
 
 <P>
-The start.py script in the ZEO directory can be used to start a
+The runzeo.py script in the ZEO directory can be used to start a
 server.  Run it with the -h option to see the various values.  If
 you're just experimenting, a good choise is to use 
-<code>python ZEO/start.py -D -U /tmp/zeosocket</code> to run ZEO in
-debug mode and with a Unix domain socket.
+<code>python ZEO/runzeo.py -a /tmp/zeosocket -f /tmp/test.fs</code> to run
+ZEO with a Unix domain socket and a <tt class="class">FileStorage</tt>.
 
 <P>
 
@@ -200,7 +202,7 @@
 from ZODB import DB
 
 # Change next line to connect to your ZEO server
-addr = ('kronos.example.com', 1975)
+addr = 'kronos.example.com', 1975
 storage = ClientStorage.ClientStorage(addr)
 db = DB(storage)
 conn = db.open()
@@ -218,6 +220,30 @@
 If this code runs properly, then your ZEO server is working correctly.
 
 <P>
+You can also use a configuration file.
+
+<P>
+<div class="verbatim"><pre>
+&lt;zodb&gt;
+    &lt;zeoclient&gt;
+    server localhost:9100
+    &lt;/zeoclient&gt;
+&lt;/zodb&gt;
+</pre></div>
+
+<P>
+One nice feature of the configuration file is that you don't need to
+specify imports for a specific storage.  That makes the code a little
+shorter and allows you to change storages without changing the code.
+
+<P>
+<div class="verbatim"><pre>
+import ZODB.config
+
+db = ZODB.config.databaseFromURL('/tmp/zeo.conf')
+</pre></div>
+
+<P>
 
 <H2><A NAME="SECTION000440000000000000000">
 3.4 ZEO Programming Notes</A>
@@ -379,16 +405,7 @@
 </UL>
 
 <P>
-<BR><HR><H4>Footnotes</H4>
-<DL>
-<DT><A NAME="foot433">... themselves.</A><A
- href="zeo.html#tex2html1"><SUP>1</SUP></A></DT>
-<DD>These messages are
-small and sent in batches, so there would need to be a lot of writes
-before it became a problem.
 
-</DD>
-</DL>
 <DIV CLASS="navigation">
 <div class='online-navigation'><hr />
 <table align="center" width="100%" cellpadding="0" cellspacing="2">
@@ -424,7 +441,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/node8.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/node8.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/node8.html	Tue Jan  6 23:11:57 2004
@@ -575,7 +575,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/node7.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/node7.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/node7.html	Tue Jan  6 23:11:57 2004
@@ -57,13 +57,6 @@
 </H1>
 
 <P>
-ZODB HOWTO, by Michel Pelletier:
-
-<BR>
-Goes into slightly more detail about the rules for writing applications using the ZODB.
-
-<BR><a class="url" href="http://www.zope.org/Members/michel/HowTos/ZODB-How-To">http://www.zope.org/Members/michel/HowTos/ZODB-How-To</a>
-<P>
 Introduction to the Zope Object Database, by Jim Fulton:
 
 <BR>
@@ -119,7 +112,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/node6.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/node6.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/node6.html	Tue Jan  6 23:11:57 2004
@@ -56,11 +56,12 @@
 <A NAME="CHILD_LINKS"><STRONG>Subsections</STRONG></a>
 
 <UL CLASS="ChildLinks">
-<LI><A href="node6.html#SECTION000610000000000000000">5.1 <tt class="module">ZODB.PersistentMapping</tt></a>
-<LI><A href="node6.html#SECTION000620000000000000000">5.2 <tt class="module">ZODB.PersistentList</tt></a>
+<LI><A href="node6.html#SECTION000610000000000000000">5.1 <tt class="module">persistent.mapping.PersistentMapping</tt></a>
+<LI><A href="node6.html#SECTION000620000000000000000">5.2 <tt class="module">persistent.list.PersistentList</tt></a>
 <LI><A href="node6.html#SECTION000630000000000000000">5.3 BTrees Package</a>
 <UL>
 <LI><A href="node6.html#SECTION000631000000000000000">5.3.1 Total Ordering and Persistence</a>
+<LI><A href="node6.html#SECTION000632000000000000000">5.3.2 BTree Diagnostic Tools</a>
 </ul></ul>
 <!--End of Table of Child-Links-->
 </div>
@@ -77,7 +78,7 @@
 <P>
 
 <H2><A NAME="SECTION000610000000000000000">
-5.1 <tt class="module">ZODB.PersistentMapping</tt></A>
+5.1 <tt class="module">persistent.mapping.PersistentMapping</tt></A>
 </H2>
 
 <P>
@@ -87,7 +88,7 @@
 
 <P>
 <dl><dt><table cellpadding="0" cellspacing="0"><tr valign="baseline">
-  <td><nobr><b><a name="l2h-1" id='l2h-1'><tt class="function">PersistentMapping</tt></a></b>(</nobr></td>
+  <td><nobr><b><tt id='l2h-1' class="function">PersistentMapping</tt></b>(</nobr></td>
   <td><var>container = {}</var>)</td></tr></table></dt>
 <dd>
 Create a <tt class="class">PersistentMapping</tt> object that wraps the
@@ -102,7 +103,7 @@
 <P>
 
 <H2><A NAME="SECTION000620000000000000000">
-5.2 <tt class="module">ZODB.PersistentList</tt></A>
+5.2 <tt class="module">persistent.list.PersistentList</tt></A>
 </H2>
 
 <P>
@@ -111,7 +112,7 @@
 
 <P>
 <dl><dt><table cellpadding="0" cellspacing="0"><tr valign="baseline">
-  <td><nobr><b><a name="l2h-2" id='l2h-2'><tt class="function">PersistentList</tt></a></b>(</nobr></td>
+  <td><nobr><b><tt id='l2h-2' class="function">PersistentList</tt></b>(</nobr></td>
   <td><var>initlist = []</var>)</td></tr></table></dt>
 <dd>
 Create a <tt class="class">PersistentList</tt> object that wraps the
@@ -146,7 +147,7 @@
 <P>
 The BTrees package provides a large collection of related data
 structures.  There are variants of the data structures specialized to
-handle integer values, which are faster and use less memory.  There
+integers, which are faster and use less memory.  There
 are four modules that handle the different variants.  The first two
 letters of the module name specify the types of the keys and values in
 mappings - O for any object and I for integer.  For example, the
@@ -154,21 +155,24 @@
 keys and arbitrary objects as values.
 
 <P>
-The four data structures provide by each module are a btree, a bucket,
-a tree set, and a set.  The btree and bucket types are mappings and
+The four data structures provide by each module are a BTree, a Bucket,
+a TreeSet, and a Set.  The BTree and Bucket types are mappings and
 support all the usual mapping methods, e.g. <tt class="function">update()</tt> and
-<tt class="function">keys()</tt>.  The tree set and set types are similar to mappings
+<tt class="function">keys()</tt>.  The TreeSet and Set types are similar to mappings
 but they have no values; they support the methods that make sense for
 a mapping with no keys, e.g. <tt class="function">keys()</tt> but not
-<tt class="function">items()</tt>.  The bucket and set types are the individual
-building blocks for btrees and tree sets, respectively.  A bucket or
-set can be used when you are sure that it will have few elements.  If
-the data structure will grow large, you should use a btree or tree
-set.  Like Python lists, buckets and sets are allocated in one
+<tt class="function">items()</tt>.  The Bucket and Set types are the individual
+building blocks for BTrees and TreeSets, respectively.  A Bucket or
+Set can be used when you are sure that it will have few elements.  If
+the data structure will grow large, you should use a BTree or TreeSet.
+Like Python lists, Buckets and Sets are allocated in one
 contiguous piece, and insertions and deletions can take time
-proportional to the number of existing elements.  Btrees and tree sets
-are multi-level tree structures with much better (logarithmic) worst-case
-time bounds.
+proportional to the number of existing elements.  Also like Python lists,
+a Bucket or Set is a single object, and is pickled and unpickled in its
+entirety.  BTrees and TreeSets are multi-level tree structures with
+much better (logarithmic) worst-case time bounds, and the tree structure
+is built out of multiple objects, which ZODB can load individually
+as needed.
 
 <P>
 The four modules are named <tt class="module">OOBTree</tt>, <tt class="module">IOBTree</tt>,
@@ -180,7 +184,7 @@
 
 <P>
 The <tt class="function">keys()</tt>, <tt class="function">values()</tt>, and <tt class="function">items()</tt>
-methods on btree and tree set types do not materialize a list with all
+methods on BTree and TreeSet types do not materialize a list with all
 of the data.  Instead, they return lazy sequences that fetch data
 from the BTree as needed.  They also support optional arguments to
 specify the minimum and maximum values to return, often called "range
@@ -189,26 +193,31 @@
 
 <P>
 The <tt class="function">keys()</tt>, <tt class="function">values()</tt>, and <tt class="function">items()</tt>
-methods on bucket and set types do return lists with all the data.
-Starting in ZODB4, there are also <tt class="function">iterkeys()</tt>,
+methods on Bucket and Set types do return lists with all the data.
+Starting in ZODB 3.3, there are also <tt class="function">iterkeys()</tt>,
 <tt class="function">itervalues()</tt>, and <tt class="function">iteritems()</tt> methods that
-return iterators (in the Python 2.2 sense).
+return iterators (in the Python 2.2 sense).  Those methods also apply to
+BTree and TreeSet objects.
 
 <P>
-A BTree object supports all the methods you would expect of a mapping
+A BTree object supports all the methods you would expect of a mapping,
 with a few extensions that exploit the fact that the keys are sorted.
 The example below demonstrates how some of the methods work.  The
 extra methods are <tt class="function">minKey()</tt> and <tt class="function">maxKey()</tt>, which
 find the minimum and maximum key value subject to an optional bound
 argument, and <tt class="function">byValue()</tt>, which should probably be ignored
 (it's hard to explain exactly what it does, and as a result it's
-almost never used - best to consider it deprecated).
+almost never used - best to consider it deprecated).  The various
+methods for enumerating keys, values and items also accept minimum
+and maximum key arguments ("range search"), and (new in ZODB 3.3)
+optional Boolean arguments to control whether a range search is
+inclusive or exclusive of the range's endpoints.
 
 <P>
 <div class="verbatim"><pre>
 &gt;&gt;&gt; from BTrees.OOBTree import OOBTree
 &gt;&gt;&gt; t = OOBTree()
-&gt;&gt;&gt; t.update({ 1: "red", 2: "green", 3: "blue", 4: "spades" })
+&gt;&gt;&gt; t.update({1: "red", 2: "green", 3: "blue", 4: "spades"})
 &gt;&gt;&gt; len(t)
 4
 &gt;&gt;&gt; t[2]
@@ -224,28 +233,65 @@
 [1, 2, 3, 4]
 &gt;&gt;&gt; list(t.values())
 ['red', 'green', 'blue', 'spades']
-&gt;&gt;&gt; list(t.values(1, 2))
+&gt;&gt;&gt; list(t.values(1, 2)) # values at keys in 1 to 2 inclusive
 ['red', 'green']
-&gt;&gt;&gt; list(t.values(2))
+&gt;&gt;&gt; list(t.values(2))    # values at keys &gt;= 2
 ['green', 'blue', 'spades']
+&gt;&gt;&gt; list(t.values(min=1, max=4))  # keyword args new in ZODB 3.3
+['red', 'green', 'blue', 'spades']
+&gt;&gt;&gt; list(t.values(min=1, max=4, excludemin=True, excludemax=True))
+['green', 'blue']
 &gt;&gt;&gt; t.minKey()     # smallest key
 1
 &gt;&gt;&gt; t.minKey(1.5)  # smallest key &gt;= 1.5
 2
+&gt;&gt;&gt; for k in t.keys():
+...     print k,
+1 2 3 4
+&gt;&gt;&gt; for k in t:    # new in ZODB 3.3
+...     print k,
+1 2 3 4
+&gt;&gt;&gt; for pair in t.iteritems():  # new in ZODB 3.3
+...     print pair,
+...
+(1, 'red') (2, 'green') (3, 'blue') (4, 'spades')
+&gt;&gt;&gt; t.has_key(4)  # returns a true value, but exactly what undefined
+2
+&gt;&gt;&gt; t.has_key(5)
+0
+&gt;&gt;&gt; 4 in t  # new in ZODB 3.3
+True
+&gt;&gt;&gt; 5 in t  # new in ZODB 3.3
+False
+&gt;&gt;&gt;
 </pre></div>
 
 <P>
 Each of the modules also defines some functions that operate on
 BTrees - <tt class="function">difference()</tt>, <tt class="function">union()</tt>, and
-<tt class="function">difference()</tt>.  The <tt class="function">difference()</tt> function returns
-a bucket, while the other two methods return a set.
+<tt class="function">intersection()</tt>.  The <tt class="function">difference()</tt> function returns
+a Bucket, while the other two methods return a Set.
 If the keys are integers, then the module also defines
 <tt class="function">multiunion()</tt>.  If the values are integers, then the module
 also defines <tt class="function">weightedIntersection()</tt> and
-<tt class="function">weighterUnion()</tt>.  The function doc strings describe each
+<tt class="function">weightedUnion()</tt>.  The function doc strings describe each
 function briefly.
 
 <P>
+<code>BTrees/Interfaces.py</code> defines the operations, and is the official
+documentation.  Note that the interfaces don't define the concrete types
+returned by most operations, and you shouldn't rely on the concrete types
+that happen to be returned:  stick to operations guaranteed by the
+interface.  In particular, note that the interfaces don't specify anything
+about comparison behavior, and so nothing about it is guaranteed.  In ZODB
+3.3, for example, two BTrees happen to use Python's default object
+comparison, which amounts to comparing the (arbitrary but fixed) memory
+addresses of the BTrees. This may or may not be true in future releases.
+If the interfaces don't specify a behavior, then whether that behavior
+appears to work, and exactly happens if it does appear to work, are
+undefined and should not be relied on.
+
+<P>
 
 <H3><A NAME="SECTION000631000000000000000">
 5.3.1 Total Ordering and Persistence</A>
@@ -255,7 +301,7 @@
 The BTree-based data structures differ from Python dicts in several
 fundamental ways.  One of the most important is that while dicts
 require that keys support hash codes and equality comparison,
-the btree-based structures don't use hash codes and require a total
+the BTree-based structures don't use hash codes and require a total
 ordering on keys.
 
 <P>
@@ -287,12 +333,12 @@
 does not satisfy these rules:  complex numbers only support <code>==</code>
 and <code>!=</code> comparisons, and raise an exception if you try to compare
 them in any other way.  They don't satisfy the trichotomy rule, and must
-not be used as keys in btree-based data structures (although note that
+not be used as keys in BTree-based data structures (although note that
 complex numbers can be used as keys in Python dicts, which do not require
 a total ordering).
 
 <P>
-Examples of objects that are wholly safe to use as keys in btree-based
+Examples of objects that are wholly safe to use as keys in BTree-based
 structures include ints, longs, floats, 8-bit strings, Unicode strings,
 and tuples composed (possibly recursively) of objects of wholly safe
 types.
@@ -305,12 +351,12 @@
 <code>u'x' == 'x'</code>, but trying to compare <code>chr(255)</code> to
 <code>u'x'</code> raises an exception.  Partly for this reason (another is
 given later), it can be dangerous to use keys with multiple types in
-a single btree-based structure.  Don't try to do that, and you don't
+a single BTree-based structure.  Don't try to do that, and you don't
 have to worry about it.
 
 <P>
 Another potential problem is mutability:  when a key is inserted in a
-btree-based structure, it must retain the same order relative to the
+BTree-based structure, it must retain the same order relative to the
 other keys over time.  This is easy to run afoul of if you use mutable
 objects as keys.  For example, lists supply a total ordering, and then
 
@@ -343,7 +389,7 @@
 addresses of two objects.  Because Python never moves an object in memory,
 this does supply a usable (albeit arbitrary) total ordering across the
 life of a program run (an object's memory address doesn't change).  But
-if objects compared in this way are used as keys of a btree-based
+if objects compared in this way are used as keys of a BTree-based
 structure that's stored in a database, when the objects are loaded from
 the database again they will almost certainly wind up at different
 memory addresses.  There's no guarantee then that if key K1 had a memory
@@ -360,8 +406,8 @@
 common mistake is to use keys that are instances of a user-defined class
 that doesn't supply its own <tt class="method">__cmp__()</tt> method.  Python compares
 such instances by memory address.  This is fine if such instances are
-used as keys in temporary btree-based structures used only in a single
-program run.  It can be disastrous if that btree-based structure is
+used as keys in temporary BTree-based structures used only in a single
+program run.  It can be disastrous if that BTree-based structure is
 stored to a database, though.
 
 <P>
@@ -389,7 +435,7 @@
 <tt class="method">__cmp__()</tt>, but define it incorrectly.  It's possible but
 rare for a custom <tt class="method">__cmp__()</tt> implementation to violate one
 of the three required formal properties directly.  It's more common for
-it to fall back" to address-based comparison by mistake.
+it to "fall back" to address-based comparison by mistake.
 For example,
 
 <P>
@@ -405,7 +451,7 @@
 <P>
 It's quite possible there that the <tt class="keyword">else</tt> clause allows
 a result to be computed based on memory address.  The bug won't show
-up until a btree-based structure uses objects of class <tt class="class">Mine</tt> as
+up until a BTree-based structure uses objects of class <tt class="class">Mine</tt> as
 keys, and also objects of other types as keys, and the structure is
 loaded from a database, and a sequence of comparisons happens to execute
 the <tt class="keyword">else</tt> clause in a case where the relative order of object
@@ -423,11 +469,11 @@
 
 <OL>
 <LI>Use objects of simple immutable types as keys in
-       btree-based data structures.
+       BTree-based data structures.
 
 <P>
 </LI>
-<LI>Within a single btree-based data structure, use objects of
+<LI>Within a single BTree-based data structure, use objects of
        a single type as keys.  Don't use multiple key types in a
        single structure.
 
@@ -448,6 +494,34 @@
 
 <P>
 
+<H3><A NAME="SECTION000632000000000000000">
+5.3.2 BTree Diagnostic Tools</A>
+</H3>
+
+<P>
+A BTree (or TreeSet) is a complex data structure, really a graph of
+variable-size nodes, connected in multiple ways via three distinct kinds
+of C pointers.  There are some tools available to help check internal
+consistency of a BTree as a whole.
+
+<P>
+Most generally useful is the <tt class="module">BTrees.check</tt> module.  The
+<tt class="function">check.check()</tt> function examines a BTree (or Bucket, Set, or
+TreeSet) for value-based consistency, such as that the keys are in
+strictly increasing order.  See the function docstring for details.
+The <tt class="function">check.display()</tt> function displays the internal structure
+of a BTree.
+
+<P>
+BTrees and TreeSets also have a <tt class="method">_check()</tt> method.  This verifies
+that the (possibly many) internal pointers in a BTree or TreeSet
+are mutually consistent, and raises <tt class="exception">AssertionError</tt> if they're
+not.  If a <tt class="method">_check()</tt> method call fails, in may point to a bug
+in the implementation of BTrees or conflict resolution, or may point to
+database corruption.
+
+<P>
+
 
 <P>
 
@@ -486,7 +560,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/node5.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/node5.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/node5.html	Tue Jan  6 23:11:57 2004
@@ -182,8 +182,8 @@
 <P>
 After you call <tt class="method">undo()</tt> you must commit the transaction for the
 undo to actually be applied.
-<A NAME="tex2html2"
-  HREF="#foot587"><SUP>2</SUP></A>  There is one glitch in the undo process.  The thread
+<A NAME="tex2html1"
+  HREF="#foot585"><SUP>1</SUP></A>  There is one glitch in the undo process.  The thread
 that calls undo may not see the changes to the object until it calls
 <tt class="method">Connection.sync()</tt> or commits another transaction.
 
@@ -265,8 +265,8 @@
 <P>
 <BR><HR><H4>Footnotes</H4>
 <DL>
-<DT><A NAME="foot587">... applied.</A><A
- HREF="node5.html#tex2html2"><SUP>2</SUP></A></DT>
+<DT><A NAME="foot585">... applied.</A><A
+ HREF="node5.html#tex2html1"><SUP>1</SUP></A></DT>
 <DD>There are actually two different ways a storage can
 implement the undo feature.  Most of the storages that ship with ZODB
 use the transactional form of undo described in the main text.  Some
@@ -310,7 +310,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/node3.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/node3.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/node3.html	Tue Jan  6 23:11:57 2004
@@ -63,16 +63,16 @@
 </ul>
 <LI><A href="node3.html#SECTION000320000000000000000">2.2 How ZODB Works</a>
 <LI><A href="node3.html#SECTION000330000000000000000">2.3 Opening a ZODB</a>
-<LI><A href="node3.html#SECTION000340000000000000000">2.4 Writing a Persistent Class</a>
-<LI><A href="node3.html#SECTION000350000000000000000">2.5 Rules for Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000340000000000000000">2.4 Using a ZODB Configuration File</a>
+<LI><A href="node3.html#SECTION000350000000000000000">2.5 Writing a Persistent Class</a>
+<LI><A href="node3.html#SECTION000360000000000000000">2.6 Rules for Writing Persistent Classes</a>
 <UL>
-<LI><A href="node3.html#SECTION000351000000000000000">2.5.1 Modifying Mutable Objects</a>
-<LI><A href="node3.html#SECTION000352000000000000000">2.5.2 Some Special Methods Don't Work</a>
-<LI><A href="node3.html#SECTION000353000000000000000">2.5.3 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></a>
+<LI><A href="node3.html#SECTION000361000000000000000">2.6.1 Modifying Mutable Objects</a>
+<LI><A href="node3.html#SECTION000362000000000000000">2.6.2 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></a>
 </ul>
-<LI><A href="node3.html#SECTION000360000000000000000">2.6 Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000370000000000000000">2.7 Writing Persistent Classes</a>
 <UL>
-<LI><A href="node3.html#SECTION000361000000000000000">2.6.1 Changing Instance Attributes</a>
+<LI><A href="node3.html#SECTION000371000000000000000">2.7.1 Changing Instance Attributes</a>
 </ul></ul>
 <!--End of Table of Child-Links-->
 </div>
@@ -98,7 +98,7 @@
 </H3>
 
 <P>
-You will need Python 2.2 or higher.  Since the code is packaged using
+You will need Python 2.3 or higher.  Since the code is packaged using
 distutils, it is simply a matter of untarring or unzipping the release
 package, and then running <code>python setup.py install</code>.
 
@@ -115,7 +115,7 @@
 
 <P>
 Download the ZODB tarball containing all the packages for both ZODB
-and ZEO from <a class="url" href="http://www.zope.org/Products/ZODB3.2">http://www.zope.org/Products/ZODB3.2</a>.  See
+and ZEO from <a class="url" href="http://www.zope.org/Products/ZODB3.3">http://www.zope.org/Products/ZODB3.3</a>.  See
 the <span class="file">README.txt</span> file in the top level of the release directory
 for details on building, testing, and installing.
 
@@ -131,12 +131,12 @@
 
 <P>
 The ZODB is conceptually simple.  Python classes subclass a 
-<tt class="class">Persistent</tt> class to become ZODB-aware. 
+<tt class="class">persistent.Persistent</tt> class to become ZODB-aware. 
 Instances of persistent objects are brought in from a permanent
 storage medium, such as a disk file, when the program needs them, and
 remain cached in RAM.  The ZODB traps modifications to objects, so
 that when a statement such as <code>obj.size = 1</code> is executed, the
-modified object is marked as ``dirty''.  On request, any dirty objects
+modified object is marked as ``dirty.''  On request, any dirty objects
 are written out to permanent storage; this is called committing a
 transaction.  Transactions can also be aborted or rolled back, which
 results in any changes being discarded, dirty objects reverting to
@@ -215,9 +215,9 @@
  storing and retrieving objects from some form of long-term storage.
  A few different types of Storage have been written, such as
  <tt class="class">FileStorage</tt>, which uses regular disk files, and
- <tt class="class">bsddb3Storage</tt>, which uses Sleepycat Software's BerkeleyDB
+ <tt class="class">BDBFullStorage</tt>, which uses Sleepycat Software's BerkeleyDB
  database.  You could write a new Storage that stored objects in a
- relational database or Metakit file, for example, if that would
+ relational database, for example, if that would
  better suit your application.  Two example storages,
  <tt class="class">DemoStorage</tt> and <tt class="class">MappingStorage</tt>, are available to use
  as models if you want to write a new Storage.
@@ -264,7 +264,51 @@
 <P>
 
 <H2><A NAME="SECTION000340000000000000000">
-2.4 Writing a Persistent Class</A>
+2.4 Using a ZODB Configuration File</A>
+</H2>
+
+<P>
+ZODB also supports configuration files written in the ZConfig format.
+A configuration file can be used to separate the configuration logic
+from the application logic.  The storages classes and the <tt class="class">DB</tt>
+class support a variety of keyword arguments; all these options can be
+specified in a config file.
+
+<P>
+The configuration file is simple.  The example in the previous section
+could use the following example:
+
+<P>
+<div class="verbatim"><pre>
+&lt;zodb&gt;
+  &lt;filestorage&gt;
+  path /tmp/test-filestorage.fs
+  &lt;/filestorage&gt;
+&lt;/zodb&gt;
+</pre></div>
+
+<P>
+The <tt class="module">ZODB.config</tt> module includes several functions for opening
+database and storages from configuration files.
+
+<P>
+<div class="verbatim"><pre>
+import ZODB.config
+
+db = ZODB.config.databaseFromURL('/tmp/test.conf')
+conn = db.open()
+</pre></div>
+
+<P>
+The ZConfig documentation, included in the ZODB3 release, explains
+the format in detail.  Each configuration file is described by a
+schema, by convention stored in a <span class="file">component.xml</span> file.  ZODB,
+ZEO, zLOG, and zdaemon all have schemas.
+
+<P>
+
+<H2><A NAME="SECTION000350000000000000000">
+2.5 Writing a Persistent Class</A>
 </H2>
 
 <P>
@@ -273,23 +317,15 @@
 
 <P>
 <div class="verbatim"><pre>
-import ZODB
-from Persistence import Persistent
+from persistent import Persistent
 
 class User(Persistent):
     pass
 </pre></div>
 
 <P>
-The apparently unnecessary <code>import ZODB</code> statement is
-needed for the following <code>from...import</code> statement to work
-correctly, since the ZODB code does some magical tricks with
-importing.
-
-<P>
-The <tt class="class">Persistent</tt> base class is an <tt class="module">ExtensionClass</tt>
-class.  As a result, it not compatible with new-style classes or types
-in Python 2.2 and up.
+The <tt class="class">Persistent</tt> base class is a new-style class implemented in
+C.
 
 <P>
 For simplicity, in the examples the <tt class="class">User</tt> class will
@@ -381,8 +417,8 @@
 
 <P>
 
-<H2><A NAME="SECTION000350000000000000000">
-2.5 Rules for Writing Persistent Classes</A>
+<H2><A NAME="SECTION000360000000000000000">
+2.6 Rules for Writing Persistent Classes</A>
 </H2>
 
 <P>
@@ -400,27 +436,28 @@
 <UL>
 <LI>If you modify a mutable object that's the value of an object's
 attribute, the ZODB can't catch that, and won't mark the object as
-dirty.  
-The solution is to either set the dirty bit yourself when you modify
-mutable objects, or use a wrapper for Python's lists and dictionaries
-(<tt class="class">PersistentList</tt>, 
+dirty.  The solution is to either set the dirty bit yourself when you
+modify mutable objects, or use a wrapper for Python's lists and
+dictionaries (<tt class="class">PersistentList</tt>,
 <tt class="class">PersistentMapping</tt>)
 that will set the dirty bit properly.
 
 <P>
 </LI>
-<LI>Certain of Python's special methods don't work when they're
-defined on ExtensionClasses.  The most important ones are the
-<tt class="method">__cmp__</tt> method, and the reversed versions of binary
-arithmetic operations: <tt class="method">__radd__</tt>, <tt class="method">__rsub__</tt>, and so
-forth.
+<LI>Recent versions of the ZODB allow writing a class with 
+<tt class="method">__setattr__</tt> , <tt class="method">__getattr__</tt>, or <tt class="method">__delattr__</tt>
+methods.  (Older versions didn't support this at all.)  If you write
+such a <tt class="method">__setattr__</tt> or <tt class="method">__delattr__</tt> method, its code
+has to set the dirty bit manually.
 
 <P>
 </LI>
-<LI>Recent versions of the ZODB allow writing a class with 
-<tt class="method">__setattr__</tt> , <tt class="method">__getattr__</tt>, or <tt class="method">__delattr__</tt> methods.  (Older versions didn't support this at all.)
-If you write such a <tt class="method">__setattr__</tt> or <tt class="method">__delattr__</tt> method, 
-its code has to set the dirty bit manually, 
+<LI>A persistent class should not have an <tt class="method">__del__</tt> method.
+The database moves objects freely between memory and storage.  If an
+object has not been used in a while, it may be released and its
+contents loaded from storage the next time it is used.  Since the
+Python interpreter is unaware of persistence, it would call the
+<tt class="method">__del__</tt> each time the object was freed.
 
 <P>
 </LI>
@@ -431,8 +468,8 @@
 
 <P>
 
-<H3><A NAME="SECTION000351000000000000000">
-2.5.1 Modifying Mutable Objects</A>
+<H3><A NAME="SECTION000361000000000000000">
+2.6.1 Modifying Mutable Objects</A>
 </H3>
 
 <P>
@@ -463,15 +500,10 @@
 <P>
 <div class="verbatim"><pre>
 userobj.friends.append(otherUser)
-userobj._p_changed = 1
+userobj._p_changed = True
 </pre></div>
 
 <P>
-An obsolete way of doing this that's still supported is calling the
-<tt class="method">__changed__()</tt> method instead, but setting <tt class="member">_p_changed</tt> 
-is the preferred way.
-
-<P>
 You can hide the implementation detail of having to mark objects as
 dirty by designing your class's API to not use direct attribute
 access; instead, you can use the Java-style approach of accessor
@@ -497,55 +529,8 @@
 
 <P>
 
-<H3><A NAME="SECTION000352000000000000000">
-2.5.2 Some Special Methods Don't Work</A>
-</H3>
-
-<P>
-Don't bother defining certain special methods on
-ExtensionClasses, because they won't work.  Most notably, the
-<tt class="method">__cmp__</tt> method on an ExtensionClass will never be called.
-Neither will the reversed versions of binary arithmetic operations,
-such as <tt class="method">__radd__</tt> and <tt class="method">__rsub__</tt>.
-
-<P>
-This is a moderately annoying limitation.  It means that the
-<tt class="class">PersistentList</tt> class can't implement comparisons with regular
-sequence objects, and therefore statements such as 
-<code>if perslist==[]</code> don't do what you expect; instead of performing the correct
-comparison, they return some arbitrary fixed result, so the <code>if</code>
-statement will always be true or always be false.  There is no good
-solution to this problem at the moment, so all you can do is design
-class interfaces that don't need to overload
-<tt class="method">__cmp__</tt> or the <tt class="method">__r*__</tt> methods.
-
-<P>
-This limitation is mostly Python's fault.  As of Python 2.1, the most
-recent version at this writing, the code which handles comparing two
-Python objects contains a hard-wired check for objects that are class
-instances, which means that <code>type(obj) == types.InstanceType</code>.
-The code inside the Python interpreter looks like this:
-
-<P>
-<div class="verbatim"><pre>
-/* Code to compare objects v and w */
-if (PyInstance_Check(v) || PyInstance_Check(w))
-        return PyInstance_DoBinOp(v, w, "__cmp__", "__rcmp__", do_cmp);
-/* Do usual Python comparison of v,w */
-c = PyObject_Compare(v, w);
-</pre></div>
-
-<P>
-While ExtensionClasses try to behave as much like regular Python
-instances as possible, they are still not instances, and
-<tt class="function">type()</tt> doesn't return the <code>InstanceType</code> object, so 
-no attempt is ever made to call <tt class="method">__cmp__</tt>.  Perhaps Python 2.2
-will repair this.
-
-<P>
-
-<H3><A NAME="SECTION000353000000000000000">
-2.5.3 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></A>
+<H3><A NAME="SECTION000362000000000000000">
+2.6.2 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></A>
 </H3>
 
 <P>
@@ -560,8 +545,8 @@
 
 <P>
 
-<H2><A NAME="SECTION000360000000000000000">
-2.6 Writing Persistent Classes</A>
+<H2><A NAME="SECTION000370000000000000000">
+2.7 Writing Persistent Classes</A>
 </H2>
 
 <P>
@@ -571,8 +556,8 @@
 
 <P>
 
-<H3><A NAME="SECTION000361000000000000000">
-2.6.1 Changing Instance Attributes</A>
+<H3><A NAME="SECTION000371000000000000000">
+2.7.1 Changing Instance Attributes</A>
 </H3>
 
 <P>
@@ -649,7 +634,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/node2.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/node2.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/node2.html	Tue Jan  6 23:11:57 2004
@@ -104,8 +104,9 @@
 The downside is that the programmer has to explicitly manage objects,
 reading an object when it's needed and writing it out to disk when the
 object is no longer required.  The ZODB manages objects for you,
-keeping them in a cache and writing them out if they haven't been 
-accessed in a while.  
+keeping them in a cache, writing them out to disk when they are
+modified, and dropping them from the cache if they haven't been used
+in a while.
 
 <P>
 
@@ -251,7 +252,7 @@
 <tt class="class">Storage</tt> interface.  Such classes handle the job of
 writing out Python objects to a physical storage medium, which can be
 a disk file (the <tt class="class">FileStorage</tt> class), a BerkeleyDB file
-(<tt class="class">BerkeleyStorage</tt>), a relational database
+(<tt class="class">BDBFullStorage</tt>), a relational database
 (<tt class="class">DCOracleStorage</tt>), or some other medium.  ZEO adds
 <tt class="class">ClientStorage</tt>, a new <tt class="class">Storage</tt> that doesn't write to
 physical media but just forwards all requests across a network to a
@@ -340,7 +341,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/index.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/index.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/index.html	Tue Jan  6 23:11:57 2004
@@ -48,8 +48,8 @@
 <h1>ZODB/ZEO Programming Guide</h1>
 <p><b><font size="+2">A.M. Kuchling</font></b></p>
 <p><span class="email">amk at amk.ca</span></p>
-<p><strong>Release 0.2</strong><br />
-<strong>1 October 2003</strong></p>
+<p><strong>Release 0.3a2</strong><br />
+<strong>6 January 2004</strong></p>
 </center>
 </div>
 
@@ -77,16 +77,16 @@
 </ul>
 <LI><A href="node3.html#SECTION000320000000000000000">2.2 How ZODB Works</a>
 <LI><A href="node3.html#SECTION000330000000000000000">2.3 Opening a ZODB</a>
-<LI><A href="node3.html#SECTION000340000000000000000">2.4 Writing a Persistent Class</a>
-<LI><A href="node3.html#SECTION000350000000000000000">2.5 Rules for Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000340000000000000000">2.4 Using a ZODB Configuration File</a>
+<LI><A href="node3.html#SECTION000350000000000000000">2.5 Writing a Persistent Class</a>
+<LI><A href="node3.html#SECTION000360000000000000000">2.6 Rules for Writing Persistent Classes</a>
 <UL>
-<LI><A href="node3.html#SECTION000351000000000000000">2.5.1 Modifying Mutable Objects</a>
-<LI><A href="node3.html#SECTION000352000000000000000">2.5.2 Some Special Methods Don't Work</a>
-<LI><A href="node3.html#SECTION000353000000000000000">2.5.3 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></a>
+<LI><A href="node3.html#SECTION000361000000000000000">2.6.1 Modifying Mutable Objects</a>
+<LI><A href="node3.html#SECTION000362000000000000000">2.6.2 <tt class="method">__getattr__</tt>, <tt class="method">__delattr__</tt>, and <tt class="method">__setattr__</tt></a>
 </ul>
-<LI><A href="node3.html#SECTION000360000000000000000">2.6 Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000370000000000000000">2.7 Writing Persistent Classes</a>
 <UL>
-<LI><A href="node3.html#SECTION000361000000000000000">2.6.1 Changing Instance Attributes</a>
+<LI><A href="node3.html#SECTION000371000000000000000">2.7.1 Changing Instance Attributes</a>
 </ul>
 </ul>
 <LI><A href="zeo.html">3 ZEO</a>
@@ -110,11 +110,12 @@
 </ul>
 <LI><A href="node6.html">5 Related Modules</a>
 <UL>
-<LI><A href="node6.html#SECTION000610000000000000000">5.1 <tt class="module">ZODB.PersistentMapping</tt></a>
-<LI><A href="node6.html#SECTION000620000000000000000">5.2 <tt class="module">ZODB.PersistentList</tt></a>
+<LI><A href="node6.html#SECTION000610000000000000000">5.1 <tt class="module">persistent.mapping.PersistentMapping</tt></a>
+<LI><A href="node6.html#SECTION000620000000000000000">5.2 <tt class="module">persistent.list.PersistentList</tt></a>
 <LI><A href="node6.html#SECTION000630000000000000000">5.3 BTrees Package</a>
 <UL>
 <LI><A href="node6.html#SECTION000631000000000000000">5.3.1 Total Ordering and Persistence</a>
+<LI><A href="node6.html#SECTION000632000000000000000">5.3.2 BTree Diagnostic Tools</a>
 </ul>
 </ul>
 <LI><A href="node7.html">A. Resources</a>
@@ -165,7 +166,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/contents.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/contents.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/contents.html	Tue Jan  6 23:11:57 2004
@@ -69,9 +69,10 @@
 <LI><A href="node3.html#SECTION000310000000000000000">2.1 Installing ZODB</a>
 <LI><A href="node3.html#SECTION000320000000000000000">2.2 How ZODB Works</a>
 <LI><A href="node3.html#SECTION000330000000000000000">2.3 Opening a ZODB</a>
-<LI><A href="node3.html#SECTION000340000000000000000">2.4 Writing a Persistent Class</a>
-<LI><A href="node3.html#SECTION000350000000000000000">2.5 Rules for Writing Persistent Classes</a>
-<LI><A href="node3.html#SECTION000360000000000000000">2.6 Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000340000000000000000">2.4 Using a ZODB Configuration File</a>
+<LI><A href="node3.html#SECTION000350000000000000000">2.5 Writing a Persistent Class</a>
+<LI><A href="node3.html#SECTION000360000000000000000">2.6 Rules for Writing Persistent Classes</a>
+<LI><A href="node3.html#SECTION000370000000000000000">2.7 Writing Persistent Classes</a>
 </ul>
 <LI><A href="zeo.html">3 ZEO</a>
 <UL>
@@ -90,8 +91,8 @@
 </ul>
 <LI><A href="node6.html">5 Related Modules</a>
 <UL>
-<LI><A href="node6.html#SECTION000610000000000000000">5.1 ZODB.PersistentMapping</a>
-<LI><A href="node6.html#SECTION000620000000000000000">5.2 ZODB.PersistentList</a>
+<LI><A href="node6.html#SECTION000610000000000000000">5.1 persistent.mapping.PersistentMapping</a>
+<LI><A href="node6.html#SECTION000620000000000000000">5.2 persistent.list.PersistentList</a>
 <LI><A href="node6.html#SECTION000630000000000000000">5.3 BTrees Package</a>
 </ul>
 <LI><A href="node7.html">A. Resources</a>
@@ -158,7 +159,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 


=== ZODB3/Doc/zodb/about.html 1.3 => 1.4 ===
--- ZODB3/Doc/zodb/about.html:1.3	Thu Oct  2 14:17:28 2003
+++ ZODB3/Doc/zodb/about.html	Tue Jan  6 23:11:57 2004
@@ -51,7 +51,7 @@
 About this document ...</A>
 </H1>
  <strong>ZODB/ZEO Programming Guide</strong>,
-1 October 2003, Release 0.2
+6 January 2004, Release 0.3a2
 <p> This document was generated using the <a
     href="http://saftsack.fs.uni-bayreuth.de/~latex2ht/">
     <strong>LaTeX</strong>2<tt>HTML</tt></a> translator.
@@ -108,7 +108,7 @@
 </div>
 </div>
 <hr />
-<span class="release-info">Release 0.2, documentation updated on 1 October 2003.</span>
+<span class="release-info">Release 0.3a2, documentation updated on 6 January 2004.</span>
 </DIV>
 <!--End of Navigation Panel-->
 




More information about the Zodb-checkins mailing list