MCL/sf/os/persistentdata: comparison persistentstorage/dbms/group/RELEASE.TXT

equal deleted inserted replaced

--1:000000000000
+:08ec8eefde2f
+Version 1.05(063)
+=================
+(Made by Mark Cawston on 23 November 2001)
+Dependencies
+Built against Hurricane Release build 00629
+Defects fixed : DON-587EA3 (Corrupted Cdbv2.dat prevents device from booting)
+Testing
+automatic F32tests run on MINT UDEB, UREL, WINS UDEB.
+Version 1.05(062)
+=================
+(Made by Mark Cawston on 23 November 2001)
+Dependencies
+Built against GT6.2 Release build 00558
+Building
+Use bldmake and abld
+Testing
+Tests modified to verify defects fixed T_BENCH, T_COMP tested on WINS UDEB and
+MISA ARM4 (Assabet) UDEB.
+Defects fixed
+Hurricane : ROS-534E69: DBMS should use CleanupArrayDeletePushL()
+Version 1.05(061)
+=================
+(Made by Mark Dowman on 26 July 2000)
+Dependencies
+Built against GT6.0 Release build 00039
+Building
+Use bldmake and abld
+Testing
+Tests modified to verify defects fixed. T_DBMS, T_DBS, T_SQL and T_TRANS passed on WINS UDEB and ARM4(BRUTUS) UDEB.
+Defects fixed
+ER6.0 : EDNATHE-4MCL2K: RDbDatabase::IsDamaged() always false after opening database.
+ER6.0 : EDNPHAR-4L4KY2: DBMS access violation when sending a fax.
+Version 1.05(060)
+=================
+(Made by Andrew Thoelke on 20 May 1999)
+For EPOC Release 5 Unicode
+MSVC++ 6.0 compatible source only release
+Dependencies
+This release has been built against Baseline 0801
+Building
+Use bldmake, etc.
+Testing
+Tests added to verify defect fixes. All tests passed on WINS UREL, WINS UDEB, ARM ROM 306
+Changes
+RDbs::Version() now reports "1.05(060)"
+DBMS stores all Unicode text columns (Text and Text16 columns) using the standard unicode compression algorithm available in STORE. This breaks the data format for all databases containing text - and to ensure that old databases cannot be loaded by this build of DBMS the internal database version numbers have been increased. All existing databases are now unreadable.
+Long columns that are not inlined but still under a certain threshold (currently 1.5K) are now extracted from the database without requiring a read-lock on the database. This allows moderate sized BLOBs to be read from a shared database while another client is updating or compacting the database.
+Defects fixed
+ER5:EDNBBAR-463J5D: Concurrent server start-up does not panic and hang the second client attempting to connect.
+ER5:EDNATHE-48AEZW: Automatic cursor recovery after row deletion is now much more capable than previously.
+ER5U:EDNATHE-497KWW: Explicitly load 16-bit values using 8-bit reads to prevent incorrect use of half-word load instructions.
+Version 1.05(058)
+=================
+(Made by Andrew Thoelke on 20 May 1999)
+EPOC Release 5u baseline component
+Dependencies
+This release was built with
+Tools: E32TOOLS 120, E32TOOLP 107
+Components: E32 185, F32 145, STORE 062
+Building
+Mostly standard EBLD syntax supported. Invoking EBLD without parameters gives usage information
+Release components
+All 4 build variants have been released.
+Testing
+No testing has been done
+Changes
+RDbs::Version() now reports "1.05(058)"
+The DATAZIP tool has been removed - it was not supported for Unicode data documents in any case
+Version 1.05(057)
+=================
+(Made by Andrew Thoelke on 15 January 1999)
+EPOC Release 5 candidate component
+Dependencies
+This release was built with
+Tools: E32TOOLS 095, E32TOOLP 098
+Components: E32 158, F32 124, STORE 051
+Binary Compatibility
+Fully binary compatible with 054-6
+Building
+Mostly standard EBLD syntax supported. Invoking EBLD without parameters gives usage information
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL + EDBSRV.EXE is 130,276 + 496 bytes (127.7K) in ROM
+To install DBMS for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+Known problems
+DATAZIP will not work on new unicode database documents, as it does not recognise the new Data App UID. This tool is likely to be migrated out of DBMS in the near future
+Testing
+Test code amended and extended to verify the defect fixes. All test code passes on all platforms.
+Changes
+RDbs::Version() now reports "1.05(057)"
+Defects Fixed
+590829: CDbTableDatabase::CheckIdle() no longer causes an access violation if the table collection is modified while it iterates across the tables.
+394751: The server panics clients in such a way as to avoid trying to complete the offending message twice, which caused a KERN-EXEC 4 in the server.
+Version 1.05(056)
+=================
+(Made by Andrew Thoelke on 5 January 1999)
+EPOC Release 5 candidate component
+Dependencies
+This release was built with
+Tools: E32TOOLS 095, E32TOOLP 098
+Components: E32 158, F32 124, STORE 051
+Binary Compatibility
+Fully binary compatible with 054-5
+Building
+Mostly standard EBLD syntax supported. Invoking EBLD without parameters gives usage information
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL + EDBSRV.EXE is 130,280 + 496 bytes (127.7K) in ROM
+To install DBMS for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+Known problems
+DATAZIP will not work on new unicode database documents, as it does not recognise the new Data App UID. This tool is likely to be migrated out of DBMS in the near future
+Testing
+Test code amended and extended to verify the defect fixes. All test code passes on all platforms.
+Changes
+RDbs::Version() now reports "1.05(056)"
+New RProcess::Create() and RLibrary::Load() functions which take a TUidType parameter are now used for launching the server and loading drivers with full UID type checking
+Defects Fixed
+632258: RDbNamedDatabase::Create() will now only delete the file on cleanup if it created the file, and not delete an existing file
+Version 1.05(055)
+=================
+(Made by Andrew Thoelke on 9 December 1998)
+EPOC Release 5 candidate component
+Dependencies
+This release was built with
+Tools: E32TOOLS 095, E32TOOLP 098
+Components: E32 156, F32 122, STORE 051
+Binary Compatibility
+Fully binary compatible with 054
+Building
+Mostly standard EBLD syntax supported. Invoking EBLD without parameters gives usage information
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL + EDBSRV.EXE is 130,288 + 496 bytes (127.7K) in ROM
+To install DBMS for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+Known problems
+DATAZIP will not work on new unicode database documents, as it does not recognise the new Data App UID. This tool is likely to be migrated out of DBMS in the near future
+Testing
+Test code amended and extended to verify the defect fixes. All test code passes on all platforms.
+Changes
+RDbs::Version() now reports "1.05(055)"
+Defects Fixed
+SW1-488	Regression from 043: deleting a row can cause an access	violation. A simple fix added and tested by T_BIG.
+Rebuilt with MSVC++ 5.0 Service Pack 3 to ensure good WINS release builds.
+Boiler-plated the source code using the SysDoc tool.
+Version 1.05(054)
+=================
+(Made by Andrew Thoelke on 16th November, 1998)
+This is an EPOC Release 5 component.
+Dependencies
+The requires EPOC Release 5 components to build and run. This release
+was built with
+Tools: E32TOOLS 095, E32TOOLP 097
+Components: E32 156, F32 122, STORE 050
+Binary Compatibility
+Backwards binary compatible with 053
+RDbNotifier::Notify() has changed names, making this release source
+incompatible, and RDbNotifer has gained a new export (see Changes).
+Building
+Mostly standard EBLD syntax supported. Invoking EBLD without parameters
+gives usage information
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL + EDBSRV.EXE is 130,280 + 496 bytes
+(127.7K) in ROM
+To install DBMS for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+For ROM building, edbsrv.exe should be marked as a FIXED process, the
+process priority has yet to be specified.
+DBMS can be successfully installed an run from C: (RAM drive) on a
+EPOC Release 5 ROM
+Known problems
+DATAZIP will not work on new unicode database documents, as it does not
+recognise the new Data App UID. This tool is likely to be migrated out
+of DBMS in the near future
+Testing
+Test code amended and extended to verify the defect fixes and changes.
+All platforms have been fully tested.
+Changes
+RDbs::Version() now reports "1.05(054)"
+The notification interface of RDbNotifer has changed:
+*	Notify() has been renamed to NotifyUnlock(), inidicating that all
+	events are reported, including "unlock" events.
+*	A new request NotifyChange() has been added which only completes
+	when a change event (all except unlock) occurs on the database.
+Note that change events occuring between notifier completion and making a
+new request will not be missed (as they are in 053), see the fix for
+SW1-334 below.
+Defects Fixed
+Defects are from EPOC Software Defects.
+SW1-320	File and Path not found errors are now returned by
+	RDbNamedDatabase::Open() when appropriate.
+SW1-326	Attempting to read Long columns can return KErrAccessDenied if
+	compaction or statistics update is in progress in the same
+	client. 053 only reported this if a different client was
+	compacting, but panic'd if it was the same client.
+SW1-334	Database "change" events which occur after a request is completed
+	are now stored by the notifier and reported immediately when the
+	next notification request is made. Only the most significant event
+	is stored, following this ordering:
+		Recover > Rollback > Commit
+	The more "significant" events have a larger impact on client views.
+Version 1.05(053)
+=================
+(Made by Andrew Thoelke on 28th October, 1998)
+This is a beta EPOC Release 5 component.
+Dependencies
+The requires EPOC Release 5 compatibility components to build and run
+Tools: E32TOOLS 095, E32TOOLP 096
+Components: E32 156, F32 122, STORE 050
+Binary Compatibility
+Only WINS REL, MARM REL and MARM DEB releases are fully binary compatible
+with 052
+WINS DEB is now BC with WINS REL
+WINS UREL is BC with WINS UDEB
+MARM UREL is BC with MARM UDEB
+Building
+Mostly standard EBLD syntax supported. Invoking EBLD without parameters
+gives usage information
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL + EDBSRV.EXE is 130,020 + 496 bytes
+(127.5K) in ROM
+To install DBMS for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+For ROM building, edbsrv.exe should be marked as a FIXED process, the
+process priority has yet to be specified.
+DBMS can be successfully installed an run from C: (RAM drive) on a
+EPOC Release 4 ROM
+Known problems
+DATAZIP will not work on new unicode database documents, as it does not
+recognise the new Data App UID at the moment. This will be remedied once
+the new unicode Data app UID is available.
+Testing
+All platforms have been fully tested.
+Changes
+1.	RDbs::Version() now reports "1.05(053)"
+2.	New UIDs allocated for Unicode:
+		0x10003B0E: Unicode EDBMS.DLL
+		0x10003B0F: KDbmsDriverUid16
+Version 1.05(052)
+=================
+(Made by Andrew Thoelke on 13th October, 1998)
+This is a beta EPOC Release 5 component.
+Dependencies
+This component requires at least EPOC Release 4 in order to be built and
+run.
+Components required: E32 144, F32 115, STORE 049
+Tools: E32TOOLS 095, E32TOOLP 093
+Binary Compatibility
+This release is fully backwards binary compatible with DBMS 051.
+However, internal changes mean that different versions of DBMS 050+ in ROM
+and RAM can cause problems.
+DBMS 052 adds three more exports to the client interface, to support
+enquiry of database properties such as size and usage.
+Building
+WINS components were built using MSVC++ 5.0, hence the debugging databases
+are incompatible with previous versions of MSDev.
+Command-line building now uses the "EBLD" syntax. Invoking EBLD from the
+GROUP sub-project will provide usage information. All MNT verbs which
+could previously be used for building have been removed.
+EBLD TOOL ... is used to build the tools
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL + EDBSRV.EXE is 130,020 + 496 bytes
+(127.5K) in ROM
+To install DBMS 052 for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+For ROM building, edbsrv.exe should be marked as a FIXED process, the
+process priority has yet to be specified.
+DBMS 052 can be successfully installed an run from C: (RAM drive) on a
+EPOC Release 4 ROM
+Testing
+All platforms have been fully tested.
+A new SQL-script test program has been added, and further SQL scripts are
+planned to validate the query analysis and evaluation engine.
+Changes
+1.	RDbs::Version() now reports "1.05(052)"
+2.	To complement database compaction, a query function which returns
+	the database size and usage has been added: RDbDatabase::Size().
+	This returns a structure containing the database size (in bytes)
+	and the usage (in percent). A value <0 indiciates an inability to
+	evaluate the property, this may be because the database does not
+	support the query (such as RDbStoreDatabase), or because the value
+	is not immediately available. For hard-to-compute values (like
+	usage) this function will return a cached value, these "stats" can
+	be updated by calling RDbDatabase::UpdateStats() (which may be
+	long-running) or using the incremental version
+	RDbIncremental::UpdateStats(TInt&).
+3.	RDbNotifier's can now also be opened on a client-side database:
+	attempting this operation with build 050 or 051 panic'd. The
+	current implementation only supports a single notifier for a
+	client-side database, but continues to support any number of
+	notifiers opened on a client-server database.
+4.	SQL Query optimisation has arrived. No longer is there only one
+	way to evaluate a query, DBMS 052 will now make use of indexes to
+	optimise query evaluation. The implications for database design
+	(what to index) and access (undefined behaviour) are significant.
+4.1.	Indexes may be used to evaluate the WHERE clause, the ORDER BY
+	clause, or both. Pre DBMS 051 the exact method of evaluating a
+	query was well defined, and could be relied on: e.g. an ORDER BY
+	clause had to be evluated with an index, and WHERE clause was done
+	on-the-fly; the TDbWindow paramater to RDbView::Prepare() was
+	followed precisely. This can no longer be relied on in the
+	presence of indexes.
+4.2.	If a window is requested, the rowset is guaranteed to use one: but
+	a window'd View may be provided for a request which did not
+	specify one, because that may be the only (or best) way to
+	evaluate the query. This implies that Views must be Evaluate()'d
+	after preparation, and they may behave differently if this or
+	another view updates the underlying table.
+4.3.	An ORDER BY clause may be evaluated without an index (even if an
+	appropriate one is available), in which case none of the rows will
+	appear in the view until they have all been evaluated. So the "get
+	results as they come in" approach used in the Data application
+	will not look as cool--however, the results might appear 10 times
+	faster to make up for this.
+4.4.	Table rowsets continue to have the same behaviour as before.
+5.	The server, DBMS drivers and open tables are now held in a expiry
+	cache when they are no longer "in use", and discarded after a
+	short time if not re-used. This significantly improves performance
+	in situations where these objects are repeatedly opened and closed.
+6.	Cluster caching is now dynamically increased when it would benefit
+	access performance.
+7.	RDbRowSet::CountL() and RDbRowSet::FindL() are implemented one
+	layer "deeper" allowing the server implementation to improve their
+	performance by an order of magnitude.
+8.	All references to "Library" and "ISAM" are now "Driver". DBMS
+	driver extensions will have the extension .dbx.
+Defects fixed
+Defect numbers refer to the EPOC Software Defects database
+SW1-183: Null columns do not always return zero values (as spec'd by the
+	SDK). The row buffer code has been adapted to do the right thing
+	for all null columns. Test code amended to verify this in the
+	"problem" cases.
+SW1-225: An emulator-only defect where the server thread was being
+	cleaned up by the OS because of incorrect ownership. Test code
+	amended to verify this fix.
+*	It was possible to set up a database state combining a transaction
+	and long column access, that caused STORE to panic on rollback:
+	this was not ideal for client-side access, but deadly for
+	client-server access as it killed the server. The transaction
+	locking system has now added transient read-locks for long column
+	access to prevent this state. However, this may now cause a
+	RDbColReadStream::Open() call to fail with "KErrLocked" if
+	another client holds an exclusive lock on the database (e.g. they
+	are updating a table, or compacting...). This can be handled
+	earlier by using a transaction to enclose the read, in which case
+	Begin() may fail with KErrLocked.
+Version 1.03.051
+================
+(Made by AjThoelke, 28 August 1998)
+This is an alpha EPOC Release 5 component.
+Dependencies
+This component ideally requires at least EPOC Release 4 in order to be built
+and run.
+Components required: E32 143, F32 115, STORE 049
+Tools: E32TOOLS 094, E32TOOLP 093
+Binary Compatibility
+This release is fully backwards binary compatible with DBMS 043
+This release is backwards source compatible with DBMS 050
+DBMS now has the full E5 API, having now added support for data modification
+SQL statements. Hopefully this API will not be changed in future E5 releases.
+The SQL execution has changed from 050, although the new API remains source
+(but not binary) compatible,.
+Building
+Binaries: From the BMAKE sub-project invoke the BLD batch file
+Tools: From the TOOLS sub-project invoke the BLD batch file
+Release components
+All 8 build variants have been released.
+MARM ASCII release build EDBMS.DLL is 120,732 bytes (117.9K) in ROM
+To install DBMS 051 for MARM:
+	edbms.dll : install to \System\Libs\
+	edbsrv.exe: install to \System\Programs\
+For ROM building, edbsrv.exe should be marked as a FIXED process, the process
+priority has yet to be specified.
+DBMS 051 can be successfully installed an run from C: on a EPOC Release 4 ROM
+Testing
+All platforms have been fully tested.
+Note that some of the new functionality requires new test code to be written
+to ensure it's correctness--this work is planned for the next release.
+Defects fixed
+Defect numbers refer to the EPOC Software Defects database
+*	SW1-65: DBMS 051 should be MSVC 5.0 friendly
+*	SW1-71: Function renamed to RDbs::ResourceCount()
+*	SW1-173: LIKE '*?a?*' could fail to match rows that it should, this has
+	been remedied
+*	Faulting previously correct SQL due to the additon of reserved keywords
+	is not really backwards compatible, and this restriction is now lifted.
+	Tables,	indexes and columns can be named after SQL keywords. This is not,
+	however, recommended if you want to remain forwards compatible with 043.
+*	SQL create-table-statements could contain invalid data types and cause
+	unexpected things to happen: e.g. "UNSIGNED BINARY" was not flagged as
+	an error.
+*	If the last record in a partially evaluated view was deleted and further
+	evaluation generated more rows, the cursor put itself into an
+	inconsistent state, often resulting in a panic. This situation is now
+	detected and dealt with correctly.
+Changes and additions
+A full explanation of the API changes can be found in "r:\dbms\dsdk\api.doc",
+and the SQL grammar is described in "r:\dbms\dsdk\sql.doc".
+*	ORDER BY clauses in RDbView queries can now be evaluated without
+	requiring the support of an index (hooray!). In fact, it is now
+	recommended that you do _not_ create indexes for the sole purpose of
+	evaluating an ORDER BY clause: they are slower and bigger, particularly
+	for text keys. More detail on those issues in the next release...
+*	RDbDatabase::Execute() now supports DML as well as DDL statements.
+	(see api.doc and sql.doc for details)
+*	Added class RDbUpdate to incrementally execute data modification SQL
+	statements. (see api.doc)
+*	Started caching tables which have been opened, but are no longer used
+	by any cursor, until the current transaction completes. This
+	particularly improves performance of multiple SQL insert-statements
+	run inside a transaction, as well as removing a nearly-silent-failure
+	mode from the transaction system.
+*	Major reworking of the SQL engine involving:
+*	Rewrite of the lexer, removing most dependencies on TLex and TChar
+	for performance reasons. TChar functions are only used for non-ASCII
+	characters encountered in identifiers or spaces. TLex is only used
+	for lexing floating point numbers. Keyword identification now uses a
+	case-insensitive comparison, rather than folding.
+*	Literal values are managed and converted by a single class
+*	Added support for DML statements to the parser
+*	Access plan generation has been moved into a new class, in preparation
+	for query optimization in the next release.
+Version 1.02.050
+================
+(Made by AjThoelke, 7 May 1998)
+Binary Compatibility
+This release is fully backwards binary compatible with DBMS 043.
+The new API in this release of DBMS is NOT frozen at present, and it has
+beta status. It is liable to be changed in incompatible ways in the next
+release.
+Additionally, some of the functionality in 043 has been enhanced, so code
+which relies on the new behaviour will fail when used with 043.
+Build
+E32 release 126, for debug/release compatibility and Security framework
+F32 release 095
+STORE release 048, for RSecureStorePagePool and assertion fix
+E32TOOLS 089
+ARM narrow release size is 111,364 bytes (108.8K), as reported from ROMBUILD.
+*	Reorganised the source code, SQL classes are now in sub-project USQL
+*	Added two new source directories for the DBMS server: SDBMS contains all
+	classes which are built into EDBMS.DLL, SEXE contains the code for the
+	server process MARM executable.
+Release
+*	All MARM binaries have been validated
+*	All test code has been run against compatible platforms
+*	The build number has been bumped just in case a small incremental release
+	based on 043 is required for EPOC release 4 (e.g. for a bug fix). 050 is
+	not ready for platform release.
+*	MARM now releases an executable as well as a DLL. EDBSRV.EXE should go
+	in \system\programs and is required if and only if client/server DBMS is
+	used. WINS does not have any additional objects
+Defects fixed
+*	Obscure "phantom row" defect, discovered during code review.
+	If a row is deleted through rowset A, and then rowset B deletes what would
+	be the next record for rowset A; then NextL() on rowset A would fail to
+	move to the next record after that, resulting in a KErrNotFound error on
+	a subsequent GetL() on rowset A. NextL() now checks for this state and
+	navigates correctly
+*	LIKE '?' fails to match a text column containing a single character.
+	Certain patterns in an SQL like-predicate failed to match when they
+	should. The patterns which would failed are characterised by ending in
+	one or more '?' followed by zero or more '*', as long as the '?'s were
+	not preceeded by a regular character. e.g.
+		'?' would not match any single character string
+		'?*' would only match strings of length >=2 rather than	>=1
+Changes and additions
+These release notes contain just the highlights of the changes made to DBMS.
+The document "r:\dbms\dsdk\api.doc" provides more detail on the new API	and
+behaviour of shared databases.
+*	RDbs is the client session handle for sharing databases through the DBMS
+	server. It provides resource checking and heap failure tools
+*	RDbNamedDatabase provide the generic mechanism for instantiating a
+	database, by providing a name and a format-spec. Databases can be opened
+	client-side for exclusive write access or shared read-only access, or
+	through the DBMS server for shared write access.
+*	RDbNotifier provides change notification for shared databases. They can
+	only be opened on a database which has been opened using the DBMS server
+*	RDbDatabase::Begin() now returns a TInt error code. For client databases
+	this is garaunteed to be KErrNone (thus ensuring B.C.), but a client-server
+	database may return KErrLocked if another client has locked the database
+*	A single transaction can share DDL operations and DML operations. Any
+	affected rowsets which are open when a DDL operation is begun will be
+	invalidated, and if the DDL operation is rolled back all rowsets are
+	invalidated. In this state, most operations on the rowset result in a
+	KErrDisconnected error, and the rowset has to be Close()'d--it cannot
+	be Reset()
+*	RDbDatabase::Compact() and RDbIncremental::Compact() provide a way to
+	compact a database. This can be used for RDbStoreDatabase's as an
+	alternative	to the compaction functions available on CStreamStore. These
+	will fail if anyone has an outstanding transaction (including the caller)
+*	RDbDatabase::Execute() and RDbIncrmental::Execute() can execute DDL SQL
+	statements. See	"r:\dbms\dsdk\sql.doc" for the SQL syntax of these
+	statements.
+	*** If your databases contain tables, indexes or columns which use an SQL
+	keyword for their name: then any SQL passed to DBMS 050, including
+	RDbView::Prepare(), can fail with KErrArgument. The list SQL reserved
+	words is also in the document.
+*	Relaxed	constraints on getting and setting integral columns on a rowset
+	and also for specifying integral key values in a TDbSeekKey. These are
+	primarily provided to ease the implementation of non-C++ interfaces to
+	DBMS, note that utilising the new functionality will panic'd on DBMS 043.
+Test code
+*	Revised the current test code to use and test the new API for database
+	instantiation and DDL SQL, and also to test dynamic binding of the DBMS
+	driver library
+*	Added a new test program to test database sharing
+Version 1.02.043
+================
+(Made by AjThoelke, 30 March 1998)
+Binary Compatibility
+This release is fully backwards and forwards binary compatible with DBMS 042.
+Build
+E32 release 125, for debug/release compatibility and Security framework
+F32 release 095
+STORE release 047, for RSecureStorePagePool
+E32TOOLS 089
+ARM narrow release size is 81964 bytes (80.0K), as reported from ROMBUILD.
+Fixed
+1.	The compressor could generate an invalid compressed database due to
+	faulty analysis of the database data. The data written is subtly
+	different to the original database, so analysis for the encoding should
+	take place on the data that is written, not on the data that is read:
+	which is what DBMS 042 was doing.
+	This has been fixed: compression is now a little slower, and DBMS is
+	.5K smaller.
+Version 1.02.042
+================
+(Made by AjThoelke, 18 March 1998)
+Binary Compatibility
+With the exception of compressed databases, this release is fully backwards and
+forwards binary compatible with DBMS 041.
+The compression format has changed slightly, resulting in a data incompatibility
+for compressed databases between 041 and 042. You must use DBMS 042 to compress
+databases for use with this release.
+Build
+E32 release 125, for debug/release compatibility and Security framework
+F32 release 095
+STORE release 047, for RSecureStorePagePool
+E32TOOLS 089
+ARM narrow release size is 82448 bytes (80.5K), as reported from ROMBUILD.
+Changes
+1.	The compression format has been changed to provide a larger look-back
+	for better compression of long streams; and now uses a stream terminator
+	resulting in faster decompression code.
+Version 1.02.041
+================
+(Made by AjThoelke, 13 March 1998)
+Binary Compatibility
+Fully backwards and forwards binary compatible with DBMS 040
+Build
+E32 release 125, for debug/release compatibility and Security framework
+F32 release 095
+STORE release 047, for RSecureStorePagePool
+E32TOOLS 089
+ARM narrow release size is 82524 bytes (80.6K), as reported from ROMBUILD.
+Fixed
+1.	Compression failed for databases which had no LongText or LongBinary
+	data. The huffman code generator could not cope with a no-data
+	situation. This has been fixed so that non-encodings are supported.
+2.	Some code slipped out of 040 which ensures that enforces the read-only
+	nature of a compressed database. Otherwise the database could be
+	modified and left in a corrupt and unreadable state.
+3.	Reduced the memory requirements for compression by a factor of 4 or
+	more for databases with large streams.
+Version 1.02.040
+================
+(Made by AjThoelke, 6 March 1998)
+Binary Compatibility
+Fully backwards binary compatible with DBMS 039
+Forwards compatible with 039 if you do not use either of the two new exports:
+	RDbStoreDatabase::CompressL(CStreamStore&,TStreamId);
+	RDbStoreDatabase::DecompressL(CStreamStore&,TStreamId);
+in d32dbms.h. (See below)
+Build
+E32 release 125, for debug/release compatibility and Security framework
+F32 release 095
+STORE release 047, for RSecureStorePagePool
+E32TOOLS 089
+ARM narrow release size is 82384 bytes (80.5K), as reported from ROMBUILD.
+Fixed
+1.	Writing to a LongText column using the WriteL(RReadStream&,TInt)
+	overload can result in an incorrect column size being stored in the row.
+	This defect has only been introduced in 039, and was not present before
+	that release.
+	This has been fixed, and test code has been changed to test the
+	behaviour of stream-to-stream writing to LongText columns.
+New stuff
+1.	Provided primarily to support compression of help files in ROM...
+	Store databases can be compressed[1]. These new static functions of
+	RDbStoreDatabase
+	CompressL(CStreamStore&,TStreamId)
+	DecompressL(CStreamStore&,TStreamId)
+	convert a (non-encrypted) database from normal to compressed form and
+	back again.
+	These functions operate synchronously, and can take an extended time to
+	complete[2]. On return the database is not open, and the store file
+	should be CompactL()'d and CommitL()'d after compression or
+	decompression is successful. If they fail, the database will be in its
+	previous state, i.e. the database is still good.
+	Index data cannot be compressed (unfortunately).
+	Once compressed the database is read-only, but otherwise operates as
+	normal: the data is decompressed on the fly as required.
+	I have included the compression code on MARM (4.5K of ROM) as this
+	might prove useful, although it is less aggressive when compressing
+	than the WINS/WINC code. The resulting database is about 7% larger
+	but takes half the time to compress. Compression requires quite a bit of
+	memory.
+	[1] Test on help files show compression ratios between 2.5:1 and 4:1
+	[2] e.g. the Series5 help file (343K) takes 10 seconds to compress on
+	an E32 125 ROM.
+2.	A new releasable TOOLS contains a WINC\REL executable DataZip.exe which
+	can compress a Data Document (including help files). This has the same
+	EPOC dependencies as DBMS 040 (of course).
+	To run this program you need to have E32 WINC 125+, F32 WINC 095+, STORE
+	WINS 047+, DBMS WINS 040+ and DataZip all in the same directory. The
+	source and target file names for the program must be specified in full
+	due to a limitation of WINC at present
+Version 1.02.039
+================
+(Made by AjThoelke, 19 February 1998)
+Binary Compatibility
+Only the client API (d32dbms.h) in MARM REL, WINS REL and WINS DEB builds
+remains binary compatible with DBMS 038.
+*	This is the first release to support unicode properly, in particular,
+	the unicode releases are not BC with the 038 pre-release.
+*	MARM Debug builds have broken BC in order to become BC with the
+	release build, enabling debug/release component mix'n'match.
+*	In order to enable client-server and future extensions to DBMS, the
+	implementors' interface has been thoroughly broken. This interface is
+	described by d32dbas.h, d32rec.h and d32table.h; it has never been
+	documented and will no longer be supported by DBMS. These header files
+	have been withdrawn until Akula completes its changes to this API.
+*	The client interface, described by d32dbms.h, is completely backwards
+	binary compatible with 038, adding some new functionality in the shape
+	of secure databases (see below).
+If you are building a release/debug compatible component you must use at least
+E32 125, F32 95, STORE 047 and DBMS 039.
+Build
+E32 release 125, for debug/release compatibility and Security framework
+F32 release 095
+STORE release 047, for RSecureStorePagePool
+E32TOOLS 089
+ARM narrow release size is 75920 bytes (74.1K), as reported from ROMBUILD.
+MAKMAKE is now used throughout DBMS. The new BMAKE directory contains the batch
+file (bld.bat), makefiles and mmp files to build DBMS. BWINS and BMARM now just
+contain the export definitions files.
+DBMS can still be built using the mnt verbs, or by invoking BLD in the BMAKE
+directory. Invoking BLD without parameters gives the basic syntax used.
+Test code is built either in each test code sub-project using bld.bat or the
+makefile, or using mnt.cmd from the group as before to build all test code.
+Fixed
+1.	SW1-792: Following DeleteL() on a filtered rowset, the cursor now
+	correctly determines the NextL() row in the set.
+2.	Loopholes in the LongText column streaming code allowed clever, but
+	incorrect, things to be done with text-only columns (such as embedded
+	stores etc.). These columns might now be encrypted, and so do not
+	support seeking or combined read and write: so this condition is
+	asserted. LongText streams should only ever stream text in or out,
+	LongBinary columns must be used for embedding stores.
+3.	An SQL view which had a comparison operator on a long unicode column
+	could be evaluated incorrectly due to a /2 error in a length
+	calculation. This has been fixed.
+4.	The SQL parser could fail in new ways in Unicode (such as OOM) when
+	parsing numeric values. The parser was re-engineered to correctly report
+	the real error code, instead of reporting a generic error
+	(KErrArgument).
+5.	RDbTable::SeekL(), when looking up a unicode column key would not use
+	the whole key value given (another divide-by-2 error). Fixed.
+Changes and additions
+1.	Unicode is here (properly this time). Test code has been modified to run
+	in unicode builds. Missing LongText16 functionality has been
+	implemented, and a couple of unicode column flaws have been fixed.
+2.	LongText16 columns could not be used in LIKE predicates in SQL. The
+	required classes and code has been implemented to match the 8-bit code.
+3.	Long column optimizations have been overhauled to allow many more than
+	previously (the limit has been rasied from 32 to 504, if there are no
+	other columns). To reduce memory consumption when large numbers of long
+	columns are used, the row buffer is now sized dynamically; are whereas
+	the RDbRowSet::SetColL() members may have left with KErrTooBig, they can
+	now fail with KErrNoMemory if the buffer cannot be expanded. Overall
+	this may reduce the memory requirements for using DBMS.
+4.	AlterTable() has some added powers. As long as the respective columns
+	are not indexed, it now possible to increase the maximum length of
+	Text8, Text16 and Binary columns--up to their maximum of 255 bytes--or
+	to change such a column into its respective long type. The reverse is
+	not allowed (shortening a Text column or changing LongText->Text).
+	Changing the maximum length of a column in a StoreDatabase does not
+	require the table to be	re-written, and so is a quick operation.
+	Changing the column type does require the entire table to be re-written
+	and so can take an extended time to complete.
+5.	Encrypted databases are also now available (thanks to an addition to the
+	security framework in the Base). The database is encrypted by a key it
+	generates itself, access to this key is protected by encryption and
+	decryption keys provided by clients. This allows a client to change the
+	user password (for example) without requiring the entire database to be
+	re-encrypted. For this reason it is not possible to turn a secure
+	database into a plain-text database and vice-versa: this can only be
+	done by copying the data from one database to another. It is worth noting
+	that encrypting a database does have an impact on performance.
+	The three new API functions:
+	RDbStoreDatabase::CreateL(CStreamStore*,CSecurityEncryptBase*)
+	This creates a secure version of the store database. It cannot be read
+	using DBMS 038 or earlier (it will fail with KErrNotSupported). The
+	second parameter is an encryption object (such as returned from
+	CSecurityBase::NewEncryptL) which is used to create authentication
+	data in the database. The key object is deleted by this function.
+	A matching CSecurityDecryptBase object (i.e. same key, same algorithm)
+	must be provided to allow access to the database at any later stage.
+	RDbStoreDatabase::OpenL(CStreamStore*,TStreamId,CSecurityDecryptBase*)
+	This is the secure version of opening a store database. The supplied
+	decryption key will be authenticated first before the database is
+	opened. It should match the Encryption key used to create the database,
+	or the last security change. The key object is deleted by this function.
+	If the key fails to access the database this fails with KErrGeneral.
+	If the database is not encrypted this fails with KErrArgument.
+	If the database is encrypted using an unknown algorithm this fails with
+	KErrNotSupported.
+	RDbDatabase::ChangeSecurity(CSecurityDecryptBase*,CSecurityEncryptBase*)
+	This is used to change the access key for the database. The first
+	parameter is the current decryption key, which is authenticated (just as
+	for opening a database); the second parameter is the new encryption key,
+	used to re-encrypt the authentication data. Both keys are deleted by
+	this function.
+	If the database is not encrypted this fails with KErrArgument.
+	If the key fails to access the database this fails with KErrGeneral.
+6.	Cluster (records) caching has been changed to provide caching for
+	multiple record-clusters, paving the way for more efficient multiple
+	client access.
+7.	Internal column sets are now crossed indexed by name, making table
+	creation and alteration, and view preparation faster when tha table has
+	a large number of columns. Creating tables up the the record limits is
+	quite acceptably fast now.
+8.	Took the opportunity presented by losing back-end API compatibility to
+	rectify one or two design flaws in the implementation classes, and begin
+	the work on turning it into a dynamically loaded generic-database
+	framework.
+Version 1.01.038
+================
+(Made by AjThoelke, 16 October 1997)
+1.	Built using Platform 001 releases of E32, F32 and STORE; used E32TOOLS/067
+	Only debug binaries have been modified by this release.
+	Size of EDBMS.DLL
+	WINS ASCII Release      66,560 bytes (65.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,748 bytes (67.1K)	(ROMBUILD)
+	MARM ASCII Debug        82,076 bytes (80.2K)	(ROMBUILD)
+2.	Fixed SW1-393 as described. Change T_INDEX to check the assertion.
+Version 1.00.037
+================
+(Made by Geert, 2 June 1997)
+1.	Built using Platform 001 releases of E32, F32 and STORE; used E32TOOLS/067
+	Size of EDBMS.DLL
+	WINS ASCII Release      66,560 bytes (65.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,748 bytes (67.1K)	(ROMBUILD)
+	MARM ASCII Debug        82,076 bytes (80.2K)	(ROMBUILD)
+2.	Fixed SW3-1060 as described.
+Version 1.00.036
+================
+(Made by AjThoelke, 28 May 1997)
+1.	Built using Platform 001 releases of E32, F32 and STORE; used E32TOOLS/067
+	Size of EDBMS.DLL
+	WINS ASCII Release      66,560 bytes (65.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,732 bytes (67.1K)	(ROMBUILD)
+	MARM ASCII Debug        82,060 bytes (80.1K)	(ROMBUILD)
+2.	Fixed MNT VALID: needed -e32 in pediff command line.
+Version 1.00.035
+================
+(Made by AjThoelke, 19 May 1997)
+Build
+	Built using Platform releases of E32, F32 and STORE; used E32TOOLS/066
+	Size of EDBMS.DLL
+	WINS ASCII Release      66,560 bytes (65.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,732 bytes (67.1K)	(ROMBUILD)
+	MARM ASCII Debug        82,060 bytes (80.1K)	(ROMBUILD)
+Binary Compatibility
+	Fully binary compatible with Platform release 034.
+	Four reserved virtual functions on the CDbDatabase and CDbCursor classes
+	defined in d32dbas.h were incorrectly declared as public. These now have
+	private access. The only real changes required to the releasables was new
+	WINS import libraries.
+	Nobody should have got anywhere near calling these exports, but they
+	have been made private to protect against anyone doing so "by accident".
+	You should not be building against this release: use the platform
+	version 034.
+Changes
+1.	Removed Name builds from the BWINS project make file.
+2.	Added map files to MARM releaseables
+Differences from 034:
+Version 0.06.034
+================
+(Made by AjThoelke, 17 April 1997)
+1.	Uses E32/098, F32/068, STORE/042, E32TOOLS/063
+	Binary compatible with 033.
+	File compatible with 033.
+	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      66,560 bytes (65.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,732 bytes (67.1K)	(ROMBUILD)
+	MARM ASCII Debug        82,060 bytes (80.1K)
+2.	New Uid scheme adopted for MARM releasables. For MARM, requires
+	E32 098 for anything other than narrow release.
+3.	Fixed SW-3494. Calling RDbRowSet::Cancel() before the database had
+	actually been modified when in a real transaction left the transaction
+	machinery in an invalid state. This has been cured.
+Version 0.06.033
+================
+(Made by AjThoelke, 11 April 1997)
+1.	Uses E32/097, F32/067, STORE/041, E32TOOLS/060
+2.	Binary incompatible with 032.
+	File compatible with 032.
+3.	Build (ROM) sizes for EDBMS[D].DLL
+	WINS ASCII Release      66,560 bytes (65.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,728 bytes (67.1K)	(ROMBUILD)
+	MARM ASCII Debug        82,056 bytes (80.1K)
+4.	Full Binary compatibility review complete. API is now frozen.
+	Adjusted exports to provide a full implementation API, for potential
+	other implementations of the client API.
+	Added some reserved virtual space onto the DBMS implementation framework
+	for future development.
+Version 0.06.032
+================
+(Made by AjThoelke, 10 April 1997)
+1.	Uses E32/096, F32/066, STORE/040, E32TOOLS/060
+2.	Binary compatible with 031. File compatible with 031.
+3.	Build (ROM) sizes for EDBMS[D].DLL
+	WINS ASCII Release      66,048 bytes (64.5K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,580 bytes (66.9K)	(ROMBUILD)
+	MARM ASCII Debug        81,824 bytes (79.9K)
+4.	Fixed a bug when evaluating unrestricted views (no WHERE clause): a
+	single evaluation step was doing full evaulation, rather than a bite-
+	size chunk.
+5.	MARM releasables are now pre-PETRAN'd. Obey file uids are history.
+Version 0.05.031
+================
+(Made by AjT, 21 February 1997)
+1.	Uses E32/089, F32/055, STORE/036, E32TOOLS/051
+2.	Binary compatible with 030. File compatible with 030.
+3.	Build (ROM) sizes for EDBMS[D].DLL
+	WINS ASCII Release      66,048 bytes (64.5K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,584 bytes (66.9K)
+	MARM ASCII Debug        81,832 bytes (79.9K)
+4.	API tweaklet. TDbSeekKey::Add() members now return a reference to
+	the seek key, to assist in construction of multi-column keys. This
+	is similar to the CDbColSet::AddL() and CDbKey::AddL() functions.
+	e.g.
+	TDbSeekMultiKey<3> key;
+	key.Add(value1).Add(_L("value2")).Add(value3);
+	table.SeekL(key);
+	This change does not affect binary compatibility.
+Version 0.05.030
+================
+(Made by AjT, 3 February 1997)
+1.	Uses E32/086, F32/050, STORE/035, E32TOOLS/051
+2.	Binary compatible with 029.
+	This is the B5 release.
+3.	Build (ROM) sizes for EDBMS[D].DLL
+	WINS ASCII Release      66,048 bytes (64.5K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,520 bytes (67.0K)
+	MARM ASCII Debug        81,768 bytes (79.9K)
+4.	API tweaklet. In the process of documentation, I discovered that two
+	inline functions on RDbRowSet, Beginning() and End() can leave if
+	the rowset was specified to have insert-only access. I have put an
+	L onto the end of these inline functions, which will not break any
+	binary compatibility, but might affect program logic.
+	If the rowset is read-only or updatable (the default) then these
+	functions are guaranteed not to leave.
+4.	Fixed a bug in RDbRowSet::DeleteL(). It was not reporting any errors,
+	even when there was one. Error propagation has been reinstated.
+5.	Fixed two bugs to do with synchronising mutliple rowsets during
+	concurrent updates to the same table.
+Version 0.05.029
+================
+(Made by AjT, 21st January 1997)
+1.	Uses E32/085, F32/049, STORE/033, E32TOOLS/050
+2.	Binary incompatible with any predecessor.
+3.	Build (ROM) sizes for EDBMS[D].DLL
+	WINS ASCII Release      66,048 bytes (64.5K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,448 bytes (66.8K)
+	MARM ASCII Debug        81,628 bytes (79.7K)
+4.	The code for parsing text into TTime has been passed on to the base,
+	knocking 3.5K off the DLL.
+5.	Fixed an SQL bug: Strings in SQL could not have embedded quote
+	characters (').	This can now be done by using two adjacent quote
+	characters.
+Version 0.04.028
+================
+(Made by AjT, 4th December 1996)
+1.	Uses E32/076, F32/042, STORE/031, E32TOOLS/048
+2.	Minor version number set to 4. This is the B4 release
+3.	Binary incompatible with any predecessor.
+	File compatibility has been completely broken again. This should be the
+	last time.
+4.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      68,096 bytes (66.5K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      71,268 bytes (69.6K)
+	MARM ASCII Debug        84,608 bytes (82.6K)
+5.	The embedded class RDbRowSet::RConstraint has been unembedded, and is now
+	RDbRowConstraint, it's behaviour is unchanged.
+6.	The class RDbDatabase::RIncremental and its derived classes have been
+	turned into a single unembedded class RDbIncremental. Instead of
+	constructing the class required for the operation (RDbDatabase::RCreateIndex
+	for example) and then invoking the Open() member, you now construct an
+	instance of RDbIncremental, and invoke the required member (CreateIndex()
+	for the above operation). Otherwise the behaviour of incremental operations
+	is unchanged.
+7.	RDbRowSet::ColSet() has been dropped, only the leaving version ColSetL()
+	remains.
+8.	A const KDbUnlimitedWindow has been introduced, this is a TDbWindow
+	constructed to represent an unlimited window.
+9.	RDbDatabase::IsDamaged() and RDbDatabase::InTransaction() are now const
+	members
+10.	The test to date/time conversion has been temporarily adopted by DBMS.
+	search-conditions in WHERE clauses for view preparation, or row
+	constraints can now contain comparisons with DateTime columns. The literal
+	date should be specified by enclosing it in '#'s, e.g.
+	SELECT * FROM EMPLOYEES WHERE START_DATE >= #1 Jan 1996#
+11.	DBMS RXxx objects previously would automatically close if opened/prepared
+	before being explicitly closed. This functionality has been removed: DBMS
+	handles now behave like F32 handles.
+12.	All KErrDoesNotExist errors have been replaced by KErrNotFound
+13.	Attempting to use a database/rowset between a failure and a transaction
+	Rollback (or rowset Cancel) now results in the error KErrDied (previously
+	was KErrAbort).
+14.	Some verification now takes place as clusters and records are loaded to
+	ensure that they have not been corrupted externally. These checks now
+	result in KErrCorrupt errors, as opposed to ASSERTion panics, or memory
+	overwrites (in release mode).
+Version 0.01.027
+================
+(Made by AjT, 25th November 1996)
+1.	Uses E32/074, F32/040, STORE/029, E32TOOLS/046
+2.	Binary compatible 026. Totally file compatible too.
+	Bugs in F32 040 (and 041) may cause incorrect behaviour.
+3.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      65,536 bytes (64.0K)
+	WINS ASCII Debug        -
+	MARM ASCII Release      68,012 bytes (66.4K)
+	MARM ASCII Debug        80,116 bytes (78.2K)
+4.	Fixed:
+	Insert/SetColL/Cancel/InsertCopy resulted in the row data from the
+	cancelled insertion being in the row buffer following the call to
+	InsertCopyL. Fixed.
+	Alien bookmarks (from another table) caused panics or corruption,
+	rather than being rejected. A new verification scheme has been
+	implemented to handle this (see #7 below).
+5.	Added two more typedefs
+	typedef TBufC<KDbMaxName> TDbNameC;
+	typedef TBufC<KDbMaxColName> TDbColNameC;
+	These are used in place of the explicit TBufC variants in the interface.
+6.	Schema enquiry has been added to RDbDatabase. This is the last OVAL
+	related omission.
+	CDbTableNames* RDbDatabase::TableNamesL() const;
+	CDbColSet* RDbDatabase::ColSetL(const TDesC& aName) const;
+	CDbIndexNames* RDbDatabase::IndexNamesL(const TDesC& aTable) const;
+	CDbKey* RDbDatabase::KeyL(const TDesC& aName,const TDesC& aTable) const;
+	TableNamesL() returns a list of tables in the database.
+	ColSetL() returns a the column set for a given table.
+	IndexNamesL() returns a list of indexes for the table.
+	KeyL() returns a key for the index on the table.
+	The objects returned need to be destroyed by the caller.
+	The Names functions return an instance of the CDbNames class, which can
+	be iterated through by using the Count() member and [] operator.
+7.	A bookmark's persistence can now be specified explicitly:
+	A bookmark taken from a	view A is valid in view A following
+	re-evaluation, and also in any view B based on a query using the
+	same select list on the same table.
+	A bookmark from a RDbTable object is valid for any RDbTable opened
+	on the same table, with or without a SetIndex.
+	These all operate with the proviso that the record in question has
+	not been deleted (of course).
+8.	The table-structure cache/map has been overhauled, resulting in
+	faster backwards navigation and reduced overall memory usage.
+9.	The heuristic used to determine the clustering for a table has been
+	improved following profiling tests. It is more optimistic than
+	previously, especially for variable length columns. This results in
+	significantly lower stream counts and therefore faster performance.
+10.	The "inlining" limit for Long columns has been upped to 255 bytes
+	as #9 has ensured that this doesn't have a serious clustering
+	penalty.
+Version 0.01.026
+================
+(Made by AjT, 29th October 1996)
+1.	Uses E32/072, F32/038, STORE/028, E32TOOLS/045
+2.	Not binary compatible release with 025.
+	Can read files from 025, but writes files which cannot be read
+	by 025.
+3.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      62.0K
+	WINS ASCII Debug        -
+	MARM ASCII Release      64.2K
+	MARM ASCII Debug        75.7K
+4.	Made use of TCardinality from STORE to give a little more
+	compression to some DBMS store structures, reducing storage
+	overhead to less than 2 bytes per record in ideal conditions.
+Version 0.01.025
+================
+(Made by AjT, 18th October 1996)
+1.	Uses E32/070, F32/036, STORE/026, E32TOOLS/045
+2.	Binary compatible release with 024. I lied about the file
+formats though: but it wasn't my fault really. This should be
+the last time they change though.
+3.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      62.0K
+	WINS ASCII Debug        -
+	MARM ASCII Release      64.2K
+	MARM ASCII Debug        75.6K
+4.      Fixed a bug in RDbRowSet::InsertCopyL: BLOBs were not being
+duplicated.
+5.      Added Auto-Increment support due to overwhelming demand. This has
+effected the file format change which makes all previous
+databases unreadable.
+TDbCol::EAutoIncrement can be added to the attributes of any
+integral column 32 bits wide or less. The next value of the
+counter is used to initialise any auto-increment columns when
+RDbRowSet::InsertL() or RDbRowSet::InsertCopyL() is used. So the
+value is available before PutL() is called.
+The columns are not verified for uniqueness (you can use a
+unique index to do that), nor are clients prevented from
+changing the value in an auto-increment column.
+It is implemented as an unsigned 32 bit counter, beginning
+from 0, with the following effects given the choice of column:
+EDbColUint32: Wrap-around from KMaxUint32 -> 0
+EDbColUint16: KErrOverflow in PutL() at KMaxUint16+1
+EDbColUint8:  KErrOverflow in PutL() at KMaxUint8+1
+EDbColBit:    KErrOverflow in PutL() at 2
+EDbColInt32:  Wrap-around from KMaxInt32 -> KMinInt32
+EDbColInt16:  KErrOverflow in PutL() at KMaxInt16+1
+EDbColInt8:   KErrOverflow in PutL() at KMaxInt8+1
+6.      RDbTable::SeekL(TDbSeekKey const&,TComparison=EEqualTo) has
+been implemented. This allows fast key-based lookup of a
+particular row in a table, using an index. To use it the index
+has to be created, and the RDbTable has to be set to use this
+index using the SetIndex() member.
+Two classes are provided for passing keys to Seek: TDbSeekKey
+is used for passing a single-column key, the template class
+TDbSeekMultiKey is used for multi-column keys: the template
+parameter is the number of columns in the key. Key values are
+added to the key using the Add() members. Single column keys can
+be constructed directly from the key value with the
+TDbSeekKey(... aKey) constructors.
+The key values used must match the column types in the index
+definition exactly, except for integral types <=32 bits wide
+which are all passed as 32 bit values. You can specify less key
+columns than are present in the index, and the search will be
+restricted to the columns in the key you provide.
+Results of using different comparisons are:
+ELessThan:      the last row which compares strictly less than
+the key
+ELessEqual:     the last row which compares less than or
+matches the key
+EEqualTo:       the first row which matches the key
+EGreaterEqual:  the first row which matches or compares greater
+than the key
+EGreaterThan:   the first row which compares strictly greater
+then the key
+SeekL() returns non-false to indicate when a row matching the
+key and comparison was found.
+Note:
+a) that if more than one row matches the provided key,
+EEqualTo and EGreaterEqual will return the same row, but
+ELessEqual will return a different row: the _last_ row which
+matches.
+b) the comparison type does not take into account whether an
+index column is descending: i.e. a row which is "less than" a
+key (for Seek) can contain a column value numerically greater
+than the value in the key.
+Version 0.01.024
+================
+(Made by AjT, 4th October 1996)
+1.	Uses E32/069, F32/035, STORE/025, E32TOOLS/042
+2.	Binary compatible release with 023. As with STORE 025, the final
+	adjustments in file format come with this release: all future
+	releases should be able to read databases written with this
+	release.
+3.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      60.5K
+	WINS ASCII Debug        -
+	MARM ASCII Release      62.4K
+	MARM ASCII Debug        73.6K
+4.	Recompiled against STORE 025 to bring in an inline bug fix.
+5.	Fixed a failure-to-initialise bug which occured following a
+	failure during RDbDatabase::RDropTable::Open() and
+	RDbDatabase::RRecover::Open()
+6.	Fixed a couple of bugs related to index recovery in stressed
+	conditions: resulted in corrupting the stream-structure of the
+	database, and a bogus index after rollback.
+7.	Failure during RDbView::Prepare() or RDbTable::Open() could
+	leave the database in an invalid transaction state. Fixed.
+Version 0.01.023
+================
+(Made by AjT, 1st October 1996)
+1.	Uses E32/069, F32/035, STORE/024, E32TOOLS/042
+2.	This is the DBMS B2 release.
+	There are one or two weird bugs lurking in there somewhere, which
+	we are trying to fish out at the moment. They only show up under
+	heavy alloc fail and thread shooting tests. Rather like trying to
+	catch exotic sub-atomic particles really.
+3.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      60.5K
+	WINS ASCII Debug        -
+	MARM ASCII Release      62.1K
+	MARM ASCII Debug        72.9K
+4.	Binary incompatible with any previous release.
+5.	Fixed:
+	Navigating to Next after Deleting a record from a windowed view
+	and then trying to read the record resulted in KErrDoesNotExist.
+	The next row is now correctly found.
+	Rowset returning an (incorrectly) empty row after a failed row
+	read (due to e.g. OOM). Row buffer/cache fixed.
+	Specifying a Unicode column for a LIKE match in an SQL string
+	now results in KErrNotSupported, rather than undefined (random)
+	behaviour.
+	Rollback due to a failed Update/Put left the rowset with invalid
+	data in the row. This could be returned a valid row after resetting
+	the rowset. This is now correctly invalidated.
+	Could not navigate on a rowset while any other rowset was between
+	Update/Insert and Put. Changed Transaction states to allow this.
+	Fixed an incorrect assert in the transaction states.
+6.	RDbColXmmmmStream::StoreL[C] have been withdrawn. Use the
+	CEmbeddedStore class in STORE instead to achieve store embedding
+	in LongBinary columns.
+7.	With support from STORE 024, Recovery is now fully operational.
+Version 0.01.022
+================
+(Made by AjT, 23rd September 1996)
+1.	Uses E32/067, F32/033, STORE/022, E32TOOLS/041
+	This release has not used the latest E32 etc., in order to
+	make the new DBMS functionality available to its clients
+	immediately.
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release      60.5K
+	WINS ASCII Debug        -
+	MARM ASCII Release      61.8K
+	MARM ASCII Debug        72.7K
+3.	Binary incompatible with any previous release.
+	Files are also incompatible: the DBMS head stream is now typed
+	and validated whn opened.
+4.	Fixed a bug in the calculation of maximum record size in the
+	presence of a DateTime column.
+5.	Indexes now support truncated Text and LongText keys.
+	TDbKeyCol has a new member iLength and a new ctor:
+	TDbKeyCol(const TDesC& aColumn,TInt aLength,TOrder anOrder=EAsc);
+	*	The length should only be defined for Text or LongText columns.
+	*	The lengths specified need to equal the maximum column length
+		(or be left undefined), _except_ for the last key column, for
+		which it can be smaller. Key values will be truncated to fit.
+	*	With unique indexes the _truncated_ key will have to be unique.
+	*	ORDER BY (which is only supported in the presence of an index)
+		is relaxed so that rows are returned in the order of the 'best'
+		matching index available: i.e. between indexes containing all
+		necessary columns, the one that stores most of the final key
+		column. Clearly if a truncated-key index is not unique, the rows
+		may be returned in not-quite-order.
+	*	LongText columns, like short ones, can be indexed. LongText
+		columns can only ever be used as the last column in a key
+		specification, and must have a length specified.
+	*	Every key value in an index takes up the maximum space.
+	As a guide: The maximum allowable unique Text key is 248 bytes, the
+	maximum allowable non-unique Text key is 244 bytes.
+6.	Database safety and Transaction support.
+	*	The Database uses the Store commit/revert protocol to achieve
+		transaction support. Therefore is is _vital_ that clients do
+		not do so themselves while they have the database open. Failure
+		to do so may result in an unrecoverable database.
+	*	Until a transaction is commited, the updates are not persistent:
+		Rollback or closing and re-opening the database will result in
+		loss of the updates and possible recoverable damage to the
+		database.
+	*	Without the explicit use of transactions on the database, all
+		update operations take place within their own automatic
+		transaction:
+		*	DDL incremental operations are committed on successful
+			completion, or rolled back when the incremental object
+			is closed if the operation failed or was not completed.
+		*	DML: RDbRowSet::UpdateL() or Insert[Copy]L() begins a auto-
+			transaction and PutL() commits it, on any failure,
+			Cancel() will invoke the rollback. DeleteL() does all of
+			this within the single function.
+		*	Interleaved DML operations on separate rowsets are treated
+			as a single transaction on the database, so it is possible
+			to make a multi-table update be atomic using the auto-
+			transaction feature. e.g.
+			View1.UpdateL();	// transaction begins here
+			View2.UpdateL();
+			...
+			View1.PutL();
+			View2.PutL();		// transaction commits here
+			For such a transaction to rollback on failure, all rowsets
+			with pending updates must be Cancel()led.
+	*	Explicit use of RDbDatabase::Begin(), Commit() and Rollback()
+		precludes the above behaviour. If the database is in an explicit
+		transaction, update operations do not invoke invoke their own
+		auto-transactions.
+		DML and DDL cannot (and never could be) operated at the same
+		time, but they can be done within the same database transaction.
+	*	When an operation fails during a transaction, and before any
+		rollback, the database is left in an "abort" state, and
+		attempting other operations will result in an KErrAbort error.
+		The appropriate rollback mechanism must be used before commencing
+		(Cancel() rowset updates, Close() incremental objects, Rollback()
+		any explicit transactions).
+		The database may be damaged following rollback, but this can be
+		repaired.
+	*	After a Rollback, all rowsets lose their current position, this
+		results in a return/leave code of KErrNotReady when attempting
+		to use the table or view. The rowset must be Reset() which
+		returns it to the state it was in immediately after opening or
+		preparing. (So a view may need to be re-evaluated at this point).
+		The rowset does not need to be closed and re-prepared.
+	*	If a client requires that some Store updates are commited to
+		the Store at the same save-point as some database updates,
+		an explicit transaction should be used, and both the store and
+		database updates carried out within the transaction. Commiting
+		the database will then commit the Store.
+	*	Why use transactions? Apart from providing atomicity of multiple
+		updates across one or more tables, they vastly improve
+		performance when doing bulk updates.
+		Some statistics: the test was writing 1000 records (about 40 bytes
+		per record) to a table in a database. (timings from the rack)
+		Automatic transactions (each record is written within its own
+		transaction):
+			File size: 529,667 bytes
+			Time:      90.1s
+		Explicit transactions (a single transaction is used for all 1000
+		record writes):
+			File size: 38,762 bytes		(14 x smaller)
+			Time:      1.54s			(>50 x faster)
+		The file size difference is entirely compactible on STORE
+		(eventually--when STORE provides compaction), as the extra space
+		comes from having to flush buffers and commit the store after
+		every record is written.
+7.	The recovery code is in place, but requires some more Btree
+	support from STORE than comes with 022.
+	*	Following Rollback (auto or explicit): if any indexes have
+		been updated, they are considered broken. The database is
+		still operational (although it reports that it is damaged).
+		Any damaged indexes cannot be used for DML (reporting
+		KErrCorrupt) and so may prevent some views being operational
+		after rollback and reset.
+	*	Damaged indexes can be dropped (STORE does not support this
+		yet). The database will still report damage, though recovery
+		will then be trivial.
+	*	Recovering the database involves rebuilding all damaged
+		indexes. (ditto about STORE)
+	*	All tables and views must be closed on the database before
+		recovery can commence.
+8.	There is now a limit of 32 indexes on any one table in database.
+9.	Incremental operations now take larger than minimal steps, and
+	should modify the step count more sensibly than before.
+10.	Indexing should be one helluvalot faster now: without any commit
+	framework the previous release was doing some excessive streaming
+	to the file.
+Version 0.01.021
+================
+(Made by AjT, 6th September 1996)
+1.	Uses E32/066, F32/031, STORE/021, E32TOOLS/039
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release	54.0K
+	WINS ASCII Debug        -
+	MARM ASCII Release      55.4K
+	MARM ASCII Debug        64.9K
+3.      Binary incompatible with previous release.
+4.      Any API to do with compaction has been removed as compaction is
+ommitted. Compaction of the file-store should be done with the
+STORE API.
+5.      Added RDbColXxxxStream::StoreL() and RDbColXxxxStream::StoreLC()
+to enable a persistent store to be embedded in LongBinary
+columns. Use in the same way as RStoreXxxxStream::StoreL() etc.
+6.      New persistent table structure: robust and PermanentStore
+friendly. Records are clustered and clusters are cached in
+memory, resulting in lower storage overhead and faster record
+access.
+7.      The rule about EDbColBit columns being not-null has been
+withdrawn. Nullable Bit columns are back.
+8.      No provision for serious text to time conversion has been made,
+so date columns cannot be used in WHERE clauses, and the date-
+literal is removed from the grammar.
+9.      Removed trivial constructors and destructors from abstract
+classes, there by saving code space (~1K) and preventing
+vtables being generated for these classes.
+Version 0.01.020
+================
+(Made by AjT, 2nd September 1996)
+1.	Uses E32/066, F32/031, STORE/021, E32TOOLS/039
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release	52.5K
+	WINS ASCII Debug        -
+	MARM ASCII Release      53.5K
+	MARM ASCII Debug        62.6K
+3.      Binary compatible with 019
+4.      DBMS is no longer tested against the Fragment file store layout,
+as this is being phased out and the future releases will start
+using file store features not supported by CFragmentFileStore.
+Changed your code to using CPermanentFileStore now!
+5.      Views now follow the spec for cursor position after DeleteL,
+PutL and Cancel.
+Following from DeleteL, the current position is in between what
+would have been the Next and Previous rows, so Next and Previous
+after DeleteL will go to the same row as if DeleteL had not been
+called.
+After a PutL the current row will be the row just Put. Which row
+appears following subsequent Next/Previous depends on how the
+view is evaluated. For Unlimited windows it is well defined (see
+note 8 to release 018). For Table views with no set index,
+Updated rows remain in the same place, Insert[Copy]ed rows are
+appended, so following Insert/Put the current row is the Last
+row.
+After a Cancel the view should be located in the same place it
+was prior to the Update/Insert.
+6.      Support for co-ordinating multiple views on the same table has
+been added. If one view modifies the table this can affect other
+rowsets. DBMS tries to recover the other view cursors when they
+are next used, but this is not always possible. Some RDbRowSet
+members can fail in special ways in this situations:
+If another view has deleted the rowset's current row, GetL and
+DeleteL will fail with KErrDoesNotExist. Depending on how the
+view is evaluated the view may still be able to move to
+PreviousL and NextL. If the cursor cannot be recovered, NextL
+and PreviousL will fail with KErrNotReady and the view will be
+left on an invalied row.
+If another view has modified the table between between a call to
+UpdateL and PutL, PutL will fail with KErrGeneral. [I'm trying to
+think of a more appropriate error for this]. To continue you
+need to Cancel() and then try to update again.
+As DBMS is not a server, you should usually be in control of
+multiple views, and how they will interact with each other.
+7.      Long columns are inlined into the record when they are short
+enough. This has no affect on the API to access them, as this is
+primarily to reduce the storage overheads for short BLOBs.
+Version 0.01.019
+================
+(Made by AjT, 21 August 1996)
+1.	Uses E32/065, F32/029, STORE/020, E32TOOLS/039
+A release to upgrade to the new components and directory
+structure.
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release	51,200
+	WINS ASCII Debug        -
+	MARM ASCII Release      52,812
+	MARM ASCII Debug        61,268
+Version 0.01.018
+================
+(Made by AjT, 20 August 1996)
+1.	Uses E32/064, F32/028, STORE/019, E32TOOLS/036
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release	51,200
+	MARM ASCII Release      52,860
+	MARM ASCII Debug        61,308
+3.      Fix: Table names are compared folded when opening tables or
+views on the database.
+4.      A final record layout has been adopted: Long columns are not yet
+inlined when they contain sufficiently little data. Any
+databases from previous versions will be read incorrectly. The
+new format means that the order of the columns in a newly
+created table may not be the same as that in the column set
+provided for RDbDatabase::CreateTable() or
+RDbDatabase::AlterTable().
+Specifying columns as Not-Null reduces the persistent storage
+requirements for numerical columns. Bit columns must always be
+Not-Null.
+5.      Dropping and altering tables, creating and dropping indexes, and
+evaluating a view are now done incrementally. The non-incremental
+forms use the incremental objects/functions. These are done in
+rather small steps at the moment, this will be changed to more
+efficient larger steps at some stage.
+6.      AlterTable has arrived. Specification of the altered column set:
+Any column with the same name in the altered set as one in the
+original table is considered unchanged. So it must have the same
+definition, with the exception that the TDbCol in the altered set
+can have iMaxLength set to KDbUndefinedLength.
+Any number of columns may be deleted, provided they are not used
+in any index key. Any number of nullable columns may be added.
+Any number of Not-null columns may be added to an empty table:
+it is an error to try and add Not-null columns to a non-empty
+table.
+If the table is empty, or no columns are being dropped this
+completes immediately. Otherwise the entire dataset need to be
+modified and the operation is potentially long-running.
+7.      Query text and the comparison type to be used in the query are
+now packaged into a class TDbQuery, which can be constructed
+from a descriptor, or a descriptor and a comparison type.
+This affects the following functions:
+RDbRowSet::RConstraint::Open()
+RDbRowSet::FindL()
+RDbView::Prepare()
+8.      The RDbView::Prepare API now looks like:
+TInt Prepare(RDbDatabase&,const TDbQuery&,TAccess =EUpdatable);
+TInt Prepare(RDbDatabase&,const TDbQuery&,const TDbWindow&);
+TInt Prepare(RDbDatabase&,const TDbQuery&,const TDbWindow&,TAccess);
+effectively you have
+Prepare(Database, Query [,Window] [,Access])
+The Query can be directly constructed from a descriptor, in
+which case normal text comparison is used in the query
+evaluation. Other comparison modes can be set by explicitly
+constructing a TDbQuery from the query descriptor and comparison
+type.
+The Access parameter is as specified before, and always defaults
+to RDbRowSet::EUpdatable.
+The Window parameter is the new one. This defaults to
+TDbWindow::ENone, which provides the previous behaviour for the
+view: evaluation or navigation may take an extended time to
+complete, depending on how the query is evaluated, as little
+memory is used as possible.
+If TDbWindow::EUnlimited is specified, the view takes on Dynaset
+behaviour. Evaluation may take an extended time to generate a
+set of all the rows in the query, but then navigation is
+guaranteed to take constant time. This does impact the way
+modified or inserted rows appear in the set: modified rows will
+stay in the same place in the set, even if an ORDER BY clause is
+specified in the query or they no longer match the WHERE clause;
+inserted rows will always appear at the end of the set, even
+when they do not match a WHERE clause. If the set is re-
+evaluated, these rows will then appear (or not) in the correct
+place.
+A limited size window can be specified, which allows for
+guaranteed quick navigation within the window, without the
+memory overhead of generating a set of every row in the query.
+This is specified with the TDbWindow constructor overload:
+TDbWindow(TInt aForeSlots,TInt aRearSlots);
+aForeSlots indicates the number of row references which should be
+"cached" for navigating to Next, and aRearSlots indicates the
+number which should be cached for going to Previous. The current
+row is not included. The window then provides a restricted view
+over the underlying query; when fully evaluated the window will
+try to match the requested shape if possible. Navigation is
+restricted to the window, CountL() reports the number of rows in
+the window, and going past the end will report AtEnd and
+AtBeginning as for other rowsets. To "move" the window, the
+view needs to be evaluated some more.
+Updated records in a restricted window will remain in place,
+though further navigation and evaluation may result in it
+appearing elsewhere later. Inserted records are not added to the
+window, they may appear later after further evaluation.
+Restricted windows are therefore not ideal for modifying the
+data.
+Note: Some queries will demand an unlimited window (ORDER BY on
+a non-indexed column (not yet available), so the parameter to
+Prepare can only be used as a suggestion to DBMS.
+Evaluation API:
+void Reset();
+TInt Evaluate();
+void Evaluate(TRequestStatus& aStatus);
+TBool Unevaluated() const;
+TInt EvaluateAll();
+The view can be Reset() to its condition immediately after
+Prepare(). For views with a window, this results in an empty
+window, and evaluation is required to make any rows available.
+The view is repositioned back to the beginning.
+Evaluate() does a unit of evaluation work. A return value <0
+is an error code; KErrNone implies that evaluation is complete
+for the window/set; >0 implies that further evaluation can be
+done. Evaluate(TRequestStatus& aStatus) is an asynchronous
+version of Evaluate(), the status reporting the same as the
+return code.
+At any time, RDbView::Unevaluated() will return whether
+Evaluate() has any work to do or not.
+EvaluateAll() invokes Evaluate() until evaluation is complete.
+Evaluation and navigation can be mixed. An interesting side
+effect is that if the view is navigated off the end of the
+window, resulting in being AtEnd, and then further evaluation
+results in rows being added to the window, the view will then be
+positioned at the new row, its state changing from AtEnd to
+AtRow.
+To fully re-evaluate an unlimited window, use Reset() followed
+by EvaluateAll().
+Version 0.01.017
+================
+(Made by AjT, 5 August 1996)
+1.	Uses E32/064, F32/028, STORE/019, E32TOOLS/036
+	This is just a component upgrade release
+2.	MARM ASCII Release size down to 46,776 due to IMPORT stub
+	shortening
+Version 0.01.016
+================
+(Made by AjT, 26 July 1996)
+1.	Uses E32/063, F32/027, STORE/018, E32TOOLS/034
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release	46,592
+	WINS ASCII Debug	110,592
+	MARM ASCII Release	46,980
+	MARM ASCII Debug	54,580
+3.	Bugs fixed:
+	Key uniqueness was not being persisted, so unique indexes would
+	not work when the database was re-opened after closing.
+4.	Bookmarks are here. It is possible to bookmark any cursor position,
+	including the beginning and end of the set.
+5.	Finding within a rowset is operational.
+	RDbRowSet::RConstraint, MatchL and FindL are fully functional as
+	spec'd in the previous release notes.
+6.	Incremental database operations are now functional, though their
+	implementation is currently a mock-up based on their single call
+	siblings. So they will all report 1 step after the call to
+	Open(...) and complete after the first call to Next().
+7.	A TDbCol constructed as a short Text column (EDbColText[8|16]) now
+	has a default iMaxLength of KDbDefaultTextColLength (50) rather than
+	KDbUndefinedLength.
+	This allows default length text columns to be indexed, as the
+	previous default (which translates to 255 characters in the
+	database-in-a-store) meant that the key was too large and the index
+	creation failed. The value chosen matches a default in
+	Microsoft Access.
+8.	The enum TDbPosition has been renamed to RDbRowSet::TPosition, and
+	as all its values are now scoped by RDbRowSet, the 'Db' prefix
+	to the enumeratiuon values has been dropped.
+9.	RDbRowSet::SetColNull() has had an 'L' suffix added as it may leave
+	when a Long column is being set to Null. It will never leave if the
+	column is not a Long column or it is already Null.
+10.	The base class for the incremental operations has been renamed from
+	RDbDatabase::RState to RDbDatabase::RIncremental which better
+	reflects its purpose.
+11.	RDbView's evaluation interface has been changed after thought about
+	incremental evalution.
+	IMPORTANT: Evaluate() has been renamed to EvaluateAll(). Evaluate()
+	will eventually invoke a single step in the evaluation of the view,
+	but this member has been commented out for this release to
+	help spot uses of this member which need to be changed.
+	EvaluteAll() will eventually use the incremental evaluation
+	mechanism to generate the rowset.
+12.	RDbRowSet::CountL() is fully implemented now, and will restore the
+	previous cursor position if it is necessary to navigate the entire
+	set in order to calculate the number of rows.
+13.	RDbRowSet::IsEmptyL() is also now implemented.
+Version 0.01.015
+================
+(Made by AjT, 11 July 1996)
+1.	Uses E32/063, F32/027, STORE/017(018), E32TOOLS/034
+	Upgraded to new releases. Store 017 and 018 are binary
+	compatible. Use 018, it provided between 300 and 800% speed
+	increase for the DBMS test code.
+2.	Build sizes for EDBMS[D].DLL
+	WINS ASCII Release	44,032
+	WINS ASCII Debug	115,712
+	MARM ASCII Release	44,068
+	MARM ASCII Debug	51,080
+	Tool change resulted in 18% code size reduction. Implementation
+	of indices and addition of new API has added an extra 9.5K.
+	Debug MARM version for the first time included.
+3.	Indices are here! Single- and multi-column keys can be used to create
+	indices. Once created, all indices on a table will be updated when
+	the table has rows inserted, deleted or updated.
+	RDbTable::SetIndex() (see below) allows direct index navigation of the
+	table record set.
+	ORDER BY will work as long as the ordering matches an index, including
+	the text ordering (see 7 below) for text columns. "Matching" includes
+	reversing the index order and truncating a multi-key index to a
+	shorter sort-specification.
+4.	Following the spec meeting, the API has undergone some major work
+	detailed below. All the additions which have not been implemented
+	should still link OK, but the EXPORT_C'd stubs Panic at runtime with
+	EDbUnimplemented.
+5.	TDbCol attributes are now a member enumeration and the attributes
+	member name has been changed:
+	KDbColNotNull is now TDbCol::ENotNull
+	KDbColAutoIncr is now TDbCol::EAutoIncrement
+	TDbCol::iColAtt is now TDbCol::iAttributes
+	CDbColSet::New() has been withdrawn.
+6.	The TDbSortOrder enumeration is now a member of TDbKeyCol and the
+	sorting order member of TDbKeyCol has changed:
+	TDbSortOrder is now TDbKeyCol::TOrder
+	EDbSortAsc is now TDbKeyCol::EAsc
+	EDbSortDesc is now TDBKeyCol::EDesc
+	CDbKey::New() has been withdrawn.
+	CDbKey::Unique() is now CDbKey::IsUnique()
+7.	Enumeration TDbTextComparison has been introduced to specify how text
+	data is compared and ordered:
+	EDbCompareNormal - use "binary" order
+	EDbCompareFolded - use folded order (case and accent insensitive)
+	EDbCompareCollated - use the locale collation order
+	Where-ever SQL expressions are used in the API, a companion parameter
+	of this type is now required to specify how text columns in the query
+	are compared. This parameter is query-wide, and affects text columns
+	within a WHERE clause as well as those in an ORDER BY clause.
+	So the RDbView::Prepare(...) and Evaluate(...) members have been changed.
+	This is also an attribute of an index key, specifying how the text
+	columns in the index are ordered. If a key has no text columns, this
+	attribute is ignored. Use the CDbKey::SetComparison() and
+	CDbKey::Comparison() members to	set and test this attribute.
+8.	Row data in a rowset is not retrieved automatically anymore.
+	RDbRowSet::GetL() must be called before any column extraction can be
+	done without a Panic. RDbRowSet::UpdateL() does not require
+	the use of GetL() before or after it is called, the row is read as
+	part of the UpdateL(). If Cancel() is used after an UpdateL() or
+	InsertL(), then GetL() is required to re-retrieve the data for the
+	row previously in view.
+9.	A copy of the current row can be inserted into the rowset using
+	RDbRowSet::InsertCopyL(). This will provide new values for
+	auto-increment columns.	For views with a projected column set, i.e.
+	those using a non trivial (*) select-list in the query, it is not
+	defined whether the un-viewed columns are copied or not.
+10.	RDbRowSet::Count() is now CountL(TAccuracy anAccuracy=EEnsure)
+	to reflect the fact that counting may not be a trivial operation
+	The default behaviour is to go to whatever lengths are required
+	to provide an exact count of the membership of the row set, this
+	can take an extended time to evaluate.
+	If EQuick is passed as the accuracy parameter this member will
+	return a count only if it is immediately available, otherwise it
+	will return KDbUndefinedCount (-1). Not fully implemented.
+11.	For similar reasons RDbRowSet::IsEmpty() is now IsEmptyL()
+	This is not as hard to evaluate as the Count, but may still be a
+	non-trivial operation in some cases.
+12.	The rowset positioning operations have two new additions:
+	RDbRowSet::Beginning() and End() which are always available (hence no
+	trailingL). The positioning members	are all implemented in terms of
+	RDbRowSet::GotoL(TDbPosition), which is also available for clients.
+	RDbRowSet::FirstL(), LastL(), NextL() and PreviousL() now all return
+	TBool to indicate whether or not they are at a row. i.e. calling
+	RDbRowSet::AtRow() after a call to one of the above will return the
+	same value.
+	You can write your loops in lots of ways now
+	for (view.FirstL;view.AtRow();view.NextL())
+		{
+		}
+	or
+	view.Beginning();
+	while (view.NextL())
+		{
+		}
+	etc.
+13.	RDbTable provides the ability to view the records in named index order
+	using RDbTable::SetIndex(const TDesC& anIndex). Or back in default
+	order using RDbTable::SetNoIndex().
+14.	RDbDatabase::PrepareCommit() and FinishCommit() withdrawn. Two phase
+	commit belongs to a different scale of database.
+15.	RDbDatabase::CreateTable(...,const CDbKey&) added to support
+	implementations	which use a primary key in a table definition. The
+	Store database implementation will not support this.
+16. RDbs and RDbsDatabase have been withdrawn.
+The following changes have been made to the API, but are not yet implemented:
+17.	Bookmarks to reposition to a previously accessed row. Use them like this:
+	TDbBookmark mark=view.Bookmark();
+	// use the view to do something
+	view.GotoL(mark);
+18.	Searching across a rowset using:
+	TInt RDbRowSet::FindL(TDirection,const TDesC&,TDbTextComparison)
+	The matching constraint is defined by the search-condition part of a
+	SQL WHERE clause, i.e. "Name like '*john*'", passed as the second
+	parameter, the third parameter specifies the text comparison to use
+	(see 7 above). The first parameter is either EForwards or EBackwards
+	and specifies which direction the search should move through the row
+	set. The search always starts at the current record. The search
+	terminates when either:
+	a)	a match is found and the number of records searched minus 1 is
+		returned (so if	the current record matches the condition 0 is
+		returned) or
+	b)	the	end of the set is reached and KNotFound is returned
+	The API also provides a way of testing a row against a given condition.
+	The condition is built into an RDbRowSet::RConstraint object and can
+	then be tested against individual rows using the RDbRowSet::MatchL()
+	member. As the constraint involves allocating resources it should be
+	closed when no longer required.
+19.	Incremental forms for RDbRowSet::Evaluate()
+	All the incremental operations have a single basic function
+	TInt Next(TInt& aStep) // synchronous form
+	The integer aStep is decremented for each step, though it may be in
+	units > 1. When aStep reaches 0, the operation is complete. Some of
+	the operations' step-counts are very hard to predict, and so finish much
+	earlier than predicted.
+20.	Seeking within an index for a record which matches a specified key can
+	be achieved with RDbTable::SeekL(). The index used for the look up is
+	set using RDbTable::SetIndex() (see 13 above) and the key is specified
+	using the TDbSeekKey or TDbSeekMultiKey<S> classes. The templated class
+	allows seeking with an index which has multiple	key columns. Each key
+	value is added to the TDbSeekKey, and should match the column type in
+	the table.
+	RDbTable::SeekL() also takes a parameter which specifies which record to
+	find in the index. If it succeeds in locating a record which matches the
+	key and comparison it returns true; otherwise the rowset is left in an
+	undefined position.
+20.	RDbDatabase::IsDamaged() and Recover() added to support recovery.
+	This is done on a opened database. When open IsDamaged() reports whether
+	the database requires recovery: if it is damaged then no other
+	operations can be performed on the database, and they will report the
+	error KErrCorrupt.
+21.	RDbDatabase::Compact() will compact an open database. It must not be
+	in use for anything else concurrently.
+22. Incremental database operations are supported by the RDbDatabase::RState
+	class and those derived from it.
+Version 0.01.014
+================
+(Made by AjT, 30 May 1996)
+1)	Uses E32/060, F32/024, STORE/015, E32TOOLS/028
+2)	Binary compatible with build 013.
+	Making use of the -fcheck-new flag in MAKTRAN(028)
+3)	EDBMS.DLL build sizes:
+	WINS Ascii Debug		93,696
+	WINS Ascii Release		34,304
+	MARM Ascii Release		41,496
+4)	Bugs fixed:
+	MNT bug: failed to create an E32DATA directory, which is required
+	during EPOC32 startup!
+	Clearing or rewriting a Long column while in an RDbRowSet::UpdateL
+	caused a USER panic.
+	When updating a row, making columns smaller or setting them to
+	Null, could result in data on the end of the row being lost or
+	corrupted.
+5)	STORE 015 fixed the worst of the Rewritable file store problems.
+Version 0.01.013
+================
+(Made by AndrewT, 24 May 1996)
+1)	Uses E32/059, F32/023. STORE/014, E32TOOLS/024
+2)	EDBMS.DLL build sizes
+	WINS Ascii Debug		93,696
+	WINS Ascii Release		34,304
+	MARM Ascii Release		47,108
+3)	The ODBC implementation has been removed from the release
+4)	Bugs fixed:
+	Word swapping doubles was written without alignment in mind, caused
+	the rack to hang sometimes in RDbRowSet::PutL(). Fixed
+5)  	New features:
+	[NOT] LIKE in the search condition is now case-insensitive (using Folding);
+	The other comparison operators are (and will remain) case sensitive
+	Select-lists are now supported: so
+	"select Name,Dept from Personnel where ID>3"
+	will now work. The columns in the RDbView are ordered exactly as in the
+	list in the SQl statement.
+6)	WARNING!
+	A bug in CRewritableFileStore in STORE 014 means that once a
+	CRewritableFileStore file has been closed, opening and adding new streams
+	will make the last stream (by id) corrupt and the first one (by position)
+	invisible. This will also happen when more than 16 streams are created in a
+	newly created store.
+	Signs of corruption are duff stream data or non-exisitence of a stream when
+	reading, but may be hard to track down.
+	Opening a CRewritableFileStore for reading if no corruption has yet occured
+	is not a problem.
+	This will affect databases in RewritableFileStores.
+7)	Due to dependence on STORE 014, which has changed the format of file store
+	headers, files written using DBMS(012)/STORE(013) are unreadable with
+	DBMS(013)/STORE(014)
+Version 0.01.012
+================
+(Made by AndrewT, 13 May 1996)
+1)	Uses E32/059, F32/023. STORE/013, E32TOOLS/023
+2)	EMARM build sizes from e32rom.log:
+	Rom file size:			64K
+	Total Raw Data size:	43K
+3)	Bugs fixed:
+	RDbRowSet::IsColNull(), ColSize() and ColLength() return as for a
+	NULL column when invoked on a Long column in a rowset which has not
+	had any other column evaluated.
+	Various problems with recovery after errors when opening databases
+	or views.
+4)  New features:
+	LongText8 columns can now be specified in the WHERE clause of a
+	query.
+	Table names and columns sets are fully validated when a table is
+	created.
+	Rows are fully validated before they are written to the table.
+5)	Data format has changed, so databases written with build 011 of
+	DBMS will fail to open correctly with this build.
+Version 0.01.011
+================
+(Made by AndrewT, 30 April 1996)
+1)	Uses E32/057, F32/021. STORE/012, E32TOOLS/021
+2)	EMARM build sizes from e32rom.log:
+	Rom file size:		64K
+	Total Raw Data size:	42K
+3)	Bugs fixes:
+	E32 panic during cleanup if Store database open or creation failed.
+	Deleting last row in a table generated an End-Of-File error.
+4)	API Changes:
+	KNullColNo has become KDbNullColNo
+	Added new member TDbColType RDbRowSet::ColType(TDbColNo) which just
+	reports the column type.
+	In the RDbView::Prepare(), RDbView::Evalyate() and RDbTable::Open()
+	functions, the allowUpdates boolean flag has been replaced by an enum
+	RDbRowSet::TAccess, which takes one of the three values:
+		EUpdatable:  the default, rows can be read or written
+		EReadOnly:   the rows can only be read, InsertL/DeleteL/UpdateL
+					 will leave with KErrWrite
+		EInsertOnly: the rows can only be inserted. Any navigation
+					 functions and DeleteL will leave with KErrWrite
+5)	Long columns are now length counted when written, so ColSize() and
+	ColLength() should report correctly. Only one column can be streamed
+	in at a time on a single rowset, and only one Long column can be
+	streamed out at a time. Column streams must be closed before setting
+	other columns, navigating, etc. on the rowset.
+6)	Search conditions are now supported in the query passed to
+	RDbView::Prepare() and RDbView::Evaluate().
+	See R:\DBMS\DSPEC\SQL.DOC for the supported grammar in search
+	conditions. Searching on date columns cannot be done currently as I
+	am waiting for TTime support for descriptors.
+Version 0.01.010
+================
+(Made by AndrewT, 22 April 1996)
+1).	Still uses E32/056, F32/020. STORE/011, E32TOOLS/019
+2)	API changes:
+	KDbUndefinedLength is used for TDbCol::iMaxLength to imply that no
+	maximum has been set, and also to report the RDbRow::ColSize() could
+	not be determined.
+	KDbUndefinedCount is returned from RDbRowSet::Count() when the number of
+	rows cannot be determined
+	Static member TBool TDbCol::IsLong(TDbColType) has been added for
+	convenience to test whether the column type is one of the "Long" types.
+	CDbColSet and CDbKey are implemented using Packed arrays, and provide a
+	NewLC() member.
+	TDbColSetIter has been introduced to provide simple, but fast forward
+	iteration over a column set. Use as:
+	for (TDbColSetIter col(aColSet);col;++col)
+		{
+		if (col->iType==EDbColBit)
+			// etc.
+		}
+	RDbRowSet has two new members
+		TInt ColCount()
+		TDbCol ColDef(TDbColNo)
+	These report the column definition on a column by column basis: ColSet()
+	and ColSetL() are now implemented in terms of these new members.
+3)	EDBMS (the real thing) now supports a Database-in-a-Store in Win32
+	ASCII Debug & Release builds and the MARM ASCII Release.
+	Supports Database creation/deletion within a Store.
+	Supported Table creation/dropping with all column types. Column
+	attributes (KDbColNotNUll and KDbColAutoIncr) are not supported.
+	Long columns cannot report their length	yet.
+	RDbTables and whole-table views ("SELECT * FROM <table>" exactly: no extra
+	spaces) are supported for Viewing, Adding, Editing and Deleting rows.
+Version 0.01.009
+================
+(Made by AndrewT, 10 April 1996)
+1).	Uses E32/056, F32/020, STORE/011, E32TOOLS/019
+	Reinstated F32 as a dependency, as STORE is dependant on it.
+2).	Fixed a few duff header dependencies in the test code.
+Version 0.01.008
+================
+(Made by AndrewT, 29 March 1996)
+1). Includes MARM releasables for the first time. The release components are
+	now called EWINS, EWINSDB and EMARM. EMARM is 8-bit release mode only.
+	Uses E32/055, STORE/010 and E32TOOLS/017.
+2). DBMS has been reorganised to prepare for the ODBC mock-up being phased out
+	and replaced by the Real Thing. A clean getsrc is required as a number of
+	files and directories are new or have been renamed.
+	The ODBC implementation has been relegated to a set of DLLs of its own;
+	EODBC*.DLL, available for WINS only. To use ODBC, link against these,
+	rather than the standard EDBMS*.DLL ones.
+	DBMS test programs demonstrate one way of dealing with this situation. They
+	feature new Win32 ODBC Debug and Release configurations causing them to be
+	linked against the alternative libraries.
+3). There is now a stream store-based flavour of database, as well as a
+	server-based one. EODBC*.DLLs export a mock-up of both flavours.
+	EDBMS*.DLLs, identical on WINS and ARM, do not export the server-based
+	database, and the store-based one currently exported will refuse to open,
+	leaving with KErrGeneral.
+	Note that DBMS v1 will *not* include the DBMS server.
+4). If you use the DDL pre-processor you should stick it in \tools using
+	"getrel dbms ddlpp <ver>". The Custom-Build on Build/Settings in MSVC 4
+	is dead handy for using this tool. See the T_DDL test program for details.
+5). KDbMaxColumnLength is a const which specifies the maximum "MaxLength" that
+can be used for EDbColText8, EDbColText16 and EDbColBinary columns. For the
+	text columns "Length" has the same meaning as for descriptors.
+6). EDbColLongText8, EDbColLongText16, EDbColLongBinary are the Long column
+	types. They can only be read or written using the new stream column
+	accessors (see 7), the other SetColL() and ColXxx() members of RDbRowSet
+	will Panic. "Short" columns can be read but not written using the column
+	streams. "Short" text or binary columns can always be read directly using
+	the ColDes8/16() accessors.
+	EDbLongText8 and EDbLongBinary have been implemented for ODBC. Unicode
+	columns are still unsupported.
+	EDbColObject has been removed.
+7).	RDbColReadStream, RDbColWriteStream provide the stream interface to the Long
+	columns. Although 'MExternalizer's are in the RDbColWriteStream interface
+	they are not implemented at the moment. They require a RDbRowSet and a column
+	number to open: the row set must be positioned at a valid row for reading
+	and must be in insert/update mode for writing, as for the other column
+	accessors.
+8). Two new members RDbRowSet::ColSize(), RDbRowSet::ColLength() provide size
+	information for the current row in the row set. ColSize() is the size in
+	bytes of the data available if streamed using RDbColReadStream. ColLength(),
+	in the spirit of TDesC::Length(), returns the number of "units" of data in
+	the column. For non text/binary columns this will be 0 or 1 indicating
+	whether the column is NULL or not, for text columns this returns the number
+	of characters available in the column, and for binary columns returns the
+	same value as the ColSize() member.
+	If this cannot be evaluated -1 is returned;
+9). RDbDatabase has lost the ability to Open/Create/etc. a database.
+	This functionality is now left to derived classes:
+	RDbsDatabase provides what was lost from RDbDatabase. This (and RDbs) will
+	not be present in the MARM release.
+	RDbStoreDatabase implements the new Open/Create protocol. CreateL returns
+	an Id for the database within the store, which is used by OpenL to reopen
+	the database on a later occasion. The Real Thing will require a Store
+	which supports ExtendL() and RStoreWriteStream::OpenL() (the only
+	persistent store which currently provides this is CRewritableFileStore).
+	This is supported by ODBC, but don't expect the database to be kept within
+	the Store itself, it is in fact somewhere in \E32DATA.
+9). RDbDatabase::Destroy() destroys (deletes) the persistent database and
+	closes the RDbDatabase object. This provides for deletion of databases
+	created using RDbStoreDatabase
+Version 0.01.007
+================
+(Made by AndrewT, 4 March 1996)
+1).	Updated to E32:054 and F32:018
+Version 0.01.006
+================
+(Made by AndrewT, 30 January 1996)
+1).	Updated to E32:053 and F32:017
+Version 0.01.005
+================
+(Made by AndrewT, 18 January 1996)
+1).	Updated to E32:052 and F32:016
+1).	Fixed a bug in TDbRow which meant that changing column data for
+	text columns would not always change the column data width.
+2)	Changed the accessors for the View. SetColL() does not have overloads
+	for 8 or 16 bit integers, The TInt, TInt32, TUint and TUint32 are
+	enough - (via ODBC we cannot provide range validation on shorter columns
+	due to its signed/unsigned incapabilities).
+	Any integral column can be extracted using an accessor at least as wide
+	as the column definition:
+	e.g. a Bit column can be extracted with ColUint8() ColUint16() or
+	ColUint32(), an Int16 column can be extracted with ColInt16() or
+	ColInt32() but not ColInt8() - even if the data is in range for this
+	extraction.
+Version 0.01.004
+================
+(Made by AndrewT, 3 January 1996)
+1).	Updated to E32:051 and F32:015
+2).	Now uses the new TTime and TDateTime classes. TSystemTime is no
+	longer supported.
+3).	The pre-processor has also been modified to handle the new TTime.
+Version 0.01.003
+================
+(Made by AndrewT, 18 December 1995)
+1).	Updated to E32:050 and F32:014
+	The new TBool has broken the SetColL() overloads for RDbRowSet.
+	The overload for TBool has been withdrawn for this release, pending a
+	rewrite of the set/get interface.
+Version 0.01.002
+================
+(Made by AndrewT, 17 October 1995)
+1).	Updated to E32:047 and F32:011
+	All functions which used to return TUints as counts or indices now return
+	TInts. Specifically RDbRowSet::Count() now returns -1 if it cannot determine
+	the actual count.
+2).	Fixed a bug in RDbRowSet::Prepare() to report an error on SQL syntax errors.
+Version 0.01.001
+================
+(Made by GeertB, 29 August 1995)
+1). First release.
+	The main header file is D32DBMS.H.
+	The header file D32ADT.H is for the use of implementers of DBMS file
+	organisations, "drivers" which are used by the DBMS.
+	Implemented by passing all interesting operations on to Microsoft Access
+	through ODBC.
+	Running programs linked against this release requires the installation of
+	32-bit ODBC and the Access driver. This is done as follows:
+	- shut down all applications (don't forget Office)
+	- run T:\ODBC\BIN32\ODBCAD32.EXE, the 32-bit ODBC Administrator
+	- in the resulting dialog, press "Drivers...", then "Add..."
+	- type T:\ODBC\BIN32 at the prompt (or use "Browse...")
+	- select "Microsoft Access Driver (*.mdb)" in the list that pops up
+	- press "OK" (or double click)
+	- file copying will start
+	- a message like the following will appear: "The file C:\WINNT35\SYSTEM32\
+	  MSVCRT20.DLL is currently in use and cannot be removed or updated. Try
+	  closing all applications and choosing Retry. (...)"
+	  Since it's the ODBC Administrator itself that is using the DLL, complying
+	  won't help. Instead, choose "Ignore".
+	- if a message along the lines of "An error occurred while copying
+	  C:\WINNT35\SYSTEM32\MFC30.DLL. Restart Windows and try installing again
+	  (before running any applications which use ODBC)." appears, you've left an
+	  application using MFC running. Start again from the top.
+	- the installer adds a data source called "sdk21-Access32". It can
+	  safely be deleted.
+	- in the "Data Sources" dialog, create a data source by pressing "Add..."
+	- select the Access driver in the resulting dialog and press "OK"
+	- call the new data source "DBMS", leaving other fields blank. Choose "OK".
+	- close the ODBC Administrator
+	- in case you haven't copied the new (MSVC 2.1) MSVCRT20.DLL from T:\MSVC21\
+	  SYSTEM32 yet, do so now. The Access ODBC driver needs the newer version.
+	  See the instructions in the E32 0.01.039 release notes.
+	Warning: on one NT machine, the driver setup program erroneously copied the
+	Windows 95 version of CTL3D32.DLL. If this happens, applications--notably
+	MSVC--may start complaining about it. The fix is to copy T:\ODBC\REDIST32\
+	WINNT\CTL3D32.DLL into your SYSTEM32 directory.
+2). Unicode builds are not supported. ODBC understands only 8-bit text.
+	Support for the 8-bit subset of the Unicode character set can be added
+	fairly trivially if it turns out to be needed during the life time of this
+	implementation.
+3). The initial revision of a tool to help in building programs to run against
+	the DBMS is included. It is called DDLPP.EXE and it takes a simple data
+	definition language as its input and generates C++ headers and source code.
+	See R:\DBMS\DSDK\DDLPP.HLP for more information.
+	It is less than perfect as a command line tool at the moment.
+	Comments and feedback welcome.
+4). No interpretation of ODBC status codes. In case of an ODBC error,
+	KErrGeneral is returned.
+5). RDbViews and RDbTables become unusable when the transaction they were
+	created in ends. Currently, if you don't start a transaction using
+	RDbDatabase::Begin(), one is implicitly entered for you, and committed
+	on RDbRowSet::Put(). Thus the row set is effectively closed after the
+	first database modification.
+	The workaround is to use explicit transactions.
+6). RDbView::Define() is not implemented, and will in all likelihood be
+	withdrawn in a future release.
+7). The Access driver does not accurately report the number of rows in the
+	result set. As a result, RDbRowSet::Count() returns KMaxTUint in the
+	majority of cases.
+	In general, Count() is an expensive operation and should not be used
+	lightly.
+8). No interpretation of ODBC status codes. In case of an ODBC error,
+	KErrGeneral is returned.
+9). Bit columns (EDbColBit) cannot be NULL.
+10). Text columns (EDbColText8) are currently limited to 255 characters.
+11). Binary column extraction (EDbColBinary) is limited to the first 2K of the
+	data.
+12). TUint32 column accessor functions cannot be used at the moment due to an
+	overload ambiguity with TSystemTime.
+13). The full range of the unsigned integer column types is not available.
+	Values are constrained to the range of the corresponding signed types.
+14). The Access driver does not support NOT NULL columns.
+	RDbDatabase::CreateTable() does accept KDbColNotNull columns but cannot
+	enforce it.
+15). RDbDatabase::AlterTable() is not currently implemented.
+NOTES
+=====
+The DBMS's requirements are currently undergoing extensive revision, due to
+changes in ERA's overall strategy for persistent storage. This may result in a
+number of changes to the API.