Implement LogicManager and Explanation

dependencies/vaticle/repositories.bzl

@@ -46,7 +46,7 @@ def vaticle_typedb_behaviour():
     git_repository(
         name = "vaticle_typedb_behaviour",
         remote = "https://github.com/vaticle/typedb-behaviour",
-        commit = "d4947828f570853b71f0eb8aefd34af7b5a485fb",
+        commit = "d4947828f570853b71f0eb8aefd34af7b5a485fb", # sync-marker: do not remove this comment, this is used for sync-dependencies by @vaticle_typedb_behaviour
     )
 
 def vaticle_typeql():

src/answer/concept_map.rs

@@ -26,9 +26,10 @@ use std::{
 
 use crate::concept::Concept;
 
-#[derive(Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct ConceptMap {
     pub map: HashMap<String, Concept>,
+    pub explainables: Explainables,
 }
 
 impl ConceptMap {
@@ -39,20 +40,6 @@ impl ConceptMap {
     pub fn concepts(&self) -> impl Iterator<Item = &Concept> {
         self.map.values()
     }
-
-    pub fn concepts_to_vec(&self) -> Vec<&Concept> {
-        self.concepts().collect::<Vec<&Concept>>()
-    }
-}
-
-impl Clone for ConceptMap {
-    fn clone(&self) -> Self {
-        let mut map = HashMap::with_capacity(self.map.len());
-        for (k, v) in &self.map {
-            map.insert(k.clone(), v.clone());
-        }
-        Self { map }
-    }
 }
 
 impl From<ConceptMap> for HashMap<String, Concept> {
@@ -77,3 +64,28 @@ impl IntoIterator for ConceptMap {
         self.map.into_iter()
     }
 }
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Explainables {
+    pub relations: HashMap<String, Explainable>,
+    pub attributes: HashMap<String, Explainable>,
+    pub ownerships: HashMap<(String, String), Explainable>,
+}
+
+impl Explainables {
+    pub fn is_empty(&self) -> bool {
+        self.relations.is_empty() && self.attributes.is_empty() && self.ownerships.is_empty()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Explainable {
+    pub conjunction: String,
+    pub id: i64,
+}
+
+impl Explainable {
+    pub(crate) fn new(conjunction: String, id: i64) -> Self {
+        Self { conjunction, id }
+    }
+}

src/answer/mod.rs

@@ -19,11 +19,14 @@
  * under the License.
  */
 
-mod concept_map;
+pub mod concept_map;
 mod concept_map_group;
 mod numeric;
 mod numeric_group;
 
 pub use self::{
-    concept_map::ConceptMap, concept_map_group::ConceptMapGroup, numeric::Numeric, numeric_group::NumericGroup,
+    concept_map::{ConceptMap, Explainable, Explainables},
+    concept_map_group::ConceptMapGroup,
+    numeric::Numeric,
+    numeric_group::NumericGroup,
 };

src/common/error.rs

@@ -44,6 +44,8 @@ error_messages! { ConnectionError
         9: "Missing field in message received from server: '{}'.",
     UnknownRequestId(RequestID) =
         10: "Received a response with unknown request id '{}'",
+    InvalidResponseField(&'static str) =
+        11: "Invalid field in message received from server: '{}'.",
     ClusterUnableToConnect(String) =
         12: "Unable to connect to TypeDB Cluster. Attempted connecting to the cluster members, but none are available: '{}'.",
     ClusterReplicaNotPrimary() =

src/concept/mod.rs

@@ -29,7 +29,7 @@ pub use self::{
     },
 };
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum Concept {
     RootThingType(RootThingType),
 

src/concept/thing.rs

@@ -47,19 +47,22 @@ impl Thing {
 pub struct Entity {
     pub iid: IID,
     pub type_: EntityType,
+    pub is_inferred: bool,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Relation {
     pub iid: IID,
     pub type_: RelationType,
+    pub is_inferred: bool,
 }
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct Attribute {
     pub iid: IID,
     pub type_: AttributeType,
     pub value: Value,
+    pub is_inferred: bool,
 }
 
 #[derive(Clone, Debug, PartialEq)]

src/connection/message.rs

@@ -24,6 +24,7 @@ use std::time::Duration;
 use tokio::sync::mpsc::UnboundedSender;
 use tonic::Streaming;
 use typedb_protocol::transaction;
+use typeql_lang::pattern::{Conjunction, Variable};
 
 use crate::{
     answer::{ConceptMap, ConceptMapGroup, Numeric, NumericGroup},
@@ -32,6 +33,7 @@ use crate::{
         Annotation, Attribute, AttributeType, Entity, EntityType, Relation, RelationType, RoleType, SchemaException,
         Thing, ThingType, Transitivity, Value, ValueType,
     },
+    logic::{Explanation, Rule},
     Options, SessionType, TransactionType,
 };
 
@@ -108,6 +110,8 @@ pub(super) enum TransactionRequest {
     RoleType(RoleTypeRequest),
     Thing(ThingRequest),
     Stream { request_id: RequestID },
+    Rule(RuleRequest),
+    Logic(LogicRequest),
 }
 
 #[derive(Debug)]
@@ -120,6 +124,8 @@ pub(super) enum TransactionResponse {
     ThingType(ThingTypeResponse),
     RoleType(RoleTypeResponse),
     Thing(ThingResponse),
+    Rule(RuleResponse),
+    Logic(LogicResponse),
 }
 
 #[derive(Debug)]
@@ -152,7 +158,7 @@ pub(super) enum QueryResponse {
 
     MatchAggregate { answer: Numeric },
 
-    Explain {}, // TODO: explanations
+    Explain { answers: Vec<Explanation> },
 
     MatchGroup { answers: Vec<ConceptMapGroup> },
     MatchGroupAggregate { answers: Vec<NumericGroup> },
@@ -457,3 +463,29 @@ pub(super) enum ThingResponse {
 
     AttributeGetOwners { owners: Vec<Thing> },
 }
+
+#[derive(Debug)]
+pub(super) enum RuleRequest {
+    Delete { label: String },
+    SetLabel { current_label: String, new_label: String },
+}
+
+#[derive(Debug)]
+pub(super) enum RuleResponse {
+    Delete,
+    SetLabel,
+}
+
+#[derive(Debug)]
+pub(super) enum LogicRequest {
+    PutRule { label: String, when: Conjunction, then: Variable },
+    GetRule { label: String },
+    GetRules,
+}
+
+#[derive(Debug)]
+pub(super) enum LogicResponse {
+    PutRule { rule: Rule },
+    GetRule { rule: Rule },
+    GetRules { rules: Vec<Rule> },
+}

src/connection/network/proto/concept.rs

@@ -31,19 +31,21 @@ use typedb_protocol::{
     r#type::{annotation, Annotation as AnnotationProto, Transitivity as TransitivityProto},
     thing, thing_type, Attribute as AttributeProto, AttributeType as AttributeTypeProto, Concept as ConceptProto,
     ConceptMap as ConceptMapProto, ConceptMapGroup as ConceptMapGroupProto, Entity as EntityProto,
-    EntityType as EntityTypeProto, Numeric as NumericProto, NumericGroup as NumericGroupProto,
+    EntityType as EntityTypeProto, Explainable as ExplainableProto, Explainables as ExplainablesProto,
+    Explanation as ExplanationProto, Numeric as NumericProto, NumericGroup as NumericGroupProto,
     Relation as RelationProto, RelationType as RelationTypeProto, RoleType as RoleTypeProto, Thing as ThingProto,
     ThingType as ThingTypeProto,
 };
 
 use super::{FromProto, IntoProto, TryFromProto};
 use crate::{
-    answer::{ConceptMap, ConceptMapGroup, Numeric, NumericGroup},
+    answer::{ConceptMap, ConceptMapGroup, Explainable, Explainables, Numeric, NumericGroup},
     concept::{
         Annotation, Attribute, AttributeType, Concept, Entity, EntityType, Relation, RelationType, RoleType,
         RootThingType, ScopedLabel, Thing, ThingType, Transitivity, Value, ValueType,
     },
     error::{ConnectionError, InternalError},
+    logic::{Explanation, Rule},
     Result,
 };
 
@@ -97,11 +99,11 @@ impl TryFromProto<ConceptMapGroupProto> for ConceptMapGroup {
 
 impl TryFromProto<ConceptMapProto> for ConceptMap {
     fn try_from_proto(proto: ConceptMapProto) -> Result<Self> {
-        let mut map = HashMap::with_capacity(proto.map.len());
-        for (k, v) in proto.map {
-            map.insert(k, Concept::try_from_proto(v)?);
-        }
-        Ok(Self { map })
+        let ConceptMapProto { map: map_proto, explainables: explainables_proto } = proto;
+        let map = map_proto.into_iter().map(|(k, v)| Concept::try_from_proto(v).map(|v| (k, v))).try_collect()?;
+        let explainables = explainables_proto
+            .ok_or::<ConnectionError>(ConnectionError::MissingResponseField("explainables").into())?;
+        Ok(Self { map, explainables: Explainables::from_proto(explainables) })
     }
 }
 
@@ -277,66 +279,64 @@ impl IntoProto<ThingProto> for Thing {
 
 impl TryFromProto<EntityProto> for Entity {
     fn try_from_proto(proto: EntityProto) -> Result<Self> {
-        let EntityProto { iid, entity_type, inferred: _ } = proto;
+        let EntityProto { iid, entity_type, inferred } = proto;
         Ok(Self {
             iid: iid.into(),
             type_: EntityType::from_proto(entity_type.ok_or(ConnectionError::MissingResponseField("entity_type"))?),
+            is_inferred: inferred,
         })
     }
 }
 
 impl IntoProto<EntityProto> for Entity {
     fn into_proto(self) -> EntityProto {
-        EntityProto {
-            iid: self.iid.into(),
-            entity_type: Some(self.type_.into_proto()),
-            inferred: false, // FIXME
-        }
+        let Self { iid, type_, is_inferred } = self;
+        EntityProto { iid: iid.into(), entity_type: Some(type_.into_proto()), inferred: is_inferred }
     }
 }
 
 impl TryFromProto<RelationProto> for Relation {
     fn try_from_proto(proto: RelationProto) -> Result<Self> {
-        let RelationProto { iid, relation_type, inferred: _ } = proto;
+        let RelationProto { iid, relation_type, inferred } = proto;
         Ok(Self {
             iid: iid.into(),
             type_: RelationType::from_proto(
                 relation_type.ok_or(ConnectionError::MissingResponseField("relation_type"))?,
             ),
+            is_inferred: inferred,
         })
     }
 }
 
 impl IntoProto<RelationProto> for Relation {
     fn into_proto(self) -> RelationProto {
-        RelationProto {
-            iid: self.iid.into(),
-            relation_type: Some(self.type_.into_proto()),
-            inferred: false, // FIXME
-        }
+        let Self { iid, type_, is_inferred } = self;
+        RelationProto { iid: iid.into(), relation_type: Some(type_.into_proto()), inferred: is_inferred }
     }
 }
 
 impl TryFromProto<AttributeProto> for Attribute {
     fn try_from_proto(proto: AttributeProto) -> Result<Self> {
-        let AttributeProto { iid, attribute_type, value, inferred: _ } = proto;
+        let AttributeProto { iid, attribute_type, value, inferred } = proto;
         Ok(Self {
             iid: iid.into(),
             type_: AttributeType::try_from_proto(
                 attribute_type.ok_or(ConnectionError::MissingResponseField("attribute_type"))?,
             )?,
             value: Value::try_from_proto(value.ok_or(ConnectionError::MissingResponseField("value"))?)?,
+            is_inferred: inferred,
         })
     }
 }
 
 impl IntoProto<AttributeProto> for Attribute {
     fn into_proto(self) -> AttributeProto {
+        let Self { iid, type_, value, is_inferred } = self;
         AttributeProto {
-            iid: self.iid.into(),
-            attribute_type: Some(self.type_.into_proto()),
-            value: Some(self.value.into_proto()),
-            inferred: false, // FIXME
+            iid: iid.into(),
+            attribute_type: Some(type_.into_proto()),
+            value: Some(value.into_proto()),
+            inferred: is_inferred,
         }
     }
 }
@@ -369,3 +369,51 @@ impl IntoProto<ValueProto> for Value {
         }
     }
 }
+
+impl FromProto<ExplainablesProto> for Explainables {
+    fn from_proto(proto: ExplainablesProto) -> Self {
+        let ExplainablesProto {
+            relations: relations_proto,
+            attributes: attributes_proto,
+            ownerships: ownerships_proto,
+        } = proto;
+        let relations = relations_proto.into_iter().map(|(k, v)| (k, Explainable::from_proto(v))).collect();
+        let attributes = attributes_proto.into_iter().map(|(k, v)| (k, Explainable::from_proto(v))).collect();
+        let mut ownerships = HashMap::new();
+        for (k1, owned) in ownerships_proto {
+            for (k2, v) in owned.owned {
+                ownerships.insert((k1.clone(), k2), Explainable::from_proto(v));
+            }
+        }
+
+        Self { relations, attributes, ownerships }
+    }
+}
+
+impl FromProto<ExplainableProto> for Explainable {
+    fn from_proto(proto: ExplainableProto) -> Self {
+        let ExplainableProto { conjunction, id } = proto;
+        Self::new(conjunction, id)
+    }
+}
+
+impl TryFromProto<ExplanationProto> for Explanation {
+    fn try_from_proto(proto: ExplanationProto) -> Result<Self> {
+        let ExplanationProto { rule, conclusion, condition, var_mapping } = proto;
+        let mut variable_mapping = HashMap::with_capacity(var_mapping.len());
+        for (k, v) in var_mapping {
+            variable_mapping.insert(k, v.vars);
+        }
+
+        Ok(Self {
+            rule: Rule::try_from_proto(rule.ok_or(ConnectionError::MissingResponseField("rule"))?)?,
+            conclusion: ConceptMap::try_from_proto(
+                conclusion.ok_or(ConnectionError::MissingResponseField("conclusion"))?,
+            )?,
+            condition: ConceptMap::try_from_proto(
+                condition.ok_or(ConnectionError::MissingResponseField("condition"))?,
+            )?,
+            variable_mapping,
+        })
+    }
+}