greg/mentat
1
0
Fork 0
Code Issues 294 Pull requests Projects Releases 9 Packages Wiki Activity

Pre: Move core/Attribute* to core-traits

Browse source
This commit is contained in:
Grisha Kruglov 2018-08-08 14:19:27 -07:00
parent 474d17d3da
commit 2c8f197a3f
28 changed files with 262 additions and 257 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

210
core-traits/lib.rs
View file

@ -40,6 +40,8 @@ use std::sync::{
Arc,
};
use std::collections::BTreeMap;
use indexmap::{
IndexMap,
};
@ -115,6 +117,161 @@ impl<V: TransactableValueMarker> Into<ValuePlace<V>> for KnownEntid {
}
}
/// Bit flags used in `flags0` column in temporary tables created during search,
/// such as the `search_results`, `inexact_searches` and `exact_searches` tables.
/// When moving to a more concrete table, such as `datoms`, they are expanded out
/// via these flags and put into their own column rather than a bit field.
pub enum AttributeBitFlags {
IndexAVET = 1 << 0,
IndexVAET = 1 << 1,
IndexFulltext = 1 << 2,
UniqueValue = 1 << 3,
}
pub mod attribute {
use ::{
TypedValue,
};
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialOrd, PartialEq)]
pub enum Unique {
Value,
Identity,
}
impl Unique {
// This is easier than rejigging DB_UNIQUE_VALUE to not be EDN.
pub fn into_typed_value(self) -> TypedValue {
match self {
Unique::Value => TypedValue::typed_ns_keyword("db.unique", "value"),
Unique::Identity => TypedValue::typed_ns_keyword("db.unique", "identity"),
}
}
}
}
/// A Mentat schema attribute has a value type and several other flags determining how assertions
/// with the attribute are interpreted.
///
/// TODO: consider packing this into a bitfield or similar.
#[derive(Clone,Debug,Eq,Hash,Ord,PartialOrd,PartialEq)]
pub struct Attribute {
/// The associated value type, i.e., `:db/valueType`?
pub value_type: ValueType,
/// `true` if this attribute is multi-valued, i.e., it is `:db/cardinality
/// :db.cardinality/many`. `false` if this attribute is single-valued (the default), i.e., it
/// is `:db/cardinality :db.cardinality/one`.
pub multival: bool,
/// `None` if this attribute is neither unique-value nor unique-identity.
///
/// `Some(attribute::Unique::Value)` if this attribute is unique-value, i.e., it is `:db/unique
/// :db.unique/value`.
///
/// *Unique-value* means that there is at most one assertion with the attribute and a
/// particular value in the datom store. Unique-value attributes can be used in lookup-refs.
///
/// `Some(attribute::Unique::Identity)` if this attribute is unique-identity, i.e., it is `:db/unique
/// :db.unique/identity`.
///
/// Unique-identity attributes always have value type `Ref`.
///
/// *Unique-identity* means that the attribute is *unique-value* and that they can be used in
/// lookup-refs and will automatically upsert where appropriate.
pub unique: Option<attribute::Unique>,
/// `true` if this attribute is automatically indexed, i.e., it is `:db/indexing true`.
pub index: bool,
/// `true` if this attribute is automatically fulltext indexed, i.e., it is `:db/fulltext true`.
///
/// Fulltext attributes always have string values.
pub fulltext: bool,
/// `true` if this attribute is a component, i.e., it is `:db/isComponent true`.
///
/// Component attributes always have value type `Ref`.
///
/// They are used to compose entities from component sub-entities: they are fetched recursively
/// by pull expressions, and they are automatically recursively deleted where appropriate.
pub component: bool,
/// `true` if this attribute doesn't require history to be kept, i.e., it is `:db/noHistory true`.
pub no_history: bool,
}
impl Attribute {
/// Combine several attribute flags into a bitfield used in temporary search tables.
pub fn flags(&self) -> u8 {
let mut flags: u8 = 0;
if self.index {
flags |= AttributeBitFlags::IndexAVET as u8;
}
if self.value_type == ValueType::Ref {
flags |= AttributeBitFlags::IndexVAET as u8;
}
if self.fulltext {
flags |= AttributeBitFlags::IndexFulltext as u8;
}
if self.unique.is_some() {
flags |= AttributeBitFlags::UniqueValue as u8;
}
flags
}
pub fn to_edn_value(&self, ident: Option<Keyword>) -> edn::Value {
let mut attribute_map: BTreeMap<edn::Value, edn::Value> = BTreeMap::default();
if let Some(ident) = ident {
attribute_map.insert(values::DB_IDENT.clone(), edn::Value::Keyword(ident));
}
attribute_map.insert(values::DB_VALUE_TYPE.clone(), self.value_type.into_edn_value());
attribute_map.insert(values::DB_CARDINALITY.clone(), if self.multival { values::DB_CARDINALITY_MANY.clone() } else { values::DB_CARDINALITY_ONE.clone() });
match self.unique {
Some(attribute::Unique::Value) => { attribute_map.insert(values::DB_UNIQUE.clone(), values::DB_UNIQUE_VALUE.clone()); },
Some(attribute::Unique::Identity) => { attribute_map.insert(values::DB_UNIQUE.clone(), values::DB_UNIQUE_IDENTITY.clone()); },
None => (),
}
if self.index {
attribute_map.insert(values::DB_INDEX.clone(), edn::Value::Boolean(true));
}
if self.fulltext {
attribute_map.insert(values::DB_FULLTEXT.clone(), edn::Value::Boolean(true));
}
if self.component {
attribute_map.insert(values::DB_IS_COMPONENT.clone(), edn::Value::Boolean(true));
}
if self.no_history {
attribute_map.insert(values::DB_NO_HISTORY.clone(), edn::Value::Boolean(true));
}
edn::Value::Map(attribute_map)
}
}
impl Default for Attribute {
fn default() -> Attribute {
Attribute {
// There's no particular reason to favour one value type, so Ref it is.
value_type: ValueType::Ref,
fulltext: false,
index: false,
multival: false,
unique: None,
component: false,
no_history: false,
}
}
}
/// The attribute of each Mentat assertion has a :db/valueType constraining the value to a
/// particular set. Mentat recognizes the following :db/valueType values.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialOrd, PartialEq)]
@ -863,3 +1020,56 @@ fn test_typed_value() {
assert!(TypedValue::typed_string("foo").is_congruent_with(ValueType::String));
assert!(TypedValue::typed_string("foo").is_congruent_with(None));
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_attribute_flags() {
let attr1 = Attribute {
index: true,
value_type: ValueType::Ref,
fulltext: false,
unique: None,
multival: false,
component: false,
no_history: false,
};
assert!(attr1.flags() & AttributeBitFlags::IndexAVET as u8 != 0);
assert!(attr1.flags() & AttributeBitFlags::IndexVAET as u8 != 0);
assert!(attr1.flags() & AttributeBitFlags::IndexFulltext as u8 == 0);
assert!(attr1.flags() & AttributeBitFlags::UniqueValue as u8 == 0);
let attr2 = Attribute {
index: false,
value_type: ValueType::Boolean,
fulltext: true,
unique: Some(attribute::Unique::Value),
multival: false,
component: false,
no_history: false,
};
assert!(attr2.flags() & AttributeBitFlags::IndexAVET as u8 == 0);
assert!(attr2.flags() & AttributeBitFlags::IndexVAET as u8 == 0);
assert!(attr2.flags() & AttributeBitFlags::IndexFulltext as u8 != 0);
assert!(attr2.flags() & AttributeBitFlags::UniqueValue as u8 != 0);
let attr3 = Attribute {
index: false,
value_type: ValueType::Boolean,
fulltext: true,
unique: Some(attribute::Unique::Identity),
multival: false,
component: false,
no_history: false,
};
assert!(attr3.flags() & AttributeBitFlags::IndexAVET as u8 == 0);
assert!(attr3.flags() & AttributeBitFlags::IndexVAET as u8 == 0);
assert!(attr3.flags() & AttributeBitFlags::IndexFulltext as u8 != 0);
assert!(attr3.flags() & AttributeBitFlags::UniqueValue as u8 != 0);
}
}

206
core/src/lib.rs
View file

@ -20,9 +20,9 @@ extern crate core_traits;
extern crate edn;
use core_traits::{
Attribute,
Entid,
KnownEntid,
values,
ValueType,
};
@ -77,161 +77,6 @@ pub use sql_types::{
SQLValueTypeSet,
};
/// Bit flags used in `flags0` column in temporary tables created during search,
/// such as the `search_results`, `inexact_searches` and `exact_searches` tables.
/// When moving to a more concrete table, such as `datoms`, they are expanded out
/// via these flags and put into their own column rather than a bit field.
pub enum AttributeBitFlags {
IndexAVET = 1 << 0,
IndexVAET = 1 << 1,
IndexFulltext = 1 << 2,
UniqueValue = 1 << 3,
}
pub mod attribute {
use core_traits::{
TypedValue,
};
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialOrd, PartialEq)]
pub enum Unique {
Value,
Identity,
}
impl Unique {
// This is easier than rejigging DB_UNIQUE_VALUE to not be EDN.
pub fn into_typed_value(self) -> TypedValue {
match self {
Unique::Value => TypedValue::typed_ns_keyword("db.unique", "value"),
Unique::Identity => TypedValue::typed_ns_keyword("db.unique", "identity"),
}
}
}
}
/// A Mentat schema attribute has a value type and several other flags determining how assertions
/// with the attribute are interpreted.
///
/// TODO: consider packing this into a bitfield or similar.
#[derive(Clone,Debug,Eq,Hash,Ord,PartialOrd,PartialEq)]
pub struct Attribute {
/// The associated value type, i.e., `:db/valueType`?
pub value_type: ValueType,
/// `true` if this attribute is multi-valued, i.e., it is `:db/cardinality
/// :db.cardinality/many`. `false` if this attribute is single-valued (the default), i.e., it
/// is `:db/cardinality :db.cardinality/one`.
pub multival: bool,
/// `None` if this attribute is neither unique-value nor unique-identity.
///
/// `Some(attribute::Unique::Value)` if this attribute is unique-value, i.e., it is `:db/unique
/// :db.unique/value`.
///
/// *Unique-value* means that there is at most one assertion with the attribute and a
/// particular value in the datom store. Unique-value attributes can be used in lookup-refs.
///
/// `Some(attribute::Unique::Identity)` if this attribute is unique-identity, i.e., it is `:db/unique
/// :db.unique/identity`.
///
/// Unique-identity attributes always have value type `Ref`.
///
/// *Unique-identity* means that the attribute is *unique-value* and that they can be used in
/// lookup-refs and will automatically upsert where appropriate.
pub unique: Option<attribute::Unique>,
/// `true` if this attribute is automatically indexed, i.e., it is `:db/indexing true`.
pub index: bool,
/// `true` if this attribute is automatically fulltext indexed, i.e., it is `:db/fulltext true`.
///
/// Fulltext attributes always have string values.
pub fulltext: bool,
/// `true` if this attribute is a component, i.e., it is `:db/isComponent true`.
///
/// Component attributes always have value type `Ref`.
///
/// They are used to compose entities from component sub-entities: they are fetched recursively
/// by pull expressions, and they are automatically recursively deleted where appropriate.
pub component: bool,
/// `true` if this attribute doesn't require history to be kept, i.e., it is `:db/noHistory true`.
pub no_history: bool,
}
impl Attribute {
/// Combine several attribute flags into a bitfield used in temporary search tables.
pub fn flags(&self) -> u8 {
let mut flags: u8 = 0;
if self.index {
flags |= AttributeBitFlags::IndexAVET as u8;
}
if self.value_type == ValueType::Ref {
flags |= AttributeBitFlags::IndexVAET as u8;
}
if self.fulltext {
flags |= AttributeBitFlags::IndexFulltext as u8;
}
if self.unique.is_some() {
flags |= AttributeBitFlags::UniqueValue as u8;
}
flags
}
pub fn to_edn_value(&self, ident: Option<Keyword>) -> edn::Value {
let mut attribute_map: BTreeMap<edn::Value, edn::Value> = BTreeMap::default();
if let Some(ident) = ident {
attribute_map.insert(values::DB_IDENT.clone(), edn::Value::Keyword(ident));
}
attribute_map.insert(values::DB_VALUE_TYPE.clone(), self.value_type.into_edn_value());
attribute_map.insert(values::DB_CARDINALITY.clone(), if self.multival { values::DB_CARDINALITY_MANY.clone() } else { values::DB_CARDINALITY_ONE.clone() });
match self.unique {
Some(attribute::Unique::Value) => { attribute_map.insert(values::DB_UNIQUE.clone(), values::DB_UNIQUE_VALUE.clone()); },
Some(attribute::Unique::Identity) => { attribute_map.insert(values::DB_UNIQUE.clone(), values::DB_UNIQUE_IDENTITY.clone()); },
None => (),
}
if self.index {
attribute_map.insert(values::DB_INDEX.clone(), edn::Value::Boolean(true));
}
if self.fulltext {
attribute_map.insert(values::DB_FULLTEXT.clone(), edn::Value::Boolean(true));
}
if self.component {
attribute_map.insert(values::DB_IS_COMPONENT.clone(), edn::Value::Boolean(true));
}
if self.no_history {
attribute_map.insert(values::DB_NO_HISTORY.clone(), edn::Value::Boolean(true));
}
edn::Value::Map(attribute_map)
}
}
impl Default for Attribute {
fn default() -> Attribute {
Attribute {
// There's no particular reason to favour one value type, so Ref it is.
value_type: ValueType::Ref,
fulltext: false,
index: false,
multival: false,
unique: None,
component: false,
no_history: false,
}
}
}
/// Map `Keyword` idents (`:db/ident`) to positive integer entids (`1`).
pub type IdentMap = BTreeMap<Keyword, Entid>;
@ -409,6 +254,7 @@ mod test {
use std::str::FromStr;
use core_traits::{
attribute,
TypedValue,
};
@ -421,54 +267,6 @@ mod test {
schema.attribute_map.insert(e, a);
}
#[test]
fn test_attribute_flags() {
let attr1 = Attribute {
index: true,
value_type: ValueType::Ref,
fulltext: false,
unique: None,
multival: false,
component: false,
no_history: false,
};
assert!(attr1.flags() & AttributeBitFlags::IndexAVET as u8 != 0);
assert!(attr1.flags() & AttributeBitFlags::IndexVAET as u8 != 0);
assert!(attr1.flags() & AttributeBitFlags::IndexFulltext as u8 == 0);
assert!(attr1.flags() & AttributeBitFlags::UniqueValue as u8 == 0);
let attr2 = Attribute {
index: false,
value_type: ValueType::Boolean,
fulltext: true,
unique: Some(attribute::Unique::Value),
multival: false,
component: false,
no_history: false,
};
assert!(attr2.flags() & AttributeBitFlags::IndexAVET as u8 == 0);
assert!(attr2.flags() & AttributeBitFlags::IndexVAET as u8 == 0);
assert!(attr2.flags() & AttributeBitFlags::IndexFulltext as u8 != 0);
assert!(attr2.flags() & AttributeBitFlags::UniqueValue as u8 != 0);
let attr3 = Attribute {
index: false,
value_type: ValueType::Boolean,
fulltext: true,
unique: Some(attribute::Unique::Identity),
multival: false,
component: false,
no_history: false,
};
assert!(attr3.flags() & AttributeBitFlags::IndexAVET as u8 == 0);
assert!(attr3.flags() & AttributeBitFlags::IndexVAET as u8 == 0);
assert!(attr3.flags() & AttributeBitFlags::IndexFulltext as u8 != 0);
assert!(attr3.flags() & AttributeBitFlags::UniqueValue as u8 != 0);
}
#[test]
fn test_datetime_truncation() {
let dt: DateTime<Utc> = DateTime::from_str("2018-01-11T00:34:09.273457004Z").expect("parsed");

8
db/src/db.rs
View file

@ -42,15 +42,15 @@ use edn::{
use entids;
use core_traits::{
attribute,
Attribute,
AttributeBitFlags,
Entid,
TypedValue,
ValueType,
};
use mentat_core::{
attribute,
Attribute,
AttributeBitFlags,
FromMicros,
IdentMap,
Schema,
@ -1227,12 +1227,12 @@ mod tests {
OpType,
};
use core_traits::{
attribute,
KnownEntid,
};
use mentat_core::{
HasSchema,
Keyword,
attribute,
};
use mentat_core::util::Either::*;
use std::collections::{

2
db/src/internal_types.rs
View file

@ -19,6 +19,7 @@ use std::collections::{
};
use core_traits::{
Attribute,
Entid,
KnownEntid,
TypedValue,
@ -50,7 +51,6 @@ use schema::{
SchemaTypeChecking,
};
use types::{
Attribute,
AVMap,
AVPair,
Schema,

2
db/src/metadata.rs
View file

@ -40,13 +40,13 @@ use db_traits::errors::{
};
use core_traits::{
attribute,
Entid,
TypedValue,
ValueType,
};
use mentat_core::{
attribute,
Schema,
AttributeMap,
};

4
db/src/schema.rs
View file

@ -19,6 +19,8 @@ use db_traits::errors::{
use edn::symbols;
use core_traits::{
attribute,
Attribute,
Entid,
KnownEntid,
TypedValue,
@ -26,8 +28,6 @@ use core_traits::{
};
use mentat_core::{
attribute,
Attribute,
EntidMap,
HasSchema,
IdentMap,

4
db/src/tx.rs
View file

@ -90,6 +90,8 @@ use internal_types::{
use mentat_core::util::Either;
use core_traits::{
attribute,
Attribute,
Entid,
KnownEntid,
TypedValue,
@ -102,7 +104,6 @@ use mentat_core::{
Schema,
TxReport,
Utc,
attribute,
};
use edn::entities as entmod;
@ -121,7 +122,6 @@ use tx_checking;
use types::{
AVMap,
AVPair,
Attribute,
PartitionMap,
TransactableValue,
};

2
db/src/types.rs
View file

@ -33,8 +33,6 @@ use core_traits::{
};
pub use self::mentat_core::{
Attribute,
AttributeBitFlags,
DateTime,
Schema,
Utc,

4
db/src/upsert_resolution.rs
View file

@ -41,13 +41,13 @@ use internal_types::{
use mentat_core::util::Either::*;
use core_traits::{
attribute,
Attribute,
Entid,
TypedValue,
};
use mentat_core::{
attribute,
Attribute,
Schema,
};
use edn::entities::OpType;

2
query-algebrizer/src/clauses/fulltext.rs
View file

@ -265,11 +265,11 @@ mod testing {
use super::*;
use core_traits::{
Attribute,
ValueType,
};
use mentat_core::{
Attribute,
Schema,
};

5
query-algebrizer/src/clauses/ground.rs
View file

@ -325,11 +325,8 @@ mod testing {
use super::*;
use core_traits::{
ValueType,
};
use mentat_core::{
Attribute,
ValueType,
};
use edn::query::{

2
query-algebrizer/src/clauses/mod.rs
View file

@ -26,6 +26,7 @@ use std::fmt::{
};
use core_traits::{
Attribute,
Entid,
KnownEntid,
ValueType,
@ -34,7 +35,6 @@ use core_traits::{
};
use mentat_core::{
Attribute,
Cloned,
HasSchema,
Schema,

2
query-algebrizer/src/clauses/not.rs
View file

@ -91,13 +91,13 @@ mod testing {
use super::*;
use core_traits::{
Attribute,
TypedValue,
ValueType,
ValueTypeSet,
};
use mentat_core::{
Attribute,
Schema,
};

2
query-algebrizer/src/clauses/or.rs
View file

@ -754,12 +754,12 @@ mod testing {
use super::*;
use core_traits::{
Attribute,
ValueType,
TypedValue,
};
use mentat_core::{
Attribute,
Schema,
};

6
query-algebrizer/src/clauses/pattern.rs
View file

@ -659,12 +659,14 @@ mod testing {
use std::collections::BTreeMap;
use std::collections::BTreeSet;
use mentat_core::attribute::Unique;
use core_traits::attribute::{
Unique,
};
use core_traits::{
Attribute,
ValueTypeSet,
};
use mentat_core::{
Attribute,
Schema,
};

8
query-algebrizer/src/clauses/predicate.rs
View file

@ -190,14 +190,14 @@ impl Inequality {
mod testing {
use super::*;
use mentat_core::attribute::Unique;
use core_traits::attribute::{
Unique,
};
use core_traits::{
Attribute,
TypedValue,
ValueType,
};
use mentat_core::{
Attribute,
};
use edn::query::{
FnArg,

2
query-algebrizer/tests/fulltext.rs
View file

@ -17,11 +17,11 @@ extern crate query_algebrizer_traits;
mod utils;
use core_traits::{
Attribute,
ValueType,
};
use mentat_core::{
Attribute,
Schema,
};

2
query-algebrizer/tests/ground.rs
View file

@ -19,12 +19,12 @@ mod utils;
use std::collections::BTreeMap;
use core_traits::{
Attribute,
ValueType,
TypedValue,
};
use mentat_core::{
Attribute,
Schema,
};

2
query-algebrizer/tests/predicate.rs
View file

@ -17,13 +17,13 @@ extern crate query_algebrizer_traits;
mod utils;
use core_traits::{
Attribute,
ValueType,
TypedValue,
ValueTypeSet,
};
use mentat_core::{
Attribute,
DateTime,
Schema,
Utc,

2
query-algebrizer/tests/utils/mod.rs
View file

@ -14,12 +14,12 @@
#![allow(dead_code)]
use core_traits::{
Attribute,
Entid,
ValueType,
};
use mentat_core::{
Attribute,
Schema,
};

2
query-projector-traits/tests/aggregates.rs
View file

@ -16,12 +16,12 @@ extern crate mentat_query_projector;
extern crate query_projector_traits;
use core_traits::{
Attribute,
Entid,
ValueType,
};
use mentat_core::{
Attribute,
Schema,
};

2
query-projector/tests/translate.rs
View file

@ -26,13 +26,13 @@ use edn::query::{
};
use core_traits::{
Attribute,
Entid,
TypedValue,
ValueType,
};
use mentat_core::{
Attribute,
Schema,
};

2
src/conn.rs
View file

@ -46,6 +46,7 @@ use edn::{
};
pub use core_traits::{
Attribute,
Entid,
KnownEntid,
StructuredMap,
@ -54,7 +55,6 @@ pub use core_traits::{
};
use mentat_core::{
Attribute,
HasSchema,
Keyword,
Schema,

5
src/errors.rs
View file

@ -19,11 +19,8 @@ use rusqlite;
use edn;
use core_traits::{
ValueType,
};
use mentat_core::{
Attribute,
ValueType,
};
use db_traits::errors::DbError;

2
src/lib.rs
View file

@ -39,6 +39,7 @@ extern crate mentat_sql;
extern crate mentat_tolstoy;
pub use core_traits::{
Attribute,
Binding,
Entid,
KnownEntid,
@ -49,7 +50,6 @@ pub use core_traits::{
};
pub use mentat_core::{
Attribute,
DateTime,
HasSchema,
Keyword,

2
src/store.rs
View file

@ -308,7 +308,7 @@ mod tests {
VersionedStore,
};
use ::vocabulary::attribute::{
use core_traits::attribute::{
Unique,
};

10
src/vocabulary.rs
View file

@ -93,16 +93,14 @@
use std::collections::BTreeMap;
pub use mentat_core::attribute;
use mentat_core::attribute::{
Unique,
};
use core_traits::{
KnownEntid,
};
use core_traits::attribute::{
Unique,
};
use ::{
CORE_SCHEMA_VERSION,
Attribute,

17
tests/vocabulary.rs
View file

@ -14,6 +14,7 @@ extern crate lazy_static;
#[macro_use]
extern crate mentat;
extern crate mentat_core;
extern crate core_traits;
extern crate mentat_db;
extern crate rusqlite;
@ -37,6 +38,10 @@ use mentat_core::{
HasSchema,
};
use core_traits::attribute::{
Unique,
};
// To check our working.
use mentat_db::AttributeValidation;
@ -79,7 +84,7 @@ lazy_static! {
vocabulary::AttributeBuilder::helpful()
.value_type(ValueType::String)
.multival(false)
.unique(vocabulary::attribute::Unique::Identity)
.unique(Unique::Identity)
.build()),
(FOO_MOMENT.clone(),
vocabulary::AttributeBuilder::helpful()
@ -452,7 +457,7 @@ fn test_upgrade_with_functions() {
vocabulary::AttributeBuilder::helpful()
.value_type(ValueType::String)
.multival(false)
.unique(vocabulary::attribute::Unique::Identity)
.unique(Unique::Identity)
.index(true)
.build()),
],
@ -468,7 +473,7 @@ fn test_upgrade_with_functions() {
vocabulary::AttributeBuilder::helpful()
.value_type(ValueType::String)
.multival(false)
.unique(vocabulary::attribute::Unique::Identity)
.unique(Unique::Identity)
.index(true)
.build()),
(kw!(:person/height),
@ -759,7 +764,7 @@ fn test_upgrade_with_functions() {
vocabulary::AttributeBuilder::helpful()
.value_type(ValueType::String)
.multival(false)
.unique(vocabulary::attribute::Unique::Identity)
.unique(Unique::Identity)
.build()),
],
pre: |ip, from| {
@ -781,7 +786,7 @@ fn test_upgrade_with_functions() {
vocabulary::AttributeBuilder::helpful()
.value_type(ValueType::String)
.multival(false)
.unique(vocabulary::attribute::Unique::Identity)
.unique(Unique::Identity)
.build()),
],
pre: |ip, from| {
@ -877,7 +882,7 @@ fn test_upgrade_with_functions() {
vocabulary::AttributeBuilder::helpful()
.value_type(ValueType::String)
.multival(false)
.unique(vocabulary::attribute::Unique::Identity)
.unique(Unique::Identity)
.build()),
// This phrasing is backward, but this is just a test.