zeppelin-embed 0.8.0

In-process vector, lexical, and hybrid search for macOS and Apple silicon
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use super::expression::expression;
use super::validate::add_slot;
use super::*;
pub(super) fn validate(
    description: PlanDescription<'_>,
    items: &[Mutation<'_>],
    output: &mut NodeFacts,
    seen: &mut [bool; MAX_PLAN_NODES],
    context: &mut ValueContext<'_>,
) -> Result<(), PlanError> {
    for item in items {
        context.step()?;
        match *item {
            Mutation::CreateNode { output: slot, .. } => add_slot(
                output,
                Slot {
                    id: slot.0,
                    kinds: ValueKinds::NODE,
                },
            )?,
            Mutation::CreateRelationship {
                output: slot,
                source,
                target,
                ..
            } => {
                entity(description, source, output, seen, context, ValueKinds::NODE)?;
                entity(description, target, output, seen, context, ValueKinds::NODE)?;
                add_slot(
                    output,
                    Slot {
                        id: slot.0,
                        kinds: ValueKinds::REL,
                    },
                )?;
            }
            Mutation::SetProperty {
                entity: receiver,
                value,
                ..
            } => {
                entity(
                    description,
                    receiver,
                    output,
                    seen,
                    context,
                    ValueKinds::NODE
                        .union(ValueKinds::REL)
                        .union(ValueKinds::NULL),
                )?;
                let value = expression(description, value, output, seen, context)?;
                if !value.overlaps(
                    ValueKinds::NULL
                        .union(ValueKinds::BOOL)
                        .union(ValueKinds::I64)
                        .union(ValueKinds::F64)
                        .union(ValueKinds::STRING)
                        .union(ValueKinds::LIST),
                ) {
                    return Err(PlanError::Type);
                }
            }
            Mutation::RemoveProperty {
                entity: receiver, ..
            } => entity(
                description,
                receiver,
                output,
                seen,
                context,
                ValueKinds::NODE
                    .union(ValueKinds::REL)
                    .union(ValueKinds::NULL),
            )?,
            Mutation::SetLabel {
                entity: receiver, ..
            } => entity(
                description,
                receiver,
                output,
                seen,
                context,
                ValueKinds::NODE.union(ValueKinds::NULL),
            )?,
            Mutation::Delete {
                entity: receiver, ..
            } => entity(
                description,
                receiver,
                output,
                seen,
                context,
                ValueKinds::NODE
                    .union(ValueKinds::REL)
                    .union(ValueKinds::NULL),
            )?,
        }
    }
    Ok(())
}
fn entity(
    description: PlanDescription<'_>,
    id: ExprId,
    scope: &NodeFacts,
    seen: &mut [bool; MAX_PLAN_NODES],
    context: &mut ValueContext<'_>,
    kinds: ValueKinds,
) -> Result<(), PlanError> {
    if !expression(description, id, scope, seen, context)?.overlaps(kinds) {
        return Err(PlanError::Type);
    }
    Ok(())
}