Database.java

package com.ladybugdb;

/**
 * The Database class is the main class of LbugDB. It manages all database
 * components.
 */
public class Database implements AutoCloseable {
    long db_ref;
    String db_path;
    long buffer_size;
    long max_db_size;
    boolean enableCompression = true;
    boolean destroyed = false;
    boolean readOnly = false;
    boolean autoCheckpoint = true;
    boolean throwOnWalReplayFailure = true;
    boolean enableChecksums = true;
    boolean enableMultiWrites = true;
    boolean enableDefaultHashIndex = true;
    long max_num_threads;
    long checkpointThreshold;

    /**
     * Creates a database object. The database will be created in memory with
     * default settings.
     */
    public Database() {
        this("");
    }

    /**
     * Creates a database object.
     *
     * @param databasePath: Database path. If the database does not already exist,
     *                      it will be created.
     */
    public Database(String databasePath) {
        this.db_path = databasePath;
        this.buffer_size = 0;
        this.max_num_threads = 0;
        this.max_db_size = 0;
        this.checkpointThreshold = -1;
        db_ref = Native.lbugDatabaseInit(databasePath, 0, true, false, max_db_size,
                autoCheckpoint, checkpointThreshold, throwOnWalReplayFailure, enableChecksums);
    }

    /**
     * Creates a database object.
     *
     * @param databasePath: Database path. If the path is empty, or equal to
     *                      `:memory:`, the database will be created in memory.
     * @param systemConfig: Runtime database configuration.
     */
    public Database(String databasePath, SystemConfig systemConfig) {
        this(databasePath, systemConfig.bufferPoolSize, systemConfig.maxNumThreads,
                systemConfig.enableCompression, systemConfig.readOnly, systemConfig.maxDBSize,
                systemConfig.autoCheckpoint, systemConfig.checkpointThreshold,
                systemConfig.throwOnWalReplayFailure, systemConfig.enableChecksums,
                systemConfig.enableMultiWrites, systemConfig.enableDefaultHashIndex);
    }

    /**
     * Creates a database object.
     *
     * @param databasePath:             Database path. If the path is empty, or equal to
     *                                  `:memory:`, the database will be created in
     *                                  memory.
     * @param bufferPoolSize:           Max size of the buffer pool in bytes.
     * @param enableCompression:        Enable compression in storage.
     * @param readOnly:                 Open the database in READ_ONLY mode.
     * @param maxDBSize:                The maximum size of the database in bytes. Note
     *                                  that this is introduced
     *                                  temporarily for now to get around with the default
     *                                  8TB mmap address space limit some
     *                                  environment.
     * @param autoCheckpoint            If true, the database will automatically
     *                                  checkpoint when the size of
     *                                  the WAL file exceeds the checkpoint threshold.
     * @param checkpointThreshold       The threshold of the WAL file size in bytes. When
     *                                  the size of the
     *                                  WAL file exceeds this threshold, the database will
     *                                  checkpoint if autoCheckpoint is true.
     * @param throwOnWalReplayFailure   If true, any WAL replaying failure when loading the database
     *                                  will throw an error. Otherwise, Lbug will silently ignore
     *                                  the failure and replay up to where the error occured.
     * @param enableChecksums           If true, the database will use checksums to detect
     *                                  corruption in the WAL file.
     */
    public Database(String databasePath, long bufferPoolSize, boolean enableCompression, boolean readOnly,
            long maxDBSize, boolean autoCheckpoint, long checkpointThreshold, boolean throwOnWalReplayFailure, boolean enableChecksums) {
        this.db_path = databasePath;
        this.buffer_size = bufferPoolSize;
        this.max_num_threads = 0;
        this.enableCompression = enableCompression;
        this.readOnly = readOnly;
        this.max_db_size = maxDBSize;
        this.autoCheckpoint = autoCheckpoint;
        this.checkpointThreshold = checkpointThreshold;
        this.throwOnWalReplayFailure = throwOnWalReplayFailure;
        this.enableChecksums = enableChecksums;
        db_ref = Native.lbugDatabaseInit(databasePath, bufferPoolSize, enableCompression, readOnly,
                maxDBSize, autoCheckpoint, checkpointThreshold, throwOnWalReplayFailure,
                enableChecksums);
    }

    /**
     * Creates a database object.
     *
     * @param databasePath             Database path. If the path is empty, or equal to
     *                                 `:memory:`, the database will be created in memory.
     * @param bufferPoolSize           Max size of the buffer pool in bytes.
     * @param maxNumThreads            The maximum number of threads available to the database.
     * @param enableCompression        Enable compression in storage.
     * @param readOnly                 Open the database in READ_ONLY mode.
     * @param maxDBSize                The maximum size of the database in bytes.
     * @param autoCheckpoint           If true, the database will automatically checkpoint.
     * @param checkpointThreshold      The threshold of the WAL file size in bytes.
     * @param throwOnWalReplayFailure  If true, WAL replay failures raise an error.
     * @param enableChecksums          If true, WAL and storage page checksums are enabled.
     * @param enableMultiWrites        If true, multiple concurrent write transactions are allowed.
     * @param enableDefaultHashIndex   If true, node tables create the default primary-key hash index.
     */
    public Database(String databasePath, long bufferPoolSize, long maxNumThreads,
            boolean enableCompression, boolean readOnly, long maxDBSize, boolean autoCheckpoint,
            long checkpointThreshold, boolean throwOnWalReplayFailure, boolean enableChecksums,
            boolean enableMultiWrites, boolean enableDefaultHashIndex) {
        this.db_path = databasePath;
        this.buffer_size = bufferPoolSize;
        this.max_num_threads = maxNumThreads;
        this.enableCompression = enableCompression;
        this.readOnly = readOnly;
        this.max_db_size = maxDBSize;
        this.autoCheckpoint = autoCheckpoint;
        this.checkpointThreshold = checkpointThreshold;
        this.throwOnWalReplayFailure = throwOnWalReplayFailure;
        this.enableChecksums = enableChecksums;
        this.enableMultiWrites = enableMultiWrites;
        this.enableDefaultHashIndex = enableDefaultHashIndex;
        db_ref = Native.lbugDatabaseInitExtended(databasePath, bufferPoolSize, maxNumThreads,
                enableCompression, readOnly, maxDBSize, autoCheckpoint, checkpointThreshold,
                throwOnWalReplayFailure, enableChecksums, enableMultiWrites,
                enableDefaultHashIndex);
    }

    /**
     * Checks if the database instance has been destroyed.
     *
     * @throws RuntimeException If the database instance is destroyed.
     */
    private void checkNotDestroyed() {
        if (destroyed)
            throw new RuntimeException("Database has been destroyed.");
    }

    /**
     * Close the database and release the underlying resources. This method is
     * invoked automatically on objects managed by the try-with-resources statement.
     *
     * @throws RuntimeException If the database instance has been
     *                                     destroyed.
     */
    @Override
    public void close() {
        destroy();
    }

    /**
     * Destroy the database instance.
     *
     * @throws RuntimeException If the database instance has been
     *                                     destroyed.
     */
    private void destroy() {
        checkNotDestroyed();
        Native.lbugDatabaseDestroy(this);
        destroyed = true;
    }
}