surrealdb-sql 1.1.0

Full type definitions for the SurrealQL query language
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

use crate::idiom::Idiom;
use crate::part::Part;
use crate::value::Value;

impl Value {
	pub(crate) fn every(&self, path: Option<&[Part]>, steps: bool, arrays: bool) -> Vec<Idiom> {
		match path {
			Some(path) => self.pick(path)._every(steps, arrays, Idiom::from(path)),
			None => self._every(steps, arrays, Idiom::default()),
		}
	}
	fn _every(&self, steps: bool, arrays: bool, prev: Idiom) -> Vec<Idiom> {
		match self {
			// Current path part is an object and is not empty
			Value::Object(v) if !v.is_empty() => match steps {
				// Let's log all intermediary nodes
				true if !prev.is_empty() => Some(prev.clone())
					.into_iter()
					.chain(v.iter().flat_map(|(k, v)| {
						let p = Part::from(k.to_owned());
						v._every(steps, arrays, prev.clone().push(p))
					}))
					.collect::<Vec<_>>(),
				// Let's not log intermediary nodes
				_ => v
					.iter()
					.flat_map(|(k, v)| {
						let p = Part::from(k.to_owned());
						v._every(steps, arrays, prev.clone().push(p))
					})
					.collect::<Vec<_>>(),
			},
			// Current path part is an array and is not empty
			Value::Array(v) if !v.is_empty() => match arrays {
				// Let's log all individual array items
				true => std::iter::once(prev.clone())
					.chain(v.iter().enumerate().rev().flat_map(|(i, v)| {
						let p = Part::from(i.to_owned());
						v._every(steps, arrays, prev.clone().push(p))
					}))
					.collect::<Vec<_>>(),
				// Let's not log individual array items
				false => vec![prev],
			},
			// Process everything else
			_ => vec![prev],
		}
	}
}

#[cfg(test)]
mod tests {

	use super::*;
	use crate::idiom::Idiom;
	use crate::syn::test::Parse;

	#[test]
	fn every_with_empty_objects_arrays() {
		let val = Value::parse("{ test: {}, status: false, something: {age: 45}, tags: []}");
		let res = vec![
			Idiom::parse("something.age"),
			Idiom::parse("status"),
			Idiom::parse("tags"),
			Idiom::parse("test"),
		];
		assert_eq!(res, val.every(None, false, false));
	}

	#[test]
	fn every_without_array_indexes() {
		let val = Value::parse("{ test: { something: [{ age: 34, tags: ['code', 'databases'] }, { age: 36, tags: ['design', 'operations'] }] } }");
		let res = vec![Idiom::parse("test.something")];
		assert_eq!(res, val.every(None, false, false));
	}

	#[test]
	fn every_including_array_indexes() {
		let val = Value::parse("{ test: { something: [{ age: 34, tags: ['code', 'databases'] }, { age: 36, tags: ['design', 'operations'] }] } }");
		let res = vec![
			Idiom::parse("test.something"),
			Idiom::parse("test.something[1].age"),
			Idiom::parse("test.something[1].tags"),
			Idiom::parse("test.something[1].tags[1]"),
			Idiom::parse("test.something[1].tags[0]"),
			Idiom::parse("test.something[0].age"),
			Idiom::parse("test.something[0].tags"),
			Idiom::parse("test.something[0].tags[1]"),
			Idiom::parse("test.something[0].tags[0]"),
		];
		assert_eq!(res, val.every(None, false, true));
	}

	#[test]
	fn every_including_intermediary_nodes_without_array_indexes() {
		let val = Value::parse("{ test: { something: [{ age: 34, tags: ['code', 'databases'] }, { age: 36, tags: ['design', 'operations'] }] } }");
		let res = vec![Idiom::parse("test"), Idiom::parse("test.something")];
		assert_eq!(res, val.every(None, true, false));
	}

	#[test]
	fn every_including_intermediary_nodes_including_array_indexes() {
		let val = Value::parse("{ test: { something: [{ age: 34, tags: ['code', 'databases'] }, { age: 36, tags: ['design', 'operations'] }] } }");
		let res = vec![
			Idiom::parse("test"),
			Idiom::parse("test.something"),
			Idiom::parse("test.something[1]"),
			Idiom::parse("test.something[1].age"),
			Idiom::parse("test.something[1].tags"),
			Idiom::parse("test.something[1].tags[1]"),
			Idiom::parse("test.something[1].tags[0]"),
			Idiom::parse("test.something[0]"),
			Idiom::parse("test.something[0].age"),
			Idiom::parse("test.something[0].tags"),
			Idiom::parse("test.something[0].tags[1]"),
			Idiom::parse("test.something[0].tags[0]"),
		];
		assert_eq!(res, val.every(None, true, true));
	}
}