Quadcap Embeddable Database

com/quadcap/sql/file/Datafile.java

Go to the documentation of this file.

package com.quadcap.sql.file;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.ByteArrayOutputStream;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;

//#ifdef JDK14
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
//#endif

import java.util.HashMap;
import java.util.Iterator;
import java.util.Properties;

import com.quadcap.sql.lock.Lock;
import com.quadcap.sql.lock.LockManager;
import com.quadcap.sql.lock.LockMode;
import com.quadcap.sql.lock.Transaction;
import com.quadcap.sql.lock.TransactionObserver;

import com.quadcap.sql.types.Value;

import com.quadcap.util.collections.LongIterator;
import com.quadcap.util.collections.LongMap;

import com.quadcap.util.ConfigNumber;
import com.quadcap.util.ConfigString;
import com.quadcap.util.Debug;
import com.quadcap.util.Util;
 
/**
 * This class brings together the various file-level components of the
 * structured (SQL) database.
 *
 * @author Stan Bailes
 */
abstract public class Datafile {
    protected boolean                   inMemory = false;
    String                              fileName;
    
    protected DatafileRoot              root;
    File                                dbRootDir;
    File                                tempDir;
    String                              url;
    protected String                    origFileName;

    // "datafile"
    protected BlockFile                 file;

    // "scratch"
    protected BlockFile                 tempFile;


    // "log" file
    Log                                 log;

    // read/write table locks
    LockManager                         locks           = null;

    // Original connection properties
    Properties                          props;

    static {
        try {
            Class.forName("com.quadcap.sql.io.Extern");
        } catch (Throwable t) {}
    }

    /** True if we've locked the lockfile */
    private FileChannel lockChannel                     = null;
    private FileLock    lockLock                        = null;
    
    protected boolean                   readOnly        = false;
    protected byte[]                    temp            = new byte[256];

    protected Object                    fileLock        = new Object();

    private int                         tempFileRefCount = 0;

    abstract public void maybeBackup() throws IOException;
    abstract public void readRoot() throws IOException;
    abstract public void createRoot(String fileName,
                                    Properties props) throws IOException;
    abstract public void flushRoot() throws IOException;
    abstract public long getNextTransId() throws IOException;
    abstract public void bootFromRoot(boolean restart) throws IOException;

    /**
     * Minimum cache size: 256K, with 8K blocks.  The minimum is
     * dependent on various factors, including query type (joins
     * need more cache, for example) and concurrency level.
     *
     * Simple applications which are primarily single threaded will
     * be able to get by with 32 blocks or so.
     */
    static final int MIN_CACHE = 32;

    /**
     * Reasonable cache size: 4MB (8K blocks).  This cache size should
     * support a moderate load; 8-10 busy threads...
     */
    static final int GOOD_CACHE = 256;

    /**
     * Reasonable scratch cache default
     */
    static final int SCRATCH_CACHE_DEFAULT = 64;

    /*{com.quadcap.util.Config-vars.xml-1000}
     * <config-var>
     *   <config-name>qed.blockSize</config-name>
     *   <config-dflt>8192</config-dflt>
     *   <config-desc>The database block size.</config-desc>
     * </config-var>
     */
    static final int                    BLOCK_SIZE
    = ConfigNumber.find("qed.blockSize", Integer.toString(8192)).intValue();
    int                                 blockSize = BLOCK_SIZE;

    /*{com.quadcap.util.Config-vars.xml-1001}
     * <config-var>
     *   <config-name>qed.cacheSize</config-name>
     *   <config-dflt>256 blocks</config-dflt>
     *   <config-desc>The database cache size.  A certain number of blocks
     *      are cached in an LRU cache;  this parameter controls the size
     *      of this cache.  32 is probably a the minimum for a single-threaded
     *      application; more threads increase cache requirements.
     *   </config-desc>
     * </config-var>
     */
    final ConfigNumber          cacheSize
    = ConfigNumber.find("qed.cacheSize", 
                        Integer.toString(GOOD_CACHE * BLOCK_SIZE));
    int                                 CACHE_SIZE =
    Math.max(MIN_CACHE, cacheSize.intValue() / BLOCK_SIZE);

    /*{com.quadcap.util.Config-vars.xml-1002}
     * <config-var>
     *   <config-name>qed.scratchCacheSize</config-name>
     *   <config-dflt>32 blocks</config-dflt>
     *   <config-desc>The "temporary" file cache size.  A certain number of
     *          blocks in the scratch file (used for temporary tables and
     *          indexes) are cached in an LRU cache;  this parameter controls
     *          the size of this cache.
     *   </config-desc>
     * </config-var>
     */
    final ConfigNumber          scratchCacheSize
    = ConfigNumber.find("qed.scratchCacheSize", 
                        Integer.toString(SCRATCH_CACHE_DEFAULT * BLOCK_SIZE));
    int                                 SCRATCH_CACHE_SIZE =
    Math.max(MIN_CACHE, scratchCacheSize.intValue() / BLOCK_SIZE);

    /*{com.quadcap.util.Config-vars.xml-1003}
     * <config-var>
     *   <config-name>qed.defaultMode</config-name>
     *   <config-dflt>rw</config-dflt>
     *   <config-desc>The default database 'mode'.  Either 'r' or 'rw'
     *    </config-desc>
     * </config-var>
     */
    final ConfigString          defaultMode
    = ConfigString.find("qed.defaultMode", "rw");

    /*{com.quadcap.util.Config-vars.xml-1004}
     * <config-var>
     *   <config-name>qed.isCaseSensitive</config-name>
     *   <config-dflt>true</config-dflt>
     *   <config-desc>A boolean flag specifying whether string (VARCHAR)
     *      items are case-sensitive.
     *    </config-desc>
     * </config-var>
     */
    static final ConfigString           caseSensitive
    = ConfigString.find("qed.isCaseSensitive", "true");
    // XXX This should *NOT* be static, but expediency forces it
    // XXX to be so for now.
    public static boolean                             isCaseSensitive =
    caseSensitive.toString().equalsIgnoreCase("true");

    /**
     * Construct a new Datafile object, from the specified filename and mode.
     */

    /*{com.quadcap.sql.Datafile-conn.xml-0}
     *
     * <config>
     */

    /*{com.quadcap.sql.Datafile-conn.xml-999999}
     *
     * </config>
     */

    public Datafile() {
    }

    public void init(String url, String fileName, Properties props)
        throws IOException
    {
        this.fileName = fileName;
        this.inMemory =
            props.getProperty("memoryOnly", "").equalsIgnoreCase("true");
        boolean nullStore =
            props.getProperty("cacheOnly", "").equalsIgnoreCase("true");
        if (inMemory || nullStore) {
            initMemoryDatabase(url, fileName, props);
        } else {
            initFileDatabase(url, fileName, props);
        }
    }
    
    public void initMemoryDatabase(String url, String fileName, Properties props)
        throws IOException
    {
        this.inMemory = true;
        this.props = (Properties)props.clone();
        this.url = url;
        this.origFileName = fileName;
        this.readOnly = false;

        String ics = props.getProperty("isCaseSensitive",
                                      caseSensitive.toString());
        isCaseSensitive = ics.equalsIgnoreCase("true");
        Value.isCaseSensitive = isCaseSensitive;
        String bs = props.getProperty("blockSize");
        if (bs != null) {
            blockSize = Integer.parseInt(bs);
        }
        String cs = props.getProperty("cacheSize");
        if (cs != null) {
            CACHE_SIZE = Integer.parseInt(cs) / blockSize;
        }
        this.locks = new LockManager();

        this.file = new BlockFile(fileName, "rw", props,
                                  blockSize, CACHE_SIZE);
        this.fileLock = this.file.getLock();
        createRoot(fileName, props);
        try {
            this.log = new Log3();
        } catch (Throwable t) {
            throw new DatafileException("Error creating logger", t);
        }
        log.init(this, true, props);
        file.setLog(log);

        //log.restoreBlocks();
        bootFromRoot(false);
    }    

    public void initFileDatabase(String url, String fileName, Properties props)
        throws IOException
    {
        this.props = (Properties)props.clone();
        this.url = url;
        this.origFileName = fileName;
        fileName = new File(fileName).getAbsolutePath();
        this.dbRootDir = new File(fileName);
        boolean newDb = false;
        /*{com.quadcap.sql.Datafile-conn.xml-10}
         * <config-var>
         *   <config-name>mode</config-name>
         *   <config-dflt>from Config: qed.defaultMode</config-dflt>
         *   <config-desc>Read-only or read-write access to the database:
         *      <ul>
         *        <li><code><b>rw</b></code>: Read-write (the default)</li>
         *        <li><code><b>r</b></code>:
         *            Read-only, intended for deployment on read-only media
         *        </li>
         *      </ul>
         *   </config-desc>
         * </config-var>
         */
        String mode = props.getProperty("mode", defaultMode.toString());
        this.readOnly = mode.equalsIgnoreCase("r");

        /*{com.quadcap.sql.Datafile-conn.xml-11}
         * <config-var>
         *   <config-name>isCaseSensitive</config-name>
         *   <config-dflt>from Config: qed.isCaseSensitive</config-dflt>
         *   <config-desc>A boolean flag specifying whether string (VARCHAR)
         *      items are case-sensitive.
         *   </config-desc>
         * </config-var>
         */
        String ics = props.getProperty("isCaseSensitive",
                                      caseSensitive.toString());
        isCaseSensitive = ics.equalsIgnoreCase("true");
        Value.isCaseSensitive = isCaseSensitive;

        
        /*{com.quadcap.sql.Datafile-conn.xml-12}
         * <config-var>
         *   <config-name>create</config-name>
         *   <config-dflt>false</config-dflt>
         *   <config-desc>If <code>"true"</code>, the database will be
         *      created if it doesn't already exist. 
         *   </config-desc>
         * </config-var>
         */
        String create = props.getProperty("create", "false");
        if (!dbRootDir.isDirectory()) {
            if (readOnly) {
                throw new IOException("Can't open database: " + fileName);
            }
            if (!create.equalsIgnoreCase("true")) {
                throw new IOException("Can't open database: " + fileName);
            }
            newDb = true;
            if (!dbRootDir.mkdirs()) {
                throw new IOException("Can't create directory: " + fileName);
            }
        }

        /*{com.quadcap.sql.Datafile-conn.xml-13}
         * <config-var>
         *   <config-name>blockSize</config-name>
         *   <config-dflt>from Config:
         *                qed.blockSize</config-dflt>
         *   <config-desc>The database block size, which must be a
         *      power of two.
         *      Maximum size: 32768, Minimum recommended size: 4096.
         *   </config-desc>
         * </config-var>
         */
        String bs = props.getProperty("blockSize");
        if (bs != null) {
            blockSize = Integer.parseInt(bs);
        }


        /*{com.quadcap.sql.Datafile-conn.xml-14}
         * <config-var>
         *   <config-name>cacheSize</config-name>
         *   <config-dflt>from Config:
         *                qed.cacheSize</config-dflt>
         *   <config-desc>The database cache size.  A certain number of blocks
         *      are cached in an LRU cache;  this parameter controls the size
         *      of this cache.</config-desc>
         * </config-var>
         */
        String cs = props.getProperty("cacheSize");
        if (cs != null) {
            CACHE_SIZE = Integer.parseInt(cs) / blockSize;
        }

        /*{com.quadcap.sql.Datafile-conn.xml-15}
         * <config-var>
         *   <config-name>scratchCacheSize</config-name>
         *   <config-dflt>from Config:
         *                qed.scratchCacheSize</config-dflt>
         *   <config-desc>The database scratch cache size, used for caching access
         *      to the database temporary (or "scratch") file.
         *      A certain number of blocks are cached in an LRU cache;
         *      this parameter controls the size
         *      of this cache.</config-desc>
         * </config-var>
         */
        String scs = props.getProperty("scratchCacheSize");
        if (scs != null) {
            SCRATCH_CACHE_SIZE = Integer.parseInt(scs) / blockSize;
        }

        /*{com.quadcap.sql.Datafile-conn.xml-16}
         * <config-var>
         *   <config-name>useLockFile</config-name>
         *   <config-dflt>true</config-dflt>
         *   <config-desc>A boolean.  If <b>true</b>, a lock file will
         *      be used to protect from database corruption which might
         *      result from multiple processes accessing the same database
         *      simultaneously.</config-desc>
         * </config-var>
         */
        String lf = props.getProperty("useLockFile", "true");
        boolean useLockFile = lf.equalsIgnoreCase("true");

        try {
            File g = new File(dbRootDir, "datafile");
            if (!g.exists()) {
                if (readOnly) {
                    throw new IOException("Can't open database: " + fileName);
                }
                newDb = true;
            }
            
            if (!readOnly && useLockFile) {
                File k = new File(dbRootDir, "lockfile");
                //#ifdef JDK14
                lockChannel = new RandomAccessFile(k, "rw").getChannel();
                lockLock = lockChannel.tryLock();
                if (lockLock == null) {
                    /*{com.quadcap.sql.Datafile-conn.xml-18}
                     * <config-var>
                     *   <config-name>force</config-name>
                     *   <config-dflt>false</config-dflt>
                     *   <config-desc>QED uses a lockfile to prevent multiple
                     *      JVMs from accessing the database files
                     *      simultaneously, which could lead to database
                     *      corruption.  When the JVM exits normally, this
                     *      lockfile is deleted.  If the JVM exits abnormally
                     *      the lockfile may be left behind, and subsequent
                     *      attempts to access the database will fail because
                     *      of the old lockfile.  If <b>force</b> is
                     *      <code>true</code>, the database connection will
                     *      succeed even if the lockfile is present.
                     *      This option should be used with extreme care,
                     *      since if there really is another process accessing
                     *      the database, corruption may result.</config-desc>
                     * </config-var>
                     */
                    String force = props.getProperty("force", "false");
                    if (!force.equalsIgnoreCase("true")) {
                        throw new IOException(
                            "lockfile already exists.  Maybe another " +
                            "process is accessing the database?");
                    }
                }
                //#endif
            }
            makeTempDirectory(props);
            this.locks = new LockManager();

            String gFileName = g.getAbsolutePath();
            this.file = new BlockFile(gFileName, mode, props,
                                      blockSize, CACHE_SIZE);
            this.fileLock = this.file.getLock();
            if (!newDb) {
                try {
                    readRoot();
                } catch (IOException ex) {
                    if (ex.toString().indexOf("magic") > 0) {
                        throw new IOException("Database Connection Failed: Possible bad authorization");
                    } else {
                        throw ex;
                    }
                }
            } else {
                createRoot(fileName, props);
            }
            if (!readOnly) {
                /*{com.quadcap.sql.Datafile-conn.xml-20}
                 * <config-var>
                 *   <config-name>logger</config-name>
                 *   <config-dflt>2</config-dflt>
                 *   <config-desc>If no transaction logging is required
                 *   (i.e., no rollback or recovery), then use '0'.
                 *   Otherwise, use '2', (the default)</config-desc>
                 * </config-var>
                 */
                String ls = props.getProperty("logger");
                if (ls == null) ls = "2";
                this.log = (Log)(
                    Class.forName("com.quadcap.sql.file.Log" + ls).
                    newInstance());
                log.init(this, newDb, props);
                file.setLog(log);
                if (!newDb) {
                    log.restoreBlocks();
                    file.revert();
                }
            }
            bootFromRoot(!newDb);
            if (!newDb) {
                log.restart();
            }
            if (!readOnly) {
                log.start();
            }
            log.checkpoint();
        } catch (IOException e) {
            if (newDb && !readOnly) deleteHalfBakedDir();
            throw e;
        } catch (RuntimeException e) {
            if (newDb && !readOnly) deleteHalfBakedDir();
            throw new DatafileException(e);
        } catch (Exception e) {
            if (newDb && !readOnly) deleteHalfBakedDir();
            throw new DatafileException(e);
        }
    }

    // i am a factor.  but at least I have a name!
    final private void deleteHalfBakedDir() {
        new File(dbRootDir, "datafile").delete();
        new File(dbRootDir, "lockfile").delete();
    }

    /**
     * Accessor for my underlying file
     */
    public BlockFile getFile() { return file; }

    /**
     * Return the JDBC URL used to connect to this database.
     */
    public String getURL() { return url; }

    /**
     * Return a File representing the database root directory
     */
    File getDbRootDir() { return dbRootDir; }

    /**
     * Return a File representing the database scratch/temp root directory
     */
    File getScratchDir() { return tempDir; }

    /**
     * Accessor for the datbase's lock manager
     */
    public LockManager getLockManager() { return locks; }

    /**
     * Accessor for file lock
     */
    public Object getFileLock() { return fileLock; }

    /**
     * Is db read only?
     */
    public boolean isReadOnly() { return readOnly; }

    /**
     * Return the specified persistent object from the store
     * @param ref the block number of the object's root
     * @return the object
     * @exception IOException may be thrown
     */
    public Object getObject(long ref) throws IOException {
        return file.getObject(ref);
    }


    /**
     * Write a new object to the store and return its reference
     * @param obj the object
     * @return the block number of the object's root
     * @exception IOException may be thrown
     */
    public long putObject(Object obj) throws IOException {
        return file.putObject(obj);
    }

    /**
     * Write a new version of a persistent object to the store.
     * @param blockNum the address of the object's root page in the store
     * @param obj the new object value
     *
     * @exception IOException may be thrown
     */
    public void updateObject(long seg, Object obj) throws IOException {
        file.updateObject(seg, obj);
    }

    /**
     * Remove an object from the store
     * @param ref the block number of the object's root
     *
     * @exception IOException may be thrown
     */
    public void removeObject(long ref) throws IOException {
        file.removeObject(ref);
    }


    /**
     * Hook which allows the scratch files to be written to a separate
     * directory.  Useful when you want to mount the data files read only
     */
    final void makeTempDirectory(Properties props) throws IOException {
        /*{com.quadcap.sql.Datafile-conn.xml-22}
         * <config-var>
         *   <config-name>scratchDir</config-name>
         *   <config-dflt><i>database directory</i></config-dflt>
         *   <config-desc>
         *      Specify the directory where scratch files are written.  This
         *      option is most useful in conjunction with <code>mode=r</code>,
         *      where the database files can be located on read-only media,
         *      and the scratch directory can be located separately.
         *   </config-desc>
         * </config-var>
         */
        if (!inMemory) {
            String tmpDirName = props.getProperty("scratchDir",
                                                  dbRootDir.getAbsolutePath());
            this.tempDir = new File(tmpDirName);
            if (!tempDir.isDirectory()) {
                if (!tempDir.mkdirs()) {
                    throw new IOException("Can't create temp directory: " +
                                          tmpDirName);
                }
            }
        }
    }

    /**
     * The temporary file can be used for storage of non-transactionally-secure
     * data
     */
    public BlockFile getTempFile() throws IOException {
        return getTempFile(true);
    }
    
    public BlockFile getTempFile(boolean incr) throws IOException {
        synchronized (fileLock) {
            if (tempFile == null) {
                if (inMemory) {
                    this.tempFile = new BlockFile(fileName + ".scratch", "rw",
                                                  props, blockSize, SCRATCH_CACHE_SIZE);
                } else {
                    File f = new File(tempDir, "scratch");
                    this.tempFile = new BlockFile(f.getAbsolutePath(), "rw",
                                                  props,
                                                  blockSize,
                                                  SCRATCH_CACHE_SIZE);
                }
                this.tempFileRefCount = 0;
            }
            //Debug.println("Datafile.getTempFile(" + tempFileRefCount +
            //              (incr ? (" -> " + (tempFileRefCount+1)) : "") +
            //              ") @\n" + Util.stackTrace());
            if (incr) tempFileRefCount++;
        }
        return tempFile;
    }

    public void releaseTempFile() {
        synchronized (fileLock) {
            //Debug.println("Datafile.releaseTempFile(" + tempFileRefCount +
            //              " -> " + (tempFileRefCount-1) + ") @\n" +
            //              Util.stackTrace());
            if (--tempFileRefCount == 0) {
                clearTempFile();
            }
        }
    }

    /**
     * When nothing is happening, get rid of this guy.  Who needs him, eh?
     */
    void clearTempFile() {
        if (tempFile != null) {
            //Debug.println("clearTempFile"); // XXX
            if (inMemory) {
                tempFile = null;
            } else if (true) {
                try {
                    tempFile.close();
                } catch (Throwable e8) {
                } finally {
                    tempFile = null;
                }
                try {
                    new File(dbRootDir, "scratch").delete();
                } catch (Throwable e9) {
                }
            }
        }
    }

    /**
     * Close the database.  Sync and close the physical file(s),
     * delete the tempfile(s) and lockfile.  Kill the database
     * reference monitor thread.
     */
    public void close() {
        if (file != null) {
            //#ifdef TRACE
            if (Trace.bit(12)) {
                Debug.println("Datafile.close(" + dbRootDir.getPath() + ")");
            }
            //#endif
            try {
                if (log != null) {
                    log.checkpoint();
                    log.sync();
                    log.close();
                    log.remove();
                }
            } catch (Throwable e8) {
                Debug.print(e8);
            } finally {
                log = null;
            }

            clearTempFile();
            
            try {
                if (file != null) file.close();
            } catch (Throwable e2) {
            }

            file = null;
            try {
                //#ifdef JDK14
                if (lockLock != null) {
                    lockLock.release();
                    if (lockChannel != null) lockChannel.close();
                    //new File(dbRootDir, "lockfile").delete();
                }
                //#endif
            } catch (Throwable t) {
            } finally {
                //#ifdef JDK14
                lockLock = null;
                lockChannel = null;
                //#endif
            }
        }
    }

    /**
     * Helper to create a new transaction, and optionally to write the
     * BEGIN_TRANSACTION log entry.
     */
    public final Transaction makeTransaction(boolean writeLog)
        throws IOException
    {
        Transaction trans = null;
        long transId = -1;
        synchronized (fileLock) {
            transId = getNextTransId();
            trans = locks.getTransaction(transId);
        }
        if (writeLog) {
            log.addEntry(new LogEntry(transId,
                                      LogEntry.BEGIN_TRANSACTION));
        }
        return trans;
    }

    /**
     * Commit the transaction
     */
    public void commitTransaction(Transaction trans) throws IOException {
        long transId = trans.getTransactionId();
        log.addEntry(new LogEntry(transId, LogEntry.COMMIT));
        log.flushLog();
        releaseLocks(trans);
    }
    
    /**
     * Rollback the transaction
     */
    public void rollbackTransaction(Transaction trans)
        throws IOException
    {
        log.rollbackTransaction(trans);
        commitTransaction(trans);
    }
    
    /**
     * Rollback the specified statement.
     */
    public void rollbackStatement(Transaction trans, int stmtId)
        throws IOException
    {
        log.rollbackStatement(trans, stmtId);
    }
    
    /**
     * Remove the transaction for the given connection from the
     * 'active transactions' table.  Flush the log?
     */
    public void releaseLocks(Transaction trans) {
        locks.releaseTransaction(trans);
    }

    /**
     * Find the specified transaction
     */
    public Transaction findTransaction(long transId) throws IOException {
        Transaction t = locks.findTransaction(transId);
        return t;
    }

    /**
     * Return the log for this database
     */
    public final Log getLog() { return log; }

    /**
     * If we get finalized, and haven't closed yet, then we should try.
     */
    public void finalize() throws Throwable {
        close();
        super.finalize();
    }

    /**
     * Return the total size of the datafile, in bytes
     */
    public long getSize() {
        return file.getSize();
    }

    /**
     * Reset the temp file (on checkpoint)
     */
    public void checkpoint(boolean truncate, boolean fastSync)
        throws IOException
    {
        synchronized (fileLock) {
            if (tempFile != null) {
                tempFile.flush(fastSync);
            }
        }
    }

    public void checkpointHandler(LongMap activeTransactions)
        throws IOException
    {
    }
    
    //#ifdef DEBUG
    /**
     * Return a displayable representation for debugging purposes
     */
    public String toString() {
        String u = url;
        if (u.startsWith("jdbc:qed:")) u = u.substring(9);
        int idx = u.indexOf(';');
        if (idx > 0) u = u.substring(0, idx);           
        return u;
    }
    //#endif

    public void doStep(Transaction t, LogEntry e)
        throws IOException, DatafileException
    {
        log.addEntry(e);
        e.redo(t, this);
    }

    public boolean inRecovery() throws IOException {
        return log != null && log.inRecovery();
    }

}