mirror of https://github.com/nextgraph-org/rkv.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
328 lines
11 KiB
328 lines
11 KiB
// Copyright 2018-2019 Mozilla
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
// this file except in compliance with the License. You may obtain a copy of the
|
|
// License at http://www.apache.org/licenses/LICENSE-2.0
|
|
// Unless required by applicable law or agreed to in writing, software distributed
|
|
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
|
|
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
|
|
// specific language governing permissions and limitations under the License.
|
|
|
|
use std::fs;
|
|
|
|
use tempfile::Builder;
|
|
|
|
use rkv::{
|
|
backend::{Lmdb, SafeMode},
|
|
Rkv, StoreOptions, Value,
|
|
};
|
|
|
|
#[test]
|
|
fn test_open_safe_same_dir_as_lmdb() {
|
|
let root = Builder::new()
|
|
.prefix("test_open_safe_same_dir_as_lmdb")
|
|
.tempdir()
|
|
.expect("tempdir");
|
|
fs::create_dir_all(root.path()).expect("dir created");
|
|
|
|
// Create database of type A and save to disk.
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
|
|
|
|
let mut writer = k.write().expect("writer");
|
|
sk.put(&mut writer, "foo", &Value::I64(1234))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "bar", &Value::Bool(true))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "baz", &Value::Str("héllo, yöu"))
|
|
.expect("wrote");
|
|
assert_eq!(
|
|
sk.get(&writer, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
writer.commit().expect("committed");
|
|
k.sync(true).expect("synced");
|
|
}
|
|
// Verify that database of type A was written to disk.
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
}
|
|
// Create database of type B and verify that it is empty.
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let _ = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect_err("not opened");
|
|
}
|
|
// Verify that database of type A wasn't changed.
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
}
|
|
// Create database of type B and save to disk (type A exists at the same path).
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
|
|
|
|
let mut writer = k.write().expect("writer");
|
|
sk.put(&mut writer, "foo1", &Value::I64(5678))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "bar1", &Value::Bool(false))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "baz1", &Value::Str("héllo~ yöu"))
|
|
.expect("wrote");
|
|
assert_eq!(
|
|
sk.get(&writer, "foo1").expect("read"),
|
|
Some(Value::I64(5678))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "bar1").expect("read"),
|
|
Some(Value::Bool(false))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "baz1").expect("read"),
|
|
Some(Value::Str("héllo~ yöu"))
|
|
);
|
|
writer.commit().expect("committed");
|
|
k.sync(true).expect("synced");
|
|
}
|
|
// Verify that database of type B was written to disk.
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo1").expect("read"),
|
|
Some(Value::I64(5678))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar1").expect("read"),
|
|
Some(Value::Bool(false))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz1").expect("read"),
|
|
Some(Value::Str("héllo~ yöu"))
|
|
);
|
|
}
|
|
// Verify that database of type A still wasn't changed.
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_open_lmdb_same_dir_as_safe() {
|
|
let root = Builder::new()
|
|
.prefix("test_open_lmdb_same_dir_as_safe")
|
|
.tempdir()
|
|
.expect("tempdir");
|
|
fs::create_dir_all(root.path()).expect("dir created");
|
|
|
|
// Create database of type A and save to disk.
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
|
|
|
|
let mut writer = k.write().expect("writer");
|
|
sk.put(&mut writer, "foo", &Value::I64(1234))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "bar", &Value::Bool(true))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "baz", &Value::Str("héllo, yöu"))
|
|
.expect("wrote");
|
|
assert_eq!(
|
|
sk.get(&writer, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
writer.commit().expect("committed");
|
|
k.sync(true).expect("synced");
|
|
}
|
|
// Verify that database of type A was written to disk.
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
}
|
|
// Create database of type B and verify that it is empty.
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let _ = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect_err("not opened");
|
|
}
|
|
// Verify that database of type A wasn't changed.
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
}
|
|
// Create database of type B and save to disk (type A exists at the same path).
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let sk = k.open_single("sk", StoreOptions::create()).expect("opened");
|
|
|
|
let mut writer = k.write().expect("writer");
|
|
sk.put(&mut writer, "foo1", &Value::I64(5678))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "bar1", &Value::Bool(false))
|
|
.expect("wrote");
|
|
sk.put(&mut writer, "baz1", &Value::Str("héllo~ yöu"))
|
|
.expect("wrote");
|
|
assert_eq!(
|
|
sk.get(&writer, "foo1").expect("read"),
|
|
Some(Value::I64(5678))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "bar1").expect("read"),
|
|
Some(Value::Bool(false))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&writer, "baz1").expect("read"),
|
|
Some(Value::Str("héllo~ yöu"))
|
|
);
|
|
writer.commit().expect("committed");
|
|
k.sync(true).expect("synced");
|
|
}
|
|
// Verify that database of type B was written to disk.
|
|
{
|
|
let k = Rkv::new::<Lmdb>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo1").expect("read"),
|
|
Some(Value::I64(5678))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar1").expect("read"),
|
|
Some(Value::Bool(false))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz1").expect("read"),
|
|
Some(Value::Str("héllo~ yöu"))
|
|
);
|
|
}
|
|
// Verify that database of type A still wasn't changed.
|
|
{
|
|
let k = Rkv::new::<SafeMode>(root.path()).expect("new succeeded");
|
|
let sk = k
|
|
.open_single("sk", StoreOptions::default())
|
|
.expect("opened");
|
|
|
|
let reader = k.read().expect("reader");
|
|
assert_eq!(
|
|
sk.get(&reader, "foo").expect("read"),
|
|
Some(Value::I64(1234))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "bar").expect("read"),
|
|
Some(Value::Bool(true))
|
|
);
|
|
assert_eq!(
|
|
sk.get(&reader, "baz").expect("read"),
|
|
Some(Value::Str("héllo, yöu"))
|
|
);
|
|
}
|
|
}
|
|
|