linkrs-query 0.1.0

Query engine, parser, and executor for Linkrs
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::parser::ast::{CopyDirection, CopyTarget, TagInsertSpec};

use linkrs_core::types::EdgeDirection;

use super::expr::BoundExpression;

#[derive(Debug, Clone)]
pub struct BoundInsert {
    pub target: BoundInsertTarget,
    pub if_not_exists: bool,
}

#[derive(Debug, Clone)]
pub enum BoundInsertTarget {
    Vertices {
        tag: TagInsertSpec,
        values: Vec<BoundVertexRow>,
    },
    Edge {
        edge_name: String,
        prop_names: Vec<String>,
        edges: Vec<(
            BoundExpression,
            BoundExpression,
            Option<BoundExpression>,
            Vec<BoundExpression>,
        )>,
    },
}

#[derive(Debug, Clone)]
pub struct BoundVertexRow {
    pub vid: BoundExpression,
    pub values: Vec<BoundExpression>,
}

#[derive(Debug, Clone)]
pub struct BoundUpdate {
    pub target: BoundUpdateTarget,
    pub assignments: Vec<BoundAssignment>,
    pub where_clause: Option<BoundExpression>,
    pub is_upsert: bool,
}

#[derive(Debug, Clone)]
pub enum BoundUpdateTarget {
    Vertex(BoundExpression),
    Edge(Box<BoundEdgeUpdateTarget>),
    Tag(String),
    TagOnVertex {
        vid: BoundExpression,
        tag_name: String,
    },
}

/// Edge update target payload. Boxed inside [`BoundUpdateTarget::Edge`] so the
/// several large `BoundExpression` fields do not inflate every enum variant.
#[derive(Debug, Clone)]
pub struct BoundEdgeUpdateTarget {
    pub src: BoundExpression,
    pub dst: BoundExpression,
    pub edge_type: Option<String>,
    pub rank: Option<BoundExpression>,
}

#[derive(Debug, Clone)]
pub struct BoundAssignment {
    pub property: String,
    pub value: BoundExpression,
    pub target: Option<BoundExpression>,
    pub object: Option<BoundExpression>,
    pub is_map_overwrite: bool,
}

#[derive(Debug, Clone)]
pub struct BoundDelete {
    pub target: BoundDeleteTarget,
    pub with_edge: bool,
    pub detach: bool,
}

#[derive(Debug, Clone)]
pub enum BoundDeleteTarget {
    Vertices {
        tag: String,
        ids: Vec<BoundExpression>,
    },
    Edges {
        edge_type: Option<String>,
        edges: Vec<(BoundExpression, BoundExpression, Option<BoundExpression>)>,
    },
    Index(String),
}

// ── Bound pattern types (replace raw AST patterns) ───────────────────────────

#[derive(Debug, Clone)]
pub struct BoundPatternVertex {
    pub variable: Option<String>,
    pub labels: Vec<String>,
    pub properties: Option<Vec<(String, BoundExpression)>>,
}

#[derive(Debug, Clone)]
pub struct BoundPatternEdge {
    pub variable: Option<String>,
    pub edge_types: Vec<String>,
    pub properties: Option<Vec<(String, BoundExpression)>>,
    pub direction: EdgeDirection,
}

#[derive(Debug, Clone)]
pub enum BoundMergePattern {
    Node(BoundPatternVertex),
    Edge {
        src: BoundPatternVertex,
        edge: BoundPatternEdge,
        dst: BoundPatternVertex,
    },
}

#[derive(Debug, Clone)]
pub struct BoundMerge {
    pub pattern: BoundMergePattern,
    pub on_create: Vec<BoundAssignment>,
    pub on_match: Vec<BoundAssignment>,
}

#[derive(Debug, Clone)]
pub struct BoundSet {
    pub assignments: Vec<BoundAssignment>,
}

#[derive(Debug, Clone)]
pub struct BoundRemove {
    pub items: Vec<BoundExpression>,
}

#[derive(Debug, Clone)]
pub struct BoundCopy {
    pub target: CopyTarget,
    pub direction: CopyDirection,
    pub file_paths: Vec<String>,
    pub by_column: bool,
    pub header: bool,
    pub delimiter: char,
    pub batch_size: Option<usize>,
}