Examples with Cache org.h2.util.Cache used on opensource projects

Example 36 with Cache

use of org.h2.util.Cache in project jackrabbit-oak by apache.

the class PersistentCache method createMapFactory.

private MapFactory createMapFactory(final int generation, final boolean readOnly) {
    MapFactory f = new MapFactory() {

        final String fileName = getFileName(generation);

        MVStore store;

        @Override
        void openStore() {
            if (store != null) {
                return;
            }
            MVStore.Builder builder = new MVStore.Builder();
            try {
                if (compress) {
                    builder.compress();
                }
                if (manualCommit) {
                    builder.autoCommitDisabled();
                }
                if (fileName != null) {
                    builder.fileName(fileName);
                }
                if (memCache >= 0) {
                    builder.cacheSize(memCache);
                }
                if (readOnly) {
                    builder.readOnly();
                }
                if (maxSizeMB < 10) {
                    builder.cacheSize(maxSizeMB);
                }
                if (autoCompact >= 0) {
                    builder.autoCompactFillRate(autoCompact);
                }
                builder.backgroundExceptionHandler(new Thread.UncaughtExceptionHandler() {

                    @Override
                    public void uncaughtException(Thread t, Throwable e) {
                        exceptionCount++;
                        LOG.debug("Error in the background thread of the persistent cache", e);
                        LOG.warn("Error in the background thread of the persistent cache: " + e);
                    }
                });
                store = builder.open();
                if (appendOnly) {
                    store.setReuseSpace(false);
                }
            } catch (Exception e) {
                exceptionCount++;
                LOG.warn("Could not open the store " + fileName, e);
            }
        }

        @Override
        synchronized void closeStore() {
            if (store == null) {
                return;
            }
            boolean compact = compactOnClose;
            try {
                if (store.getFileStore().isReadOnly()) {
                    compact = false;
                }
                // clear the interrupted flag, if set
                Thread.interrupted();
                store.close();
            } catch (Exception e) {
                exceptionCount++;
                LOG.debug("Could not close the store", e);
                LOG.warn("Could not close the store: " + e);
                store.closeImmediately();
            }
            if (compact) {
                try {
                    MVStoreTool.compact(fileName, true);
                } catch (Exception e) {
                    exceptionCount++;
                    LOG.debug("Could not compact the store", e);
                    LOG.warn("Could not compact the store: " + e);
                }
            }
            store = null;
        }

        @Override
        <K, V> Map<K, V> openMap(String name, Builder<K, V> builder) {
            try {
                if (builder == null) {
                    return store.openMap(name);
                }
                return store.openMap(name, builder);
            } catch (Exception e) {
                exceptionCount++;
                LOG.warn("Could not open the map", e);
                return null;
            }
        }

        @Override
        long getFileSize() {
            try {
                if (store == null) {
                    return 0;
                }
                FileStore fs = store.getFileStore();
                if (fs == null) {
                    return 0;
                }
                return fs.size();
            } catch (Exception e) {
                exceptionCount++;
                LOG.warn("Could not retrieve the map size", e);
                return 0;
            }
        }
    };
    f.openStore();
    return f;
}

Example 37 with Cache

use of org.h2.util.Cache in project h2database by h2database.

the class Session method prepareLocal.

/**
 * Parse and prepare the given SQL statement.
 * This method also checks if the connection has been closed.
 *
 * @param sql the SQL statement
 * @return the prepared statement
 */
public Command prepareLocal(String sql) {
    if (closed) {
        throw DbException.get(ErrorCode.CONNECTION_BROKEN_1, "session closed");
    }
    Command command;
    if (queryCacheSize > 0) {
        if (queryCache == null) {
            queryCache = SmallLRUCache.newInstance(queryCacheSize);
            modificationMetaID = database.getModificationMetaId();
        } else {
            long newModificationMetaID = database.getModificationMetaId();
            if (newModificationMetaID != modificationMetaID) {
                queryCache.clear();
                modificationMetaID = newModificationMetaID;
            }
            command = queryCache.get(sql);
            if (command != null && command.canReuse()) {
                command.reuse();
                return command;
            }
        }
    }
    Parser parser = new Parser(this);
    try {
        command = parser.prepareCommand(sql);
    } finally {
        // we can't reuse sub-query indexes, so just drop the whole cache
        subQueryIndexCache = null;
    }
    command.prepareJoinBatch();
    if (queryCache != null) {
        if (command.isCacheable()) {
            queryCache.put(sql, command);
        }
    }
    return command;
}

Example 38 with Cache

use of org.h2.util.Cache in project h2database by h2database.

the class TableView method recompile.

/**
 * Re-compile the view query and all views that depend on this object.
 *
 * @param session the session
 * @param force if exceptions should be ignored
 * @param clearIndexCache if we need to clear view index cache
 * @return the exception if re-compiling this or any dependent view failed
 *         (only when force is disabled)
 */
public synchronized DbException recompile(Session session, boolean force, boolean clearIndexCache) {
    try {
        compileViewQuery(session, querySQL, false, getName());
    } catch (DbException e) {
        if (!force) {
            return e;
        }
    }
    ArrayList<TableView> dependentViews = new ArrayList<>(getDependentViews());
    initColumnsAndTables(session, false);
    for (TableView v : dependentViews) {
        DbException e = v.recompile(session, force, false);
        if (e != null && !force) {
            return e;
        }
    }
    if (clearIndexCache) {
        clearIndexCaches(database);
    }
    return force ? null : createException;
}

Example 39 with Cache

use of org.h2.util.Cache in project h2database by h2database.

the class PageStore method recover.

/**
 * Run recovery.
 *
 * @return whether the transaction log was empty
 */
private boolean recover() {
    trace.debug("log recover");
    recoveryRunning = true;
    boolean isEmpty = true;
    isEmpty &= log.recover(PageLog.RECOVERY_STAGE_UNDO);
    if (reservedPages != null) {
        for (int r : reservedPages.keySet()) {
            if (trace.isDebugEnabled()) {
                trace.debug("reserve " + r);
            }
            allocatePage(r);
        }
    }
    isEmpty &= log.recover(PageLog.RECOVERY_STAGE_ALLOCATE);
    openMetaIndex();
    readMetaData();
    isEmpty &= log.recover(PageLog.RECOVERY_STAGE_REDO);
    boolean setReadOnly = false;
    if (!database.isReadOnly()) {
        if (log.getInDoubtTransactions().isEmpty()) {
            log.recoverEnd();
            int firstUncommittedSection = getFirstUncommittedSection();
            log.removeUntil(firstUncommittedSection);
        } else {
            setReadOnly = true;
        }
    }
    PageDataIndex systemTable = (PageDataIndex) metaObjects.get(0);
    isNew = systemTable == null;
    for (PageIndex index : metaObjects.values()) {
        if (index.getTable().isTemporary()) {
            // temporary indexes are removed after opening
            if (tempObjects == null) {
                tempObjects = new HashMap<>();
            }
            tempObjects.put(index.getId(), index);
        } else {
            index.close(pageStoreSession);
        }
    }
    allocatePage(PAGE_ID_META_ROOT);
    writeIndexRowCounts();
    recoveryRunning = false;
    reservedPages = null;
    writeBack();
    // clear the cache because it contains pages with closed indexes
    cache.clear();
    freeLists.clear();
    metaObjects.clear();
    metaObjects.put(-1, metaIndex);
    if (setReadOnly) {
        database.setReadOnly(true);
    }
    trace.debug("log recover done");
    return isEmpty;
}

Example 40 with Cache

use of org.h2.util.Cache in project h2database by h2database.

the class PageDataOverflow method moveTo.

@Override
public void moveTo(Session session, int newPos) {
    // load the pages into the cache, to ensure old pages
    // are written
    Page parent = store.getPage(parentPageId);
    if (parent == null) {
        throw DbException.throwInternalError();
    }
    PageDataOverflow next = null;
    if (nextPage != 0) {
        next = (PageDataOverflow) store.getPage(nextPage);
    }
    store.logUndo(this, data);
    PageDataOverflow p2 = PageDataOverflow.create(store, newPos, type, parentPageId, nextPage, data, start, size);
    store.update(p2);
    if (next != null) {
        next.setParentPageId(newPos);
        store.update(next);
    }
    if (parent instanceof PageDataOverflow) {
        PageDataOverflow p1 = (PageDataOverflow) parent;
        p1.setNext(getPos(), newPos);
    } else {
        PageDataLeaf p1 = (PageDataLeaf) parent;
        p1.setOverflow(getPos(), newPos);
    }
    store.update(parent);
    store.free(getPos());
}