import org.h2.mvstore.MVMap; //导入依赖的package包/类
static MVStore createSecurely(MVStore.Builder builder, String userId, String password) {
    MVStore store = builder.open();

    try {
        if (!isNullOrEmpty(password) && !isNullOrEmpty(userId)) {
            byte[] salt = getNextSalt();
            byte[] hash = hash(password.toCharArray(), salt);
            UserCredential userCredential = new UserCredential();
            userCredential.setPasswordHash(hash);
            userCredential.setPasswordSalt(salt);

            MVMap<String, UserCredential> userMap = store.openMap(USER_MAP);
            userMap.put(userId, userCredential);
        }
    } finally {
        if (store != null) {
            store.commit();
        }
    }

    return store;
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
/**
 * Remove all temporary maps.
 *
 * @param objectIds the ids of the objects to keep
 */
public void removeTemporaryMaps(BitField objectIds) {
    for (String mapName : store.getMapNames()) {
        if (mapName.startsWith("temp.")) {
            MVMap<?, ?> map = store.openMap(mapName);
            store.removeMap(map);
        } else if (mapName.startsWith("table.") || mapName.startsWith("index.")) {
            int id = Integer.parseInt(mapName.substring(1 + mapName.indexOf(".")));
            if (!objectIds.get(id)) {
                ValueDataType keyType = new ValueDataType(null, null, null);
                ValueDataType valueType = new ValueDataType(null, null, null);
                Transaction t = transactionStore.begin();
                TransactionMap<?, ?> m = t.openMap(mapName, keyType, valueType);
                transactionStore.removeMap(m);
                t.commit();
            }
        }
    }
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private MVMap<Value, Value> openMap(String mapName) {
    int[] sortTypes = new int[keyColumns];
    for (int i = 0; i < indexColumns.length; i++) {
        sortTypes[i] = indexColumns[i].sortType;
    }
    sortTypes[keyColumns - 1] = SortOrder.ASCENDING;
    ValueDataType keyType = new ValueDataType(
            database.getCompareMode(), database, sortTypes);
    ValueDataType valueType = new ValueDataType(null, null, null);
    MVMap.Builder<Value, Value> builder =
            new MVMap.Builder<Value, Value>().keyType(keyType).valueType(valueType);
    MVMap<Value, Value> map = database.getMvStore().
            getStore().openMap(mapName, builder);
    if (!keyType.equals(map.getKeyType())) {
        throw DbException.throwInternalError("Incompatible key type");
    }
    return map;
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
/**
 * Create a new transaction store.
 *
 * @param store the store
 * @param dataType the data type for map keys and values
 */
public TransactionStore(MVStore store, DataType dataType) {
    this.store = store;
    this.dataType = dataType;
    preparedTransactions = store.openMap("openTransactions",
            new MVMap.Builder<Integer, Object[]>());
    VersionedValueType oldValueType = new VersionedValueType(dataType);
    ArrayType undoLogValueType = new ArrayType(new DataType[]{
            new ObjectDataType(), dataType, oldValueType
    });
    MVMap.Builder<Long, Object[]> builder =
            new MVMap.Builder<Long, Object[]>().
            valueType(undoLogValueType);
    undoLog = store.openMap("undoLog", builder);
    if (undoLog.getValueType() != undoLogValueType) {
        throw DataUtils.newIllegalStateException(
                DataUtils.ERROR_TRANSACTION_CORRUPT,
                "Undo map open with a different value type");
    }
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
/**
 * Initialize the store. This is needed before a transaction can be opened.
 * If the transaction store is corrupt, this method can throw an exception,
 * in which case the store can only be used for reading.
 */
public synchronized void init() {
    init = true;
    // remove all temporary maps
    for (String mapName : store.getMapNames()) {
        if (mapName.startsWith("temp.")) {
            MVMap<Object, Integer> temp = openTempMap(mapName);
            store.removeMap(temp);
        }
    }
    synchronized (undoLog) {
        if (undoLog.size() > 0) {
            for (Long key : undoLog.keySet()) {
                int transactionId = getTransactionId(key);
                openTransactions.set(transactionId);
            }
        }
    }
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
/**
 * Open the map with the given name.
 *
 * @param <K> the key type
 * @param name the map name
 * @param keyType the key type
 * @param valueType the value type
 * @return the map
 */
synchronized <K> MVMap<K, VersionedValue> openMap(String name,
        DataType keyType, DataType valueType) {
    if (keyType == null) {
        keyType = new ObjectDataType();
    }
    if (valueType == null) {
        valueType = new ObjectDataType();
    }
    VersionedValueType vt = new VersionedValueType(valueType);
    MVMap<K, VersionedValue> map;
    MVMap.Builder<K, VersionedValue> builder =
            new MVMap.Builder<K, VersionedValue>().
            keyType(keyType).valueType(vt);
    map = store.openMap(name, builder);
    @SuppressWarnings("unchecked")
    MVMap<Object, VersionedValue> m = (MVMap<Object, VersionedValue>) map;
    maps.put(map.getId(), m);
    return map;
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
@Override
public Map<Integer, Boolean> getPostContingencyLoadflowConvergence(String workflowId, String contingencyId) {
    if (isWorkflowStored(workflowId)) {
        Map<Integer, Boolean> loadflowConvergence = new HashMap<Integer, Boolean>();
        MVStore wfMVStore = getStore(workflowId);
        if (wfMVStore.getMapNames().contains(STORED_PC_LOADFLOW_CONTINGENCIES_MAP_NAME)) {
            Map<String, String> storedStatesMap = wfMVStore.openMap(STORED_PC_LOADFLOW_CONTINGENCIES_MAP_NAME, mapBuilder);
            if (storedStatesMap.containsKey(contingencyId)) {
                MVMap<String, String> contingencyStateMap = wfMVStore.openMap(contingencyId + STORED_PC_LOADFLOW_STATES_MAP_SUFFIX, mapBuilder);
                for (String stateId : contingencyStateMap.keySet()) {
                    loadflowConvergence.put(Integer.valueOf(stateId), Boolean.valueOf(contingencyStateMap.get(stateId)));
                }
                return loadflowConvergence;
            } else {
                LOGGER.warn("No post contingency loadflow data for contingency {} in wf {}", contingencyId, workflowId);
                return null;
            }
        } else {
            LOGGER.warn("No post contingency loadflow data in wf {}", workflowId);
            return null;
        }
    } else {
        LOGGER.warn("No data about wf {}", workflowId);
        return null;
    }
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testSaveCount() throws IOException {
    String fileName = getBaseDir() + "/testSaveCount.h3";
    FileUtils.delete(fileName);
    MVStore s = new MVStore.Builder().
            fileName(fileName).
            open();
    MVMap<Long, byte[]> map = s.openMap("data");
    StreamStore streamStore = new StreamStore(map);
    int blockSize = 256 * 1024;
    assertEquals(blockSize, streamStore.getMaxBlockSize());
    for (int i = 0; i < 8 * 16; i++) {
        streamStore.put(new RandomStream(blockSize, i));
    }
    long writeCount = s.getFileStore().getWriteCount();
    assertTrue(writeCount > 2);
    s.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testLarge() throws IOException {
    String fileName = getBaseDir() + "/testVeryLarge.h3";
    FileUtils.delete(fileName);
    final MVStore s = new MVStore.Builder().
            fileName(fileName).
            open();
    MVMap<Long, byte[]> map = s.openMap("data");
    final AtomicInteger count = new AtomicInteger();
    StreamStore streamStore = new StreamStore(map) {
        @Override
        protected void onStore(int len) {
            count.incrementAndGet();
            s.commit();
        }
    };
    long size = 1 * 1024 * 1024;
    streamStore.put(new RandomStream(size, 0));
    s.close();
    assertEquals(4, count.get());
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void verify() {

        MVStore s;
        MVMap<Integer, byte[]> m;

        FileUtils.delete(fileName);
        s = new MVStore.Builder().
                fileName(fileName).open();
        m = s.openMap("data");
        for (int i = 0; i < 100; i++) {
            byte[] x = m.get(i);
            if (x == null) {
                break;
            }
            assertEquals(i * 100, x.length);
        }
        s.close();
    }
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testVolatileMap() {
    String fileName = getBaseDir() + "/testVolatile.h3";
    MVStore store = new MVStore.Builder().
            fileName(fileName).
            open();
    MVMap<String, String> map = store.openMap("test");
    assertFalse(map.isVolatile());
    map.setVolatile(true);
    assertTrue(map.isVolatile());
    map.put("1", "Hello");
    assertEquals("Hello", map.get("1"));
    assertEquals(1, map.size());
    store.close();
    store = new MVStore.Builder().
            fileName(fileName).
            open();
    assertTrue(store.hasMap("test"));
    map = store.openMap("test");
    assertEquals(0, map.size());
    store.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testCompressEmptyPage() {
    String fileName = getBaseDir() + "/testDeletedMap.h3";
    MVStore store = new MVStore.Builder().
            cacheSize(100).fileName(fileName).
            compress().
            autoCommitBufferSize(10 * 1024).
            open();
    MVMap<String, String> map = store.openMap("test");
    store.removeMap(map);
    store.commit();
    store.close();
    store = new MVStore.Builder().
            compress().
            open();
    store.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testVersionsToKeep() throws Exception {
    MVStore s = new MVStore.Builder().open();
    MVMap<Integer, Integer> map;
    map = s.openMap("data");
    for (int i = 0; i < 20; i++) {
        long version = s.getCurrentVersion();
        map.put(i, i);
        s.commit();
        if (version >= 6) {
            map.openVersion(version - 5);
            try {
                map.openVersion(version - 6);
                fail();
            } catch (IllegalArgumentException e) {
                // expected
            }
        }
    }
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testVersionsToKeep2() {
    MVStore s = new MVStore.Builder().autoCommitDisabled().open();
    s.setVersionsToKeep(2);
    final MVMap<Integer, String> m = s.openMap("data");
    s.commit();
    assertEquals(1, s.getCurrentVersion());
    m.put(1, "version 1");
    s.commit();
    assertEquals(2, s.getCurrentVersion());
    m.put(1, "version 2");
    s.commit();
    assertEquals(3, s.getCurrentVersion());
    m.put(1, "version 3");
    s.commit();
    m.put(1, "version 4");
    assertEquals("version 4", m.openVersion(4).get(1));
    assertEquals("version 3", m.openVersion(3).get(1));
    assertEquals("version 2", m.openVersion(2).get(1));
    new AssertThrows(IllegalArgumentException.class) {
        @Override
        public void test() throws Exception {
            m.openVersion(1);
        }
    };
    s.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testRemoveMap() throws Exception {
    String fileName = getBaseDir() + "/testCloseMap.h3";
    FileUtils.delete(fileName);
    MVStore s = new MVStore.Builder().
        fileName(fileName).
        open();
    MVMap<Integer, Integer> map;

    map = s.openMap("data");
    map.put(1, 1);
    assertEquals(1, map.get(1).intValue());
    s.commit();

    s.removeMap(map);
    s.commit();

    map = s.openMap("data");
    assertTrue(map.isEmpty());
    map.put(2, 2);

    s.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testCompactFully() throws Exception {
    String fileName = getBaseDir() + "/testCompactFully.h3";
    FileUtils.delete(fileName);
    MVStore s = new MVStore.Builder().
            fileName(fileName).
            autoCommitDisabled().
            open();
    MVMap<Integer, String> m;
    for (int i = 0; i < 100; i++) {
        m = s.openMap("data" + i);
        m.put(0, "Hello World");
        s.commit();
    }
    for (int i = 0; i < 100; i += 2) {
        m = s.openMap("data" + i);
        s.removeMap(m);
        s.commit();
    }
    long sizeOld = s.getFileStore().size();
    s.compactMoveChunks();
    long sizeNew = s.getFileStore().size();
    assertTrue("old: " + sizeOld + " new: " + sizeNew, sizeNew < sizeOld);
    s.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testExample() {
    String fileName = getBaseDir() + "/testExample.h3";
    FileUtils.delete(fileName);

    // open the store (in-memory if fileName is null)
    MVStore s = MVStore.open(fileName);

    // create/get the map named "data"
    MVMap<Integer, String> map = s.openMap("data");

    // add and read some data
    map.put(1, "Hello World");
    // System.out.println(map.get(1));

    // close the store (this will persist changes)
    s.close();

    s = MVStore.open(fileName);
    map = s.openMap("data");
    assertEquals("Hello World", map.get(1));
    s.close();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testOldVersion() {
    MVStore s;
    for (int op = 0; op <= 1; op++) {
        for (int i = 0; i < 5; i++) {
            s = openStore(null);
            s.setVersionsToKeep(Integer.MAX_VALUE);
            MVMap<String, String> m;
            m = s.openMap("data");
            for (int j = 0; j < 5; j++) {
                if (op == 1) {
                    m.put("1", "" + s.getCurrentVersion());
                }
                s.commit();
            }
            for (int j = 0; j < s.getCurrentVersion(); j++) {
                MVMap<String, String> old = m.openVersion(j);
                if (op == 1) {
                    assertEquals("" + j, old.get("1"));
                }
            }
            s.close();
        }
    }
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void removeWfWcaRulesResults(String workflowId, MVStore wfMVStore) {
    LOGGER.debug("Removing existing wca rules results for workflow {}", workflowId);
    MVMap<String, String> storedRulesResultsMap = wfMVStore.openMap(STORED_WCA_RULES_RESULTS_MAP_NAME, mapBuilder);
    // remove rules results
    Collection<String> rulesContingencies = OnlineDbMVStoreUtils.jsonToContingenciesIds(
            storedRulesResultsMap.get(STORED_RULES_RESULTS_CONTINGENCIES_WITH_RULES_KEY));
    for (String contingencyId : rulesContingencies) {
        MVMap<String, String> storedStateStatusMap = wfMVStore.openMap(contingencyId + STORED_WCA_RULES_RESULTS_STATE_STATUS_MAP_SUFFIX, mapBuilder);
        wfMVStore.removeMap(storedStateStatusMap);
        MVMap<String, String> storedStateResultsMap = wfMVStore.openMap(contingencyId + STORED_WCA_RULES_RESULTS_STATE_RESULTS_MAP_SUFFIX, mapBuilder);
        wfMVStore.removeMap(storedStateResultsMap);
        MVMap<String, String> storedStateAvailableRulesMap = wfMVStore.openMap(contingencyId + STORED_WCA_RULES_RESULTS_STATE_RULES_AVAILABLE_MAP_SUFFIX, mapBuilder);
        wfMVStore.removeMap(storedStateAvailableRulesMap);
        MVMap<String, String> storedStateInvalidRulesMap = wfMVStore.openMap(contingencyId + STORED_WCA_RULES_RESULTS_STATE_INVALID_RULES_MAP_SUFFIX, mapBuilder);
        wfMVStore.removeMap(storedStateInvalidRulesMap);
    }
    // remove info about stored rules results
    wfMVStore.removeMap(storedRulesResultsMap);
    // commit removal
    wfMVStore.commit();
}
 

import org.h2.mvstore.MVMap; //导入依赖的package包/类
private void testReuseSpace() {
    String fileName = getBaseDir() + "/testReuseSpace.h3";
    FileUtils.delete(fileName);
    long initialLength = 0;
    for (int j = 0; j < 20; j++) {
        MVStore s = openStore(fileName);
        s.setRetentionTime(0);
        MVMap<Integer, String> m = s.openMap("data");
        for (int i = 0; i < 10; i++) {
            m.put(i, "Hello");
        }
        s.commit();
        for (int i = 0; i < 10; i++) {
            assertEquals("Hello", m.get(i));
            assertEquals("Hello", m.remove(i));
        }
        s.close();
        long len = FileUtils.size(fileName);
        if (initialLength == 0) {
            initialLength = len;
        } else {
            assertTrue("len: " + len + " initial: " + initialLength + " j: " + j,
                    len <= initialLength * 2);
        }
    }
}