514 lines
19 KiB
Rust
514 lines
19 KiB
Rust
// Copyright 2016 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.
|
|
|
|
#[macro_use]
|
|
extern crate lazy_static;
|
|
|
|
#[macro_use]
|
|
extern crate mentat;
|
|
extern crate mentat_core;
|
|
extern crate mentat_db;
|
|
extern crate rusqlite;
|
|
|
|
use mentat::vocabulary;
|
|
|
|
use mentat::vocabulary::{
|
|
VersionedStore,
|
|
VocabularyCheck,
|
|
VocabularyOutcome,
|
|
VocabularyProvider,
|
|
};
|
|
|
|
use mentat::query::IntoResult;
|
|
|
|
use mentat_core::{
|
|
HasSchema,
|
|
};
|
|
|
|
// To check our working.
|
|
use mentat_db::AttributeValidation;
|
|
|
|
use mentat::{
|
|
Conn,
|
|
NamespacedKeyword,
|
|
Queryable,
|
|
Store,
|
|
TypedValue,
|
|
ValueType,
|
|
};
|
|
|
|
use mentat::entity_builder::BuildTerms;
|
|
|
|
use mentat::errors::{
|
|
Error,
|
|
ErrorKind,
|
|
};
|
|
|
|
lazy_static! {
|
|
static ref FOO_NAME: NamespacedKeyword = {
|
|
kw!(:foo/name)
|
|
};
|
|
|
|
static ref FOO_MOMENT: NamespacedKeyword = {
|
|
kw!(:foo/moment)
|
|
};
|
|
|
|
static ref FOO_VOCAB: vocabulary::Definition = {
|
|
vocabulary::Definition {
|
|
name: kw!(:org.mozilla/foo),
|
|
version: 1,
|
|
attributes: vec![
|
|
(FOO_NAME.clone(),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(false)
|
|
.unique(vocabulary::attribute::Unique::Identity)
|
|
.build()),
|
|
(FOO_MOMENT.clone(),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::Instant)
|
|
.multival(false)
|
|
.index(true)
|
|
.build()),
|
|
]
|
|
}
|
|
};
|
|
}
|
|
|
|
// Do some work with the appropriate level of paranoia for a shared system.
|
|
fn be_paranoid(conn: &mut Conn, sqlite: &mut rusqlite::Connection, name: TypedValue, moment: TypedValue) {
|
|
let mut in_progress = conn.begin_transaction(sqlite).expect("begun successfully");
|
|
assert!(in_progress.verify_core_schema().is_ok());
|
|
assert!(in_progress.ensure_vocabulary(&FOO_VOCAB).is_ok());
|
|
|
|
let a_moment = in_progress.attribute_for_ident(&FOO_MOMENT).expect("exists").1;
|
|
let a_name = in_progress.attribute_for_ident(&FOO_NAME).expect("exists").1;
|
|
|
|
let builder = in_progress.builder();
|
|
let mut entity = builder.describe_tempid("s");
|
|
entity.add(a_name, name).expect("added");
|
|
entity.add(a_moment, moment).expect("added");
|
|
assert!(entity.commit().is_ok()); // Discard the TxReport.
|
|
}
|
|
|
|
#[test]
|
|
fn test_real_world() {
|
|
let mut sqlite = mentat_db::db::new_connection("").unwrap();
|
|
let mut conn = Conn::connect(&mut sqlite).unwrap();
|
|
|
|
let alice: TypedValue = TypedValue::typed_string("Alice");
|
|
let barbara: TypedValue = TypedValue::typed_string("Barbara");
|
|
let now: TypedValue = TypedValue::current_instant();
|
|
|
|
be_paranoid(&mut conn, &mut sqlite, alice.clone(), now.clone());
|
|
be_paranoid(&mut conn, &mut sqlite, barbara.clone(), now.clone());
|
|
|
|
let results = conn.q_once(&mut sqlite, r#"[:find ?name ?when
|
|
:order (asc ?name)
|
|
:where [?x :foo/name ?name]
|
|
[?x :foo/moment ?when]
|
|
]"#,
|
|
None)
|
|
.into_rel_result()
|
|
.expect("query succeeded");
|
|
assert_eq!(results,
|
|
vec![vec![alice, now.clone()], vec![barbara, now.clone()]]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_default_attributebuilder_complains() {
|
|
// ::new is helpful. ::default is not.
|
|
assert!(vocabulary::AttributeBuilder::default()
|
|
.value_type(ValueType::String)
|
|
.multival(true)
|
|
.fulltext(true)
|
|
.build()
|
|
.validate(|| "Foo".to_string())
|
|
.is_err());
|
|
|
|
assert!(vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(true)
|
|
.fulltext(true)
|
|
.build()
|
|
.validate(|| "Foo".to_string())
|
|
.is_ok());
|
|
}
|
|
|
|
#[test]
|
|
fn test_add_vocab() {
|
|
let bar = vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::Instant)
|
|
.multival(false)
|
|
.index(true)
|
|
.build();
|
|
let baz = vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(true)
|
|
.fulltext(true)
|
|
.build();
|
|
let bar_only = vec![
|
|
(kw!(:foo/bar), bar.clone()),
|
|
];
|
|
let baz_only = vec![
|
|
(kw!(:foo/baz), baz.clone()),
|
|
];
|
|
let bar_and_baz = vec![
|
|
(kw!(:foo/bar), bar.clone()),
|
|
(kw!(:foo/baz), baz.clone()),
|
|
];
|
|
|
|
let foo_v1_a = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/foo),
|
|
version: 1,
|
|
attributes: bar_only.clone(),
|
|
};
|
|
|
|
let foo_v1_b = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/foo),
|
|
version: 1,
|
|
attributes: bar_and_baz.clone(),
|
|
};
|
|
|
|
let mut sqlite = mentat_db::db::new_connection("").unwrap();
|
|
let mut conn = Conn::connect(&mut sqlite).unwrap();
|
|
|
|
let foo_version_query = r#"[:find [?version ?aa]
|
|
:where
|
|
[:org.mozilla/foo :db.schema/version ?version]
|
|
[:org.mozilla/foo :db.schema/attribute ?a]
|
|
[?a :db/ident ?aa]]"#;
|
|
let foo_attributes_query = r#"[:find [?aa ...]
|
|
:where
|
|
[:org.mozilla/foo :db.schema/attribute ?a]
|
|
[?a :db/ident ?aa]]"#;
|
|
|
|
// Scoped borrow of `conn`.
|
|
{
|
|
let mut in_progress = conn.begin_transaction(&mut sqlite).expect("begun successfully");
|
|
|
|
assert!(in_progress.verify_core_schema().is_ok());
|
|
assert_eq!(VocabularyCheck::NotPresent, in_progress.check_vocabulary(&foo_v1_a).expect("check completed"));
|
|
assert_eq!(VocabularyCheck::NotPresent, in_progress.check_vocabulary(&foo_v1_b).expect("check completed"));
|
|
|
|
// If we install v1.a, then it will succeed.
|
|
assert_eq!(VocabularyOutcome::Installed, in_progress.ensure_vocabulary(&foo_v1_a).expect("ensure succeeded"));
|
|
|
|
// Now we can query to get the vocab.
|
|
let ver_attr =
|
|
in_progress.q_once(foo_version_query, None)
|
|
.into_tuple_result()
|
|
.expect("query returns")
|
|
.expect("a result");
|
|
assert_eq!(ver_attr[0], TypedValue::Long(1));
|
|
assert_eq!(ver_attr[1], TypedValue::typed_ns_keyword("foo", "bar"));
|
|
|
|
// If we commit, it'll stick around.
|
|
in_progress.commit().expect("commit succeeded");
|
|
}
|
|
|
|
// It's still there.
|
|
let ver_attr =
|
|
conn.q_once(&mut sqlite,
|
|
foo_version_query,
|
|
None)
|
|
.into_tuple_result()
|
|
.expect("query returns")
|
|
.expect("a result");
|
|
assert_eq!(ver_attr[0], TypedValue::Long(1));
|
|
assert_eq!(ver_attr[1], TypedValue::typed_ns_keyword("foo", "bar"));
|
|
|
|
// Scoped borrow of `conn`.
|
|
{
|
|
let mut in_progress = conn.begin_transaction(&mut sqlite).expect("begun successfully");
|
|
|
|
// Subsequently ensuring v1.a again will succeed with no work done.
|
|
assert_eq!(VocabularyCheck::Present, in_progress.check_vocabulary(&foo_v1_a).expect("check completed"));
|
|
|
|
// Checking for v1.b will say that we have work to do.
|
|
assert_eq!(VocabularyCheck::PresentButMissingAttributes {
|
|
attributes: vec![&baz_only[0]],
|
|
}, in_progress.check_vocabulary(&foo_v1_b).expect("check completed"));
|
|
|
|
// Ensuring v1.b will succeed.
|
|
assert_eq!(VocabularyOutcome::InstalledMissingAttributes,
|
|
in_progress.ensure_vocabulary(&foo_v1_b).expect("ensure succeeded"));
|
|
|
|
// Checking v1.a or v1.b again will still succeed with no work done.
|
|
assert_eq!(VocabularyCheck::Present, in_progress.check_vocabulary(&foo_v1_a).expect("check completed"));
|
|
assert_eq!(VocabularyCheck::Present, in_progress.check_vocabulary(&foo_v1_b).expect("check completed"));
|
|
|
|
// Ensuring again does nothing.
|
|
assert_eq!(VocabularyOutcome::Existed, in_progress.ensure_vocabulary(&foo_v1_b).expect("ensure succeeded"));
|
|
in_progress.commit().expect("commit succeeded");
|
|
}
|
|
|
|
// We have both attributes.
|
|
let actual_attributes =
|
|
conn.q_once(&mut sqlite,
|
|
foo_attributes_query,
|
|
None)
|
|
.into_coll_result()
|
|
.expect("query returns");
|
|
assert_eq!(actual_attributes,
|
|
vec![
|
|
TypedValue::typed_ns_keyword("foo", "bar"),
|
|
TypedValue::typed_ns_keyword("foo", "baz"),
|
|
]);
|
|
|
|
// Now let's modify our vocabulary without bumping the version. This is invalid and will result
|
|
// in an error.
|
|
let malformed_baz = vocabulary::AttributeBuilder::default()
|
|
.value_type(ValueType::Instant)
|
|
.multival(true)
|
|
.build();
|
|
let bar_and_malformed_baz = vec![
|
|
(kw!(:foo/bar), bar),
|
|
(kw!(:foo/baz), malformed_baz.clone()),
|
|
];
|
|
let foo_v1_malformed = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/foo),
|
|
version: 1,
|
|
attributes: bar_and_malformed_baz.clone(),
|
|
};
|
|
|
|
// Scoped borrow of `conn`.
|
|
{
|
|
let mut in_progress = conn.begin_transaction(&mut sqlite).expect("begun successfully");
|
|
match in_progress.ensure_vocabulary(&foo_v1_malformed) {
|
|
Result::Err(Error(ErrorKind::ConflictingAttributeDefinitions(vocab, version, attr, theirs, ours), _)) => {
|
|
assert_eq!(vocab.as_str(), ":org.mozilla/foo");
|
|
assert_eq!(attr.as_str(), ":foo/baz");
|
|
assert_eq!(version, 1);
|
|
assert_eq!(&theirs, &baz);
|
|
assert_eq!(&ours, &malformed_baz);
|
|
},
|
|
_ => panic!(),
|
|
}
|
|
}
|
|
|
|
// Some alterations -- cardinality/one to cardinality/many, unique to weaker unique or
|
|
// no unique, unindexed to indexed -- can be applied automatically, so long as you
|
|
// bump the version number.
|
|
|
|
let multival_bar = vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::Instant)
|
|
.multival(true)
|
|
.index(true)
|
|
.build();
|
|
let multival_bar_and_baz = vec![
|
|
(kw!(:foo/bar), multival_bar),
|
|
(kw!(:foo/baz), baz.clone()),
|
|
];
|
|
|
|
let altered_vocabulary = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/foo),
|
|
version: 2,
|
|
attributes: multival_bar_and_baz,
|
|
};
|
|
|
|
// foo/bar starts single-valued.
|
|
assert_eq!(false, conn.current_schema().attribute_for_ident(&kw!(:foo/bar)).expect("attribute").0.multival);
|
|
|
|
// Scoped borrow of `conn`.
|
|
{
|
|
let mut in_progress = conn.begin_transaction(&mut sqlite).expect("begun successfully");
|
|
assert_eq!(in_progress.ensure_vocabulary(&altered_vocabulary).expect("success"),
|
|
VocabularyOutcome::Upgraded);
|
|
in_progress.commit().expect("commit succeeded");
|
|
}
|
|
|
|
// Now it's multi-valued.
|
|
assert_eq!(true, conn.current_schema().attribute_for_ident(&kw!(:foo/bar)).expect("attribute").0.multival);
|
|
}
|
|
|
|
// This is a real-world-style test that evolves a schema with data changes.
|
|
// We start with a basic vocabulary in three parts:
|
|
//
|
|
// Part 1 describes foods by name.
|
|
// Part 2 describes movies by title.
|
|
// Part 3 describes people: their names and heights, and their likes.
|
|
//
|
|
// We simulate three common migrations:
|
|
// - We made a trivial modeling error: movie names should not be unique.
|
|
// - We made a less trivial modeling error, one that can fail: food names should be unique so that
|
|
// we can more easily refer to them during writes.
|
|
// In order for this migration to succeed, we need to merge duplicates, then alter the schema --
|
|
// which we will do by introducing a new property in the same vocabulary, deprecating the old one
|
|
// -- then transact the transformed data.
|
|
// - We need to normalize some non-unique data: we recorded heights in inches when they should be
|
|
// in centimeters.
|
|
// - We need to normalize some unique data: food names should all be lowercase. Again, that can fail
|
|
// because of a uniqueness constraint. (We might know that it can't fail thanks to application
|
|
// restrictions, in which case we can treat this as we did the height alteration.)
|
|
// - We made a more significant modeling error: we used 'like' to identify both movies and foods,
|
|
// and we have decided that food preferences and movie preferences should be different attributes.
|
|
// We wish to split these up and deprecate the old attribute. In order to do so we need to retract
|
|
// all of the datoms that use the old attribute, transact new attributes _in both movies and foods_,
|
|
// then re-assert the data.
|
|
#[test]
|
|
fn test_upgrade_with_functions() {
|
|
let mut store = Store::open("").expect("open");
|
|
|
|
let food_v1 = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/food),
|
|
version: 1,
|
|
attributes: vec![
|
|
(kw!(:food/name),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(false)
|
|
.build()),
|
|
],
|
|
};
|
|
|
|
let movies_v1 = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/movies),
|
|
version: 1,
|
|
attributes: vec![
|
|
(kw!(:movie/year),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::Long) // No need for Instant here.
|
|
.multival(false)
|
|
.build()),
|
|
(kw!(:movie/title),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(false)
|
|
.unique(vocabulary::attribute::Unique::Identity)
|
|
.index(true)
|
|
.build()),
|
|
],
|
|
};
|
|
|
|
let people_v1 = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/people),
|
|
version: 1,
|
|
attributes: vec![
|
|
(kw!(:person/name),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(false)
|
|
.unique(vocabulary::attribute::Unique::Identity)
|
|
.index(true)
|
|
.build()),
|
|
(kw!(:person/height),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::Long)
|
|
.multival(false)
|
|
.build()),
|
|
(kw!(:person/likes),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::Ref)
|
|
.multival(true)
|
|
.build()),
|
|
],
|
|
};
|
|
|
|
// Apply v1 of each.
|
|
let v1_provider = VocabularyProvider {
|
|
pre: |_ip| Ok(()),
|
|
definitions: vec![
|
|
food_v1.clone(),
|
|
movies_v1.clone(),
|
|
people_v1.clone(),
|
|
],
|
|
post: |_ip| Ok(()),
|
|
};
|
|
|
|
// Mutable borrow of store.
|
|
{
|
|
let mut in_progress = store.begin_transaction().expect("began");
|
|
|
|
in_progress.ensure_vocabularies(&v1_provider).expect("success");
|
|
|
|
// Also add some data. We do this in one transaction 'cos -- thanks to the modeling errors
|
|
// we are about to fix! -- it's a little awkward to make references to entities without
|
|
// unique attributes.
|
|
in_progress.transact(r#"[
|
|
{:movie/title "John Wick"
|
|
:movie/year 2014
|
|
:db/id "mjw"}
|
|
{:movie/title "Terminator 2: Judgment Day"
|
|
:movie/year 1991
|
|
:db/id "mt2"}
|
|
{:movie/title "Dune"
|
|
:db/id "md"
|
|
:movie/year 1984}
|
|
{:movie/title "Upstream Color"
|
|
:movie/year 2013
|
|
:db/id "muc"}
|
|
{:movie/title "Primer"
|
|
:db/id "mp"
|
|
:movie/year 2004}
|
|
|
|
;; No year: not yet released.
|
|
{:movie/title "The Modern Ocean"
|
|
:db/id "mtmo"}
|
|
|
|
{:food/name "Carrots" :db/id "fc"}
|
|
{:food/name "Weird blue worms" :db/id "fwbw"}
|
|
{:food/name "Spice" :db/id "fS"}
|
|
{:food/name "spice" :db/id "fs"}
|
|
|
|
;; Sam likes action movies, carrots, and lowercase spice.
|
|
{:person/name "Sam"
|
|
:person/height 64
|
|
:person/likes ["mjw", "mt2", "fc", "fs"]}
|
|
|
|
;; Beth likes thoughtful and weird movies, weird blue worms, and Spice.
|
|
{:person/name "Beth"
|
|
:person/height 68
|
|
:person/likes ["muc", "mp", "md", "fwbw", "fS"]}
|
|
|
|
]"#).expect("transacted");
|
|
|
|
in_progress.commit().expect("commit succeeded");
|
|
}
|
|
|
|
// Mutable borrow of store.
|
|
{
|
|
|
|
// Crap, there are several movies named Dune. We need to de-uniqify that attribute.
|
|
let movies_v2 = vocabulary::Definition {
|
|
name: kw!(:org.mozilla/movies),
|
|
version: 2,
|
|
attributes: vec![
|
|
(kw!(:movie/title),
|
|
vocabulary::AttributeBuilder::helpful()
|
|
.value_type(ValueType::String)
|
|
.multival(false)
|
|
.non_unique()
|
|
.index(true)
|
|
.build()),
|
|
],
|
|
};
|
|
let mut in_progress = store.begin_transaction().expect("began");
|
|
in_progress.ensure_vocabulary(&movies_v2).expect("success");
|
|
|
|
// We can now add another Dune movie: Denis Villeneuve's 2019 version.
|
|
// (Let's just pretend that it's been released, here in 2018!)
|
|
in_progress.transact(r#"[
|
|
{:movie/title "Dune"
|
|
:movie/year 2019}
|
|
]"#).expect("transact succeeded");
|
|
|
|
// And we can query both.
|
|
let years =
|
|
in_progress.q_once(r#"[:find [?year ...]
|
|
:where [?movie :movie/title "Dune"]
|
|
[?movie :movie/year ?year]
|
|
:order (asc ?year)]"#, None)
|
|
.into_coll_result()
|
|
.expect("coll");
|
|
assert_eq!(years, vec![TypedValue::Long(1984), TypedValue::Long(2019)]);
|
|
in_progress.commit().expect("commit succeeded");
|
|
}
|
|
}
|