Enum QueryPatternV2 

pub enum QueryPatternV2 {
    FieldValue {
        field: QueryFieldV2,
        comparator: QueryComparatorV2,
        value: CompatibilityValueV2,
    },
    FieldComparison {
        left: QueryFieldV2,
        comparator: QueryComparatorV2,
        right: QueryFieldV2,
    },
    FieldPresence {
        field: QueryFieldV2,
        present: bool,
    },
    BindingIid {
        binding: BindingId,
        iid: String,
    },
    RoleEdge {
        include_relation_subtypes: bool,
        player: BindingId,
        relation: BindingId,
        relation_type: TypeId,
        role: RoleId,
    },
    Reachable {
        min_depth: u8,
        max_depth: u8,
        relation: TypeId,
        role_from: RoleId,
        role_to: RoleId,
        source: BindingId,
        target: BindingId,
    },
    And {
        patterns: Vec<QueryPatternV2>,
    },
    Or {
        patterns: Vec<QueryPatternV2>,
    },
    Not {
        pattern: Box<QueryPatternV2>,
    },
}

The closed boolean compatibility algebra used by the production adapter.

Variants

FieldValue

Compare one bound field with one exact scalar literal.

Fields

field: QueryFieldV2

Descriptor-qualified field.

comparator: QueryComparatorV2

Closed comparison operator.

value: CompatibilityValueV2

Canonical or released-only typed literal.

FieldComparison

Compare two descriptor-qualified bound fields.

Fields

left: QueryFieldV2

Left field.

comparator: QueryComparatorV2

Closed non-string comparison operator.

right: QueryFieldV2

Right field.

FieldPresence

Require one descriptor-qualified field to be present or absent.

Fields

field: QueryFieldV2

Descriptor-qualified field.

present: bool

true requires at least one value; false requires none.

BindingIid

Match one thing binding by its canonical provider IID.

Fields

binding: BindingId

Thing binding.

iid: String

Canonical TypeDB thing IID.

RoleEdge

Require one descriptor-qualified role edge.

Fields

include_relation_subtypes: bool

Whether relation subtypes remain admitted while matching the edge.

player: BindingId

Player binding.

relation: BindingId

Relation binding.

relation_type: TypeId

Declared relation type.

role: RoleId

Descriptor-qualified role.

Reachable

Require one finite directed walk.

Fields

min_depth: u8

Inclusive minimum hop count.

max_depth: u8

Inclusive maximum hop count.

relation: TypeId

Exact relation type used for every hop.

role_from: RoleId

Source role.

role_to: RoleId

Target role.

source: BindingId

Source binding.

target: BindingId

Target binding.

And

Require every child in source order.

Fields

patterns: Vec<QueryPatternV2>

Non-empty children.

Or

Require at least one branch in source order.

Fields

patterns: Vec<QueryPatternV2>

Non-empty branches.

Not

Negate one closed child.

Fields

pattern: Box<QueryPatternV2>

Negated child.

Trait Implementations

impl Clone for QueryPatternV2

fn clone(&self) -> QueryPatternV2

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueryPatternV2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QueryPatternV2

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for QueryPatternV2

impl PartialEq for QueryPatternV2

fn eq(&self, other: &QueryPatternV2) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for QueryPatternV2

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for QueryPatternV2