Quadcap Embeddable Database

• QED Home
• User's Guide
• Developer's Guide
• API Documentation
• SQL Reference
• FAQ
• Changes

Quadcap Software

• Home
• Download
• Products
• Services
• Purchase
• Support
• About

• sql: In-memory mode is now fully supported.
• sql.tools: XmlDump now dumps global index objects.
• sql: Fix bug which caused a case-insensitive compare for a delimited identifier.
• sql: Implement extension: ALTER TABLE ... RENAME TO.
• sql: Optimize non-correlated subqueries, so that we only perform the subquery once, and cache the results in a temporary index structure.
• sql: Fixed bug in COUNT(DISTINCT ..) introduced by 3.3 aggregate optimization patches.
• sql.file: Make scratchCacheSize configurable from connection string
• jdbc: Fix bug in DatabaseMetadata.getColumns() where default value expressions were getting evaluated instead of being returned as literal SQL expressions.
• jdbc: Fix precision of float types in DatabaseMetadata.getTypes() to match Java/IEE754
• sql.tools: Fix bug where running XmlDump or XmlLoad multiple times from the same JVM failed due to overeager caching of jdbc.url and other connection parameters.
• sql: Fix encryption; broken in version 3.3
• sql: Performance enhancements and optimzations to speed up evaluation of IN expressions.
• sql: Fix bug in LIKE causing StringIndexOutOfBoundsException with escape sequences and certain string values.
• jdbc: Fix ResultSetMetaData.getColumnDisplaySize -- previously this returned the max of the actual column data width and the column name width; now this returns simply the width of the column's data.
• sql: Fix bug which could cause incorrect BLOB data when recovering UPDATE operations on database restart.
• sql: Fix parser to support parsing Unicode data. QED always supported Unicode strings, but the parser was basically limited to ISO-8859-1.

• jdbc: ResultSet.moveToInsertRow() should clear the insert row even if it's already on the insert row.
• sql: Work around for Samba bug 725, thus permitting QED to be run on Samba shares.
• sql: Fix deadlock situation by eliminating separate 'connLock' monitor.
• sql: Fix missing exception on DROP TABLE of bogus table.
• sql: DROP TABLE now properly drops secondary indices on that table created using CREATE INDEX.
• sql: Fix recovery bug caused by stale cache entries. Now revert the cache immediatley after recovery on restart.
• sql: Add support for COMMIT, ROLLBACK statements in the SQL grammar, to allow transaction control directly from SQL scripts.
• sql: Fixed comparator bug which could cause erroneous seek results on large datasets with integer keys.
• sql: Fixed some bugs in the 'DataOutputStream' implementation that could show up in tables with very large rows.
• sql: Optimized implementations of MIN(column) and MAX(column) for indexed columns. Also implemented the COUNT(*) short-cut.
• sql: Initial implementation of in-memory mode, not working yet....
• sql: Cleanup handling of nested exceptions
• sql.file: Fix bug in restart where log maxSize information could be lost.
• sql.index: Fix bug in BtreeCusror.afterLast() which could cause problems in large indexes.

• general: Eliminate some unused imports
• general: Other JMD-inspired cleanups
• sql.file: Clean up 'delete crash' bug (thanks, Bernard) caused by misuse of recovery rowMap (Delete test)
• sql: Fix null pointer exception in bogus foreign key delete. (CannotDrop test)
• sql: Fix predicate cursor 'absolute' implementation (Asbolute bug)
• sql: Correct 'Table not found' message in 'ADD COLUMN'
• sql: Change default in DROPs from CASCADE to RESTRICT (CannotDrop test)
• sql.types: Fix setObject(byte[]) conversion to BLOB (XMLLoadBinary test)
• sql: Fix pattern (LIKE) bugs (thanks Bernard)
• sql: SELECT foo.* FROM bar ... now throws the expected exception if 'foo' isn't valid
• sql: ALTER TABLE ADD COLUMN now throws the expected exception if the named column already exists.
• jdbc: Fixed bug with ResultSet update operations, which were broken in 3.1
• jdbc: Fixed bug in ResultSetMetaData.getColumnType where expressions had type 'OTHER' instead of the actual type.

• sql.file: A more space-efficient serializer was created using leading zero suppression, yielding a ~20% reduction in datafile sizes...
• sql.file: Added 'encrypt' option, which uses user+password to create a Rijndael/AES (128 bit) key. This key is used to encrypt each block of the file except block zero. The magic code (first two bytes) for an encrypted file is 0e0c. (normal: 040c) For an encrypted datafile, the admin/key user+password is hashed and stored in block zero for authentication of the initial connection -- subsequent connections are not authenticated.
• sql.file: Change default min/max sync interval to 15-60 seconds
• jdbc.ResultSet now has much more complete support for JDBC 2.0 features. Everything that made sense to implement was done in this pass:
  • Correct handling of 'on insert row' and 'on update row' states.
  • cancelRowUpdates() implemented.
  • refreshRow() implemented.
  • relative() implemented.
  • rowDeleted(), rowInserted, rowUpdated() implemented.
  • setFetchDirection() "implemented" (as no-op).
  • Fixes for isLast(), absolute(), etc.
• jdbc.PreparedStatement:
  • JDBC escape handling was disabled!
  • setObject() now supports java.sql.Blob, java.sql.Clob types.
• jdbc.ResultSetMetaData: Fix isAutoIncrement()
• jdbc.MultiDriver: Added a new JDBC driver which uses its own classloader to load old QED driver versions, to provide access to old-version QED datafiles.
• SQL: Undo of DROP COLUMN put the column back in the wrong position!
• sql.tools: XmlDump now uses ResultSetMetaData.isAutoIncrement() to determine presence of WITH IDENTITY constraints, thus remaining, theoretically, JDBC-standard-compliant (i.e., you could use XmlDump with antother JDBC driver to dump a database in XML format...)
• sql.tools: QED, starting with 3.0, includes the view creation DDL in the COMMENTS field of the result set returned by DatabaseMetadata.getTables(). sql.tools.XmlDump uses this field, but didn't properly handle the case where this field might be null, as with pre-3.0 QED drivers.
• sql: For ADD COLUMN WITH IDENTITY, id values are now built into rows initially, eliminating the need for an extra pass over the data to add the identity value.
• sql: For WITH IDENTITY constraints, manual insertion of a key value forces the autonumber identity values to increase to match. This strategy makes it easy to reload auto-number-generated databases.
• sql.file: The "scratch" file is now explicitly refcounted, to protect from purges based on the "transaction table empty" state..
• sql.types: Remove Type.isAutoIncrement()
• sql: Add Column.isAutoIncrement(), based on AutoNumberConstraint...
• sql: Constraint: ensure colNames is never null. This simplifies life later...
• sql: Constraints: add explicit 'resetColumns' logic for foreign key constraints.
• sql: Fix bug in rollback of partially completed ADD CONSTRAINT statements.
• sql: ADD CONSTRAINT now checks for duplicate constraints
• sql: Fixes (and complete testing) for bugs relating to empty authorization string
• sql.tools: XmlDump fixes for BLOBs.
• sql: Fixes to ensure proper handling of views with (or without) the VIEW CHECK OPTION
• sql: Fix bug with delimited identifiers
• sql: Fixes for DECIMAL types.
• sql: Fixes for bug found in ALL, ANY
• sql: Ensure that single row sub-selects really select only a single row.
• sql: Precedence of UNION should be left to right. Now it is.
• sql: Improved version of grammar that handles all JOIN cases with correct precedence.
• text.sax: Add support for Locator

• jdbc.DatabaseMetaData: Major improvement in this area, as several typical "first moves" by various SQL clients turned out to not work. All of the required metadata is available now, and the only thing that's really just a stub is the stuff for getCatalogs().
• SQL: major rewrite of the logging implementation. First, a clean API to the logging subsystem was introduced, allowing pluggable logging implementations. There are two implementations, one is a no-op logger for applications which don't need rollback and recovery; the other is a complete implementation using a RandomAccessFile. The old log.xxx files are gone, replaced by a single logfile with a configurable max size.
• SQL: Major overhaul of cursor implementation, including bidirectional movement and a better implementation with fewer memory allocations, so less gc thrashing.
• SQL: Streamline common case of INSERT ... VALUES
• SQL: implemented ALTER TABLE DROP COLUMN, and tightened up the implementation of ADD COLUMN, as well.
• SQL: implemented SQL92 CASE expression.
• SQL: implemented SQL92 UNIQUE (table-expr) predicate
• SQL: fixed bug with EXCEPT CORRESPONDING implementation
• SQL: Fixed bug in COUNT DISTINCT aggregate evaluation with NULL values.
• SQL: Fixed bug with DELETE where delete of more than 1000 rows generated "Bad block" exception.
• all: Reviewed debug code to ensure that it didn't end up in release builds.
• SQL: Adding a WITH IDENTITY column should have caused the newly added column to be numbered also, but this wasn't happening.
• SQL: fix statement update counting, which had failed to count anything except inserts!
• SQL: fix several recovery bugs caused by improper database sync logic; thanks to Jeremy Wechsler for finding this problem.
• SQL: Fixed implementation of aggregate expressions by separating the session-specific state from the database-shared portion of the expression, allowing concurrent access (generally through views) to the "same" aggregate expression.
• SQL: WITH IDENTITY now starts counting at one.
• SQL: Fix bug with constraint ordering
• JDBC: Fixed bug with PreparedStatement.setClob() and PreparedStatement.setAsciiStream().
• all: Doc comment cleanup.
• webapp/qed: Added more buttons for the newly implemented DatabaseMetaData calls.
• TEST: Fix 'Fill' test spreading function
• TEST: Add 'jdbc' test suite
• SQL: Fix problem with BLOBs and CLOBs when data is inserted into a table from a sub-SELECT -- the non-updateable cursor passed into InsertRow prevented proper type conversion of BLOB values.
• SQL: Handle 'log full' condition by aborting the oldest transaction.
• SQL: Fix the implementation of NULLIF, which was erroneously doing the same thing as IFNULL!
• SQL: Got rid of a few locks (Btree.activeCursors, BtreeCursor.staticLock), replacing them with the global file lock, to eliminate possible deadlock conditions.
• SQL: Fixed blob/clob leak.
• SQL: Fixed several end cases regarding consistency checking of foreign key constraints, and operation of foreign key constraints under rollback.

• sql: Streamlined the sync process, eliminating the need to hold a database lock. This removes the deadlock case that got introduced in 2.1.
• sql: Removed a potential deadlock in the BLOB logging logic.
• sql: More work on test framework; a killer one-minute quick-regress, plus more stuff in the large regress than ever. New tests for various end cases: Connection/Statement/ResultSet leaks, reuse of close object, etc.
• sql: Added timeout to lock calls, as a first step toward preventing deadlock (The next thing here is probably some kind of cycle detection logic in the locking layer to prevent any deadlock wait from occurring in the first place.)
• sql: Fixed 'lack-of-qualifier' bug which caused indexes to go into the database without their user/schema prefix
• sql/file: Improve sub-page allocator initialization strategy to work over a wider range of page sizes.
• sql: Ensure transaction numbers aren't reused by using the database root to keep track of transaction id allocations. (We're allocate in blocks of 256 in order to avoid thrashing the root.)

• sql: WITH IDENTITY reared it's ugly head again, with a bug that just missed the 2.1 release. Apologies for the regression here, but the testcase that caught this got missed in the transtion to the new ant-based build/test structure for 2.1....
• sql: Protect against attempt to execute against a closed connection.
• sql: Added a new trace bit to get just Session.doStep() invocations; very useful.

• sql: Rationalization of debugging 'trace' flags
• sql: Fixed bug resulting when deleted rows in a not-yet-committed transaction might get reallocated to another transaction.
• JDBC: 3.0 "compliant" now, meaning that QED compiles against 3.0, even though most of the interesting new features aren't supported.
• Simplify some of the locking logic by reducing the number of objects which can be monitors, eliminating the potential for deadlock. Fully synchronize the database open/close logic as well as all schema manipulation code.
• SAX parser: Replace ParserFactory.makeParser() call with explicit ClassLoader/Class logic to work around problem caused by the bundling of org.xml.sax.ParserFactory with the runtime (being loaded by the boot ClassLoader makes the call to Class.forName() from ParserFactory.makeParser() fail.
• sql: Simplify LazyRow implementation
• sql: Fixed bug in parsing of 64 bit integer literals.
• sql: Optimize temp table implementations to reduce memory allocations
• build system: switched from make to Ant. Long live Ant.

• sql: The big change in this release, and the reason for the change to 2.0 instead of 1.0.4 is the conversion of store addresses from 32 to 64 bits. LAST_INSERT_ID is now also a long, 64 bits.
• sql: Fix "unclosed connections leak" bug, reported by Frantisek Ruzicka.
• sql: Eliminate session state in Expression by removing Expression.execute() and passing session to getValue(). This opens the way to more concurrency, and prevents some possible problems with multiple accessors of the same view.
• Increase default blockSize from 4K to 16K. Increase default cacheSize from 256K to 4M.
• sql: Fixed failures in many common CLOB uses.
• sql: Add missing 'synchronized' to the database close path, to avoid a race if another connection is trying to open.
• sql: Streamlined WITH IDENTITY handling for better efficiency and reliability.
• sql: Streamline database sync logic; force sync on last connection close.
• sql: Add explicit schema locks for schema manipulations such as CREATE TABLE, ALTER TABLE, etc.
• sql: Revamped DROP TABLE to better handle the CASCADE case; fixed several bugs in this path relating to foreign key constraints.
• sql: Fix problem relating to failed recovery of UPDATE operations.
• sql tests: Added new test framework, allowing multi-threaded stress testing using the functional unit tests.

• jdbc: Restructured Connection/Statement implementation to more closely match JDBC's specification for handling of per-Statement ResultSets. This change permits multiple ResultSets to be active simultaneously on different Statements, which didn't work very well before. (This fixes the "nested ResultSet" bug originally reported by David Stoner.)
• jdbc: canonicalize the database path name for comparison, to deal with case insensitive file systems like Windows. Fixes a bug repored by Jaidev Haridas.
• jdbc: overhauled the various ResultSet.getXXX() methods to perform consistent SQL conversions.
• sql: Numerous performance enhancements, particularly in UPDATE statements, SELECT COUNT(*), and transaction commit. Transaction commit in particular is improved by use of a dedicated thread to perform the file syncs.
• sql: Fixed problem with recovery of WITH IDENTITY constraints, reported by Jaidev Haridas.
• sql: Improve handling of INITIALLY DEFERRED constraints.
• sql: Get rid of WeakReference treatment of ResultSets, just let the gc happen.
• sql: Fixed several locking bugs which had led to some over-zealous synchronization. This should improve concurrency and performance generally.
• sql.types: Have mostly beaten INTERVAL into submission. All of the goofy FIPS interval tests now pass. (Does anybody actually use SQL92 intervals?)
• sql.types: Fixed several type conversion bugs in the process of debugging a new, better test for ResultSet.getXXX() methods.
• sql.file: Fixed statement rollback bug that could occur if a log-file rollover caused by sync() had intervened since the beginning of the statement.
• sql.file: Improve the recovery code's ability to find the end of the log file.
• sql.lock: Locks are no longer pooled. This wasn't buying us anything -- now the "LockPool" simply keeps a SoftReference to the lock.
• sql.lock: Fix deadlock problem caused by the LockManager's refusal to promote locks from S to X mode.
• sql: Parser is now more forgiving of extraneous trailing semicolons.
• sql: New connection parameter isCaseSensitive (default true) to provide support for case insensitive applications. This feature is experimental, and may change in future releases. In particular, as we decide to add support for SQL92 COLLATIONs.

• jdbc: JDBC Url syntax now allows for semi-colon separated connection parameters, e.g.: jdbc:qed:db;create=true
• jdbc: Fix problems with handling of null in various ResultSet.getXXX() and PreparedStatement.setXXX() methods.
• sql: catch antlr.TokenStream exception in order to make sure cursors get closed on wierd syntax errors.
• sql: many changes in cursor handling, some streamlining of the internal cursor implementations.
• sql: SQL92: added COALESCE function.
• sql: several interesting join bugs fixed
• sql.types: fixed bug in handling CLOB length.
• sql.types: fixed bugs in interval handling

• sql: Change default lockfile behavior. Given the hassles associated with forgetting to remove a lockfile, we now have a new connection parameter useLockFile, which defaults to false. If you want the old behavior, you must set useLockFile=true in your connection properties.
• sql: Fixes for BlockFile corruption that could be caused by certain patterns of BLOB access. This one has been lurking for a while, and it feels really good to have squashed it!
• jdbc: Implement Statement.setMaxRows().
• jdbc: PreparedStatement.clearParameters() threw a NullPointerException if called for a statement with no formal parameters.
• jdbc: Makee JdbcDriver constructor public.
• app.dbimage: Changes to work under Enhydra.
• app.dbmiage: Dynamic image resizing; caching (in the database) of resized images.

• net.server: Implement stop() methods for all services
• net.server: Implement configurable session logging for debugging
• server: Add support for service initialization parameters in server.xml
• sql: Fix bug where unclosed ResultSet objects could cause havoc when they finally got garbage collected and finalized.
• sql: Fix bug in rollback of 'CREATE TABLE' -- in the case where the table already exists, the rollback shouldn't delete the original table!
• sql: DIGEST function returns VARBINARY now, instead of VARCHAR.
• sql.file: Fixed a multi-thread bug caused by missing 'synchronized' in Log.flush().
• sql.file: Added a main() in sql.file.Log which provides a logfile dumping utility.
• sql.io: Fixed a nasty bug in DataOutputStream which caused sizes to be wrong for BLOBs and many bad things to happen.
• sql.types: Added implicit conversion from strings to date/time/timestamp, even though this doesn't seem to be SQL92 conforming, since everybody seems to expect it to work that way. Maybe we need a STRICT_SQL92 mode.
• sql.types: Fixed bug with VARBINARY items where the bytes could be returned in the wrong order!
• sql.locks: Fixed bug which cause lock table inconsistency (leading to "No lock on parent" RuntimeExceptions) when multiple databases are open simultaneously. Thanks to Finbarr O'Sullivan for finding this and supplying a convenient reproducible testcase.
• http.server22: Request logging is now separate from the rest of the Debug information, going into a new 'web.log' file. This is just an interim solution until a more flexible logging system is put in place.
• http.server22: getRealPath() now deals with attempts to get files outside of the scope of the web application (via, e.g. "../" in the path) and prevents such access.
• sql: Fixed blob refcounting bug introduced by LazyRow optimizations. Thanks to Philip White for a testcase.
• sql, sql.io: The 'Row' class does not need to be externalizable.

• HTTP: fixed some getPathInfo() == null bugs.
• JSP: Get rid of incorrect JspWriter re-initialization on include
• SQL: Clean up temp files, lockfile, reference monitor on database shutdown
• SQL: Fix crash resulting from immediate rollback of very large insert
• SQL: Relax type constraints when comparing strings to other types
• SQL: Fixed bug in ResultSet.getLong()
• SQL: Fix finalizer deadlock that sometimes happened when ResultSets aren't closed.
• SQL: Better handling of null values in PreparedStatement.setXXX() methods.
• Add many javadoc comments
• HTTP: Fix Servlet{In|Out}putStream.close() to not close the underlying socket.
• Switch from IBM XML parser to Quadcap XML SAX parser. Faster and smaller!
• SQL: Revised locking protocol for better performance and to fix a nasty deadlock bug.
• SQL3: New column constraint: WITH IDENTITY
• SQL: New functions, DIGEST and LAST_INSERT_ID
• HTTP: fix bogus cookie date format that caused an exception if user cookies were used.
• HTTP: Fix bug in worker input stream where a client's cancelled request could cause infinite loop in the worker thread.
• HTTP: Implement stub for HttpSession.getSessionContext()
• HTTP: Fix session timeout bug; sessions were not being properly expired
• HTTP: Fix several cases where IllegalStateException should have been throw, but wasn't.
• HTTP: getPathInfo() should return null instead of the empty string if there's no path info. I don't exactly like this, but that's what the spec says to do....
• HTTP: Fix bug where explicit call to HttpResponse.flushBuffer() could cause a response to be sent with a Content-Length of zero.
• HTTP: Make parsing of POSTed form data be lazy, so the request body can be parsed by the user if she wants.
• HTTP: Implement HttpRequest.getRealPath().
• HTTP: Implement HttpRequest.getCharacterEncoding().
• HTTP: Fix HttpRequest.getLocales() to return the default locale if no Accept-Language header was specified.
• HTTP: Better support for HTTP 1.1 Keep-Alive
• HTTP: Supply a default content type if the servlet doesn't specify one.
• HTTP: Don't quote cookie values for version 0 (Netscape) cookies, or for version 1 cookies where the value is a "token"
• HTTP: Fix web classloader bug for classes in WEB-INF/classes/ inside .war-deployed applications.
• HTTP Fix classpath specification for Jikes compiler in the default context.

• New: web-server administrator application, to allow web applications to be loaded, unloaded, reloaded while the server is running.
• New: Image Database sample application.
• New: JNDI-based DataSource lookups
• New Services architecture
• New document: Quadcap Developer Guide.
• Fixed several bugs with BLOBS and large binary rows

• Web server engine upgraded to support Java Servlets 2.2. This offers a lot of new features, and implements the nifty "Web Application Archive" specified in the new Servlet API. Also added support for HTTP/1.1, and did a significant amount of optimization in the core server stack. The thread pool is now expanded dynamically (up to a maximum size), and other changes have been made to improve performance.
• The bug tracking application and the QED Administrator have been repackaged as .war files.
• This release also includes some significant optimizations in the core SQL engine, in object serialization/deserialization, lock management, buffer cache handling, logging, and avoiding recomputations when PreparedStatements are used. Testing shows a 2-3x speedup on many applications.
• Fixed bug in handling of cacheSize database connect property.
• Fixed bugs related to missing type conversions in arithmetic operations.

• The database internal format has changed for 1.0b12. Databases created with previous revisions of QED are incompatible with this release and may need to be rebuilt. You can use the XmlDump/XmlLoad tools to dump your old database in XML format, then reload it using 1.0b12.
• This release primarily performance oriented -- several bottlenecks were identified and eliminated. Full table scans and joins are now much faster.
• Added support for Linux in the installer. QED has been tested on the Linux JDK 1.2.2 RC1 release from Sun.

• Add Create Database function to database status page.
• Add force connection property, to allow a database to be opened even if the lockfile exists. Be careful with this one!
• Website cleanup, fix broken links.
• Bug fixes in the admin 'file browse' dialog.
• Fix bugdb 'logout' operation, so now it actually does log out.
• Fix bugdb NullPointerException if description was null.

• New installer. JDK1.2 QED Web version only
• Fix JOIN on DECIMAL vs INTEGER columns bug.
• Make NUMERIC cast from STRING more robust.
• Implement type conversion from NUMERIC to REAL
• Fix INTERVAL comparison bug.
• Fix "JOIN of GROUP BY" bug.
• Add support for standard SQL-92 SUBSTRING(string FROM start [FOR length]) syntax.
• Generate appropriate SQLException for SUBSTRING errors.
• SELECT table.* does not include join columns.
• Bugdb application now connects with 'create=true' to force creation of database on first use.
• Added 'cacheSize' connection property, to allow configuration of the runtime cache (default value is 256K)
• Fixed several corner cases in key comparison and serialization
• Fixed nasty btree bug that occured when a 127 byte key was inserted into a node with exactly 127 bytes of free space
• Performed Some micro-optimizations in the btree code
• File Servlet improvements:
  • Handle directory fetch as request for index.html
  • Replace file Hashtable with a cache of configurable size.
  • Eliminate temporary file creation

• Remove old scratchfile on startup
• Fix bugs in file open dialog for admin tool
• Site redesign. Thanks, Tyler!

• Changed default database creation behavior. Now, if you want to create a new database, specify the property create=true in the java.util.Properties parameter to DriverManager.getConnection().
• Fix key-comparison bug that caused numbers to collate in the wrong sequence.
• Fix key-comparison bug that caused rows with nulls to always compare equal.
• Optimize SELECT DISTINCT ... ORDER BY ... to merge the DISTINCT and ORDER BY operations.
• Change XmlDump/XmlLoad XML schema to include DDL statements for tables in the database.
• Fix XmlDump/XmlLoad handling of character encodings by using java.io.Reader instead of java.io.InputStream.
• Fix XmlLoad bug that showed up when the SAX parser split the character data for an element into two buffer fragments.
• Fix type conversion confusion with respect to BIT(1) and BOOLEAN types.
• Optimize BETWEEN operator with index access.
• Fix DatabaseMetaData.getImportedKeys(), DatabaseMetaData.getExportedKeys() bug where the wrong table name appeared in column 4.

• Fix JOIN ON bug where a crash happened if the inner table already had an index.
• Improved DISTINCT, ORDER BY implementations so that they use less memory.
• Simple optimization of cross-joins on a common set of columns.
• Optimized key representation and hence all index operations. This is an incompatible change..

• Add support for read-only databases. Controlled by:

  	    mode={r|rw}
  	    scratchDir=directory
  	  

  in the Properties object passed to DriverManager.getConnection() call.
• More fixes in DatabaseMetaData for null or empty schema name patterns
• Fix bug in logging where extra logs would be left behind on a Log.checkpoint() operation, resulting in bogus errors during recovery/restart.
• Optimize UPDATE logging to avoid serializing the new row twice.
• Add buffering to XmlDump, XmlLoad classes, for performance improvements.

• Remove timebomb for paying customers!

• Fixed cursor-related problems introduced in 1.0b3 that resulted in bogus 'Bad column name' errors.
• Fixed DROP TABLE CASCADE bug where the DROP failed if a table was multiply referenced by the same view.
• Fix UNIQUE constraint bug that caused nulls to be handled improperly.
• Fix bug which caused correlation names to mess up name matching in the WHERE clause.
• Implement support for DEFAULT keyword in table value constructors.
• Implemented more type conversions: character strings to all exact and approximate numeric types and intervals, any to fixed length character string (any to variable character already was done).

• Added configurable authentication to QED admin, controlled by properties: qed.admin.user and qed.admin.password
• Ensure that values bound to an HTTP session are correctly unbound when the session is invalidated.
• Fix Content-Length bug that would sometimes cause hangs when reading HTTP request.
• Sometimes IE opens a socket to the server but never issues a request -- just aborts the connection. Silently ignore this strange behavior.
• Improve handling of 404 "Not Found" errors.
• Change default session inactive interval to 6 hours
• Servlet engine no longer sets 'Expires' and 'Connection' headers.
• Clean up HTTP server log format.
• Support 'Location' header in CGIServlet.
• Fix bugs in compile error parsing in JSPServlet.
• Fix NullPointerException in DatabaseMetaData.getColumns when schemaPattern is null.
• Fix several problems related to CLOBs: access via getBytes(), toString(), etc.
• Fix exception during recovery of BLOBs/CLOBs.
• JDK1.1/JDBC1.2 is now supported.
• Big bug in query with sub-query and correlation name
• Improve handling of failures during database creation. If the database can't be created, remove the 'datafile' file.
• RESTRICT, CASCADE now optional for DROP COLUMN, DROP CONSTRAINT.
• Treat VARBINARY types without a maximum length specification as being of unlimited size.
• Don't set a SecurityManager any more.
• Add errorpage directives to all bugdb pages.
• Add authentication checking to all bugdb pages.
• Implement logout for bugdb
• BugSession now implements HttpSessionBindingListener to deal with changes in the status of the session.
• Fix path to Jikes in servlets.properties.

Never publicly released

Initial public release