gremlin_client/process/traversal/
graph_traversal_source.rs

1use crate::conversion::{FromGValue, ToGValue};
2use crate::process::traversal::strategies::{
3    RemoteStrategy, TraversalStrategies, TraversalStrategy,
4};
5
6#[cfg(feature = "async_gremlin")]
7use crate::aio::process::traversal::remote::AsyncTerminator;
8#[cfg(feature = "async_gremlin")]
9use crate::aio::GremlinClient as GremlinAsyncClient;
10use crate::process::traversal::remote::{MockTerminator, SyncTerminator, Terminator};
11use crate::process::traversal::Bytecode;
12use crate::process::traversal::{GraphTraversal, TraversalBuilder};
13use crate::structure::GIDs;
14use crate::structure::Labels;
15use crate::structure::{Edge, GValue, Vertex};
16use crate::GremlinClient;
17
18#[derive(Clone)]
19pub struct GraphTraversalSource<A: Terminator<GValue>> {
20    term: A,
21}
22
23impl<A: Terminator<GValue>> GraphTraversalSource<A> {
24    pub fn new(terminator: A) -> GraphTraversalSource<A> {
25        GraphTraversalSource { term: terminator }
26    }
27
28    pub fn empty() -> GraphTraversalSource<MockTerminator> {
29        GraphTraversalSource::new(MockTerminator {})
30    }
31
32    pub fn with_remote(&self, client: GremlinClient) -> GraphTraversalSource<SyncTerminator> {
33        let mut strategies = TraversalStrategies::new(vec![]);
34
35        strategies.add_strategy(TraversalStrategy::Remote(RemoteStrategy::new(client)));
36
37        GraphTraversalSource {
38            term: SyncTerminator::new(strategies),
39        }
40    }
41
42    #[cfg(feature = "async_gremlin")]
43    pub fn with_remote_async(
44        &self,
45        client: GremlinAsyncClient,
46    ) -> GraphTraversalSource<AsyncTerminator> {
47        GraphTraversalSource {
48            term: AsyncTerminator::new(client),
49        }
50    }
51
52    pub fn v<T>(&self, ids: T) -> GraphTraversal<Vertex, Vertex, A>
53    where
54        T: Into<GIDs>,
55        A: Terminator<Vertex>,
56    {
57        let mut code = Bytecode::new();
58
59        code.add_step(
60            String::from("V"),
61            ids.into().0.iter().map(|id| id.to_gvalue()).collect(),
62        );
63
64        GraphTraversal::new(self.term.clone(), TraversalBuilder::new(code))
65    }
66
67    pub fn add_v<T>(&self, label: T) -> GraphTraversal<Vertex, Vertex, A>
68    where
69        T: Into<Labels>,
70        A: Terminator<Vertex>,
71    {
72        let mut code = Bytecode::new();
73
74        code.add_step(
75            String::from("addV"),
76            label.into().0.into_iter().map(GValue::from).collect(),
77        );
78
79        GraphTraversal::new(self.term.clone(), TraversalBuilder::new(code))
80    }
81
82    pub fn add_e<T>(&self, label: T) -> GraphTraversal<Edge, Edge, A>
83    where
84        T: Into<Labels>,
85        A: Terminator<Edge>,
86    {
87        let mut code = Bytecode::new();
88
89        code.add_step(
90            String::from("addE"),
91            label.into().0.into_iter().map(GValue::from).collect(),
92        );
93
94        GraphTraversal::new(self.term.clone(), TraversalBuilder::new(code))
95    }
96
97    pub fn e<T>(&self, ids: T) -> GraphTraversal<Edge, Edge, A>
98    where
99        T: Into<GIDs>,
100        A: Terminator<Edge>,
101    {
102        let mut code = Bytecode::new();
103
104        code.add_step(
105            String::from("E"),
106            ids.into().0.iter().map(|id| id.to_gvalue()).collect(),
107        );
108
109        GraphTraversal::new(self.term.clone(), TraversalBuilder::new(code))
110    }
111
112    pub fn with_side_effect<T>(&self, step: (&'static str, T)) -> GraphTraversal<GValue, GValue, A>
113    where
114        T: Into<GValue> + FromGValue,
115        A: Terminator<T>,
116    {
117        let mut code = Bytecode::new();
118
119        code.add_source(
120            String::from("withSideEffect"),
121            vec![step.0.into(), step.1.into()],
122        );
123        GraphTraversal::new(self.term.clone(), TraversalBuilder::new(code))
124    }
125}
126
127// TESTS
128#[cfg(test)]
129mod tests {
130
131    use crate::process::traversal::remote::MockTerminator;
132
133    use super::GraphTraversalSource;
134    use crate::process::traversal::{Bytecode, Order, Scope, __};
135    use crate::structure::{GValue, P, T};
136
137    fn empty() -> GraphTraversalSource<MockTerminator> {
138        GraphTraversalSource::new(MockTerminator {})
139    }
140
141    #[test]
142    fn v_traversal() {
143        let g = empty();
144
145        let mut code = Bytecode::new();
146
147        code.add_step(String::from("V"), vec![1.into()]);
148
149        assert_eq!(&code, g.v(1).bytecode());
150    }
151
152    #[test]
153    fn e_traversal() {
154        let g = empty();
155
156        let mut code = Bytecode::new();
157
158        code.add_step(String::from("E"), vec![1.into()]);
159
160        assert_eq!(&code, g.e(1).bytecode());
161    }
162    #[test]
163    fn v_has_label_traversal() {
164        let g = empty();
165
166        let mut code = Bytecode::new();
167
168        code.add_step(String::from("V"), vec![1.into()]);
169        code.add_step(
170            String::from("hasLabel"),
171            vec![String::from("person").into()],
172        );
173
174        assert_eq!(&code, g.v(1).has_label("person").bytecode());
175    }
176
177    #[test]
178    fn v_has_traversal() {
179        let g = empty();
180
181        let mut code = Bytecode::new();
182
183        code.add_step(String::from("V"), vec![1.into()]);
184        code.add_step(
185            String::from("has"),
186            vec![
187                String::from("name").into(),
188                P::new("eq", String::from("marko").into()).into(),
189            ],
190        );
191        code.add_step(
192            String::from("has"),
193            vec![String::from("age").into(), P::new("eq", 23.into()).into()],
194        );
195
196        assert_eq!(
197            &code,
198            g.v(1).has(("name", "marko")).has(("age", 23)).bytecode()
199        );
200
201        // has with 3 params
202
203        let mut code = Bytecode::new();
204
205        code.add_step(String::from("V"), vec![]);
206        code.add_step(
207            String::from("has"),
208            vec![
209                String::from("person").into(),
210                String::from("name").into(),
211                P::new("eq", String::from("marko").into()).into(),
212            ],
213        );
214
215        assert_eq!(&code, g.v(()).has(("person", "name", "marko")).bytecode());
216
217        // has with 1 param
218
219        let mut code = Bytecode::new();
220
221        code.add_step(String::from("V"), vec![]);
222        code.add_step(String::from("has"), vec![String::from("name").into()]);
223
224        assert_eq!(&code, g.v(()).has("name").bytecode());
225
226        // hasNot
227
228        let mut code = Bytecode::new();
229
230        code.add_step(String::from("V"), vec![]);
231        code.add_step(String::from("hasNot"), vec![String::from("name").into()]);
232
233        assert_eq!(&code, g.v(()).has_not("name").bytecode());
234    }
235
236    #[test]
237    fn v_has_traversal_with_p() {
238        let g = empty();
239
240        // EQ
241        let mut code = Bytecode::new();
242
243        code.add_step(String::from("V"), vec![1.into()]);
244
245        code.add_step(
246            String::from("has"),
247            vec![String::from("age").into(), P::eq(23).into()],
248        );
249        assert_eq!(&code, g.v(1).has(("age", P::eq(23))).bytecode());
250
251        // NEQ
252        let mut code = Bytecode::new();
253
254        code.add_step(String::from("V"), vec![1.into()]);
255
256        code.add_step(
257            String::from("has"),
258            vec![String::from("age").into(), P::neq(23).into()],
259        );
260        assert_eq!(&code, g.v(1).has(("age", P::neq(23))).bytecode());
261
262        // GTE
263        let mut code = Bytecode::new();
264
265        code.add_step(String::from("V"), vec![1.into()]);
266
267        code.add_step(
268            String::from("has"),
269            vec![String::from("age").into(), P::gte(23).into()],
270        );
271
272        assert_eq!(&code, g.v(1).has(("age", P::gte(23))).bytecode());
273
274        // GT
275        let mut code = Bytecode::new();
276
277        code.add_step(String::from("V"), vec![1.into()]);
278
279        code.add_step(
280            String::from("has"),
281            vec![String::from("age").into(), P::gt(23).into()],
282        );
283
284        assert_eq!(&code, g.v(1).has(("age", P::gt(23))).bytecode());
285
286        // LTE
287        let mut code = Bytecode::new();
288
289        code.add_step(String::from("V"), vec![1.into()]);
290
291        code.add_step(
292            String::from("has"),
293            vec![String::from("age").into(), P::lte(23).into()],
294        );
295        assert_eq!(&code, g.v(1).has(("age", P::lte(23))).bytecode());
296
297        // LT
298        let mut code = Bytecode::new();
299
300        code.add_step(String::from("V"), vec![1.into()]);
301
302        code.add_step(
303            String::from("has"),
304            vec![String::from("age").into(), P::lt(23).into()],
305        );
306        assert_eq!(&code, g.v(1).has(("age", P::lt(23))).bytecode());
307
308        // Within
309        let mut code = Bytecode::new();
310
311        code.add_step(String::from("V"), vec![1.into()]);
312
313        code.add_step(
314            String::from("has"),
315            vec![String::from("age").into(), P::within((23, 26)).into()],
316        );
317        assert_eq!(&code, g.v(1).has(("age", P::within((23, 26)))).bytecode());
318
319        // IS
320        let mut code = Bytecode::new();
321
322        code.add_step(String::from("V"), vec![1.into()]);
323        code.add_step(String::from("values"), vec!["age".into()]);
324        code.add_step(String::from("is"), vec![P::eq(23).into()]);
325
326        assert_eq!(&code, g.v(1).values("age").is(23).bytecode());
327    }
328    #[test]
329    fn add_v_test() {
330        let g = empty();
331
332        let mut code = Bytecode::new();
333
334        code.add_step(String::from("addV"), vec![String::from("person").into()]);
335
336        assert_eq!(&code, g.add_v("person").bytecode());
337
338        let mut code = Bytecode::new();
339
340        code.add_step(String::from("addV"), vec![]);
341
342        assert_eq!(&code, g.add_v(()).bytecode());
343    }
344
345    #[test]
346    fn add_v_with_property_test() {
347        let g = empty();
348
349        let mut code = Bytecode::new();
350
351        code.add_step(String::from("addV"), vec![String::from("person").into()]);
352        code.add_step(
353            String::from("property"),
354            vec![String::from("name").into(), String::from("marko").into()],
355        );
356
357        assert_eq!(
358            &code,
359            g.add_v("person").property("name", "marko").bytecode()
360        );
361    }
362
363    #[test]
364    fn add_e_test() {
365        let g = empty();
366
367        let mut code = Bytecode::new();
368
369        code.add_step(String::from("addE"), vec![String::from("knows").into()]);
370
371        assert_eq!(&code, g.add_e("knows").bytecode());
372
373        let mut code = Bytecode::new();
374
375        code.add_step(String::from("addE"), vec![String::from("knows").into()]);
376        code.add_step(String::from("from"), vec![String::from("a").into()]);
377        code.add_step(String::from("to"), vec![String::from("b").into()]);
378
379        assert_eq!(&code, g.add_e("knows").from("a").to("b").bytecode());
380    }
381
382    #[test]
383    fn add_e_test_with_traversal() {
384        let g = empty();
385
386        let mut code = Bytecode::new();
387
388        code.add_step(String::from("addE"), vec![String::from("knows").into()]);
389        code.add_step(
390            String::from("from"),
391            vec![__.v(1).bytecode().clone().into()],
392        );
393        code.add_step(String::from("to"), vec![__.v(2).bytecode().clone().into()]);
394
395        assert_eq!(&code, g.add_e("knows").from(__.v(1)).to(__.v(2)).bytecode());
396    }
397
398    #[test]
399    fn as_test() {
400        let g = empty();
401
402        let mut code = Bytecode::new();
403
404        code.add_step(String::from("V"), vec![]);
405        code.add_step(String::from("as"), vec![String::from("a").into()]);
406
407        assert_eq!(&code, g.v(()).as_("a").bytecode());
408    }
409
410    #[test]
411    fn label_step_test() {
412        let g = empty();
413
414        let mut code = Bytecode::new();
415
416        code.add_step(String::from("V"), vec![]);
417        code.add_step(String::from("label"), vec![]);
418
419        assert_eq!(&code, g.v(()).label().bytecode());
420    }
421
422    #[test]
423    fn properties_step_test() {
424        let g = empty();
425
426        let mut code = Bytecode::new();
427
428        code.add_step(String::from("V"), vec![]);
429        code.add_step(String::from("properties"), vec![]);
430
431        assert_eq!(&code, g.v(()).properties(()).bytecode());
432
433        let mut code = Bytecode::new();
434
435        code.add_step(String::from("V"), vec![]);
436        code.add_step(
437            String::from("properties"),
438            vec![String::from("name").into()],
439        );
440
441        assert_eq!(&code, g.v(()).properties("name").bytecode());
442
443        let mut code = Bytecode::new();
444
445        code.add_step(String::from("V"), vec![]);
446        code.add_step(
447            String::from("properties"),
448            vec![String::from("name").into(), String::from("surname").into()],
449        );
450
451        // with vec
452        assert_eq!(
453            &code,
454            g.v(()).properties(vec!["name", "surname"]).bytecode()
455        );
456
457        // without vec
458        assert_eq!(&code, g.v(()).properties(["name", "surname"]).bytecode());
459    }
460
461    #[test]
462    fn property_map_step_test() {
463        let g = empty();
464
465        let mut code = Bytecode::new();
466
467        code.add_step(String::from("V"), vec![]);
468        code.add_step(String::from("propertyMap"), vec![]);
469
470        assert_eq!(&code, g.v(()).property_map(()).bytecode());
471
472        let mut code = Bytecode::new();
473
474        code.add_step(String::from("V"), vec![]);
475        code.add_step(
476            String::from("propertyMap"),
477            vec![String::from("name").into()],
478        );
479
480        assert_eq!(&code, g.v(()).property_map("name").bytecode());
481
482        let mut code = Bytecode::new();
483
484        code.add_step(String::from("V"), vec![]);
485        code.add_step(
486            String::from("propertyMap"),
487            vec![String::from("name").into(), String::from("surname").into()],
488        );
489
490        // with vec
491        assert_eq!(
492            &code,
493            g.v(()).property_map(vec!["name", "surname"]).bytecode()
494        );
495
496        // without vec
497        assert_eq!(&code, g.v(()).property_map(["name", "surname"]).bytecode());
498    }
499
500    #[test]
501    fn values_step_test() {
502        let g = empty();
503
504        let mut code = Bytecode::new();
505
506        code.add_step(String::from("V"), vec![]);
507        code.add_step(String::from("values"), vec![]);
508
509        assert_eq!(&code, g.v(()).values(()).bytecode());
510
511        let mut code = Bytecode::new();
512
513        code.add_step(String::from("V"), vec![]);
514        code.add_step(String::from("values"), vec![String::from("name").into()]);
515
516        assert_eq!(&code, g.v(()).values("name").bytecode());
517
518        let mut code = Bytecode::new();
519
520        code.add_step(String::from("V"), vec![]);
521        code.add_step(
522            String::from("values"),
523            vec![String::from("name").into(), String::from("surname").into()],
524        );
525
526        // with vec
527        assert_eq!(&code, g.v(()).values(vec!["name", "surname"]).bytecode());
528
529        // without vec
530        assert_eq!(&code, g.v(()).values(["name", "surname"]).bytecode());
531    }
532
533    #[test]
534    fn value_map_step_test() {
535        let g = empty();
536
537        let mut code = Bytecode::new();
538
539        code.add_step(String::from("V"), vec![]);
540        code.add_step(String::from("valueMap"), vec![]);
541
542        assert_eq!(&code, g.v(()).value_map(()).bytecode());
543
544        let mut code = Bytecode::new();
545
546        code.add_step(String::from("V"), vec![]);
547        code.add_step(String::from("valueMap"), vec![String::from("name").into()]);
548
549        assert_eq!(&code, g.v(()).value_map("name").bytecode());
550
551        let mut code = Bytecode::new();
552
553        code.add_step(String::from("V"), vec![]);
554        code.add_step(
555            String::from("valueMap"),
556            vec![String::from("name").into(), String::from("surname").into()],
557        );
558
559        assert_eq!(&code, g.v(()).value_map(vec!["name", "surname"]).bytecode());
560
561        assert_eq!(&code, g.v(()).value_map(["name", "surname"]).bytecode());
562    }
563
564    #[test]
565    fn element_map_step_test() {
566        let g = empty();
567
568        let mut code = Bytecode::new();
569
570        code.add_step(String::from("V"), vec![]);
571        code.add_step(String::from("elementMap"), vec![]);
572
573        assert_eq!(&code, g.v(()).element_map(()).bytecode());
574
575        let mut code = Bytecode::new();
576
577        code.add_step(String::from("V"), vec![]);
578        code.add_step(
579            String::from("elementMap"),
580            vec![String::from("name").into()],
581        );
582
583        assert_eq!(&code, g.v(()).element_map("name").bytecode());
584
585        let mut code = Bytecode::new();
586
587        code.add_step(String::from("V"), vec![]);
588        code.add_step(
589            String::from("elementMap"),
590            vec![String::from("name").into(), String::from("surname").into()],
591        );
592
593        assert_eq!(
594            &code,
595            g.v(()).element_map(vec!["name", "surname"]).bytecode()
596        );
597
598        assert_eq!(&code, g.v(()).element_map(["name", "surname"]).bytecode());
599    }
600
601    #[test]
602    fn count_test() {
603        let g = empty();
604
605        let mut code = Bytecode::new();
606
607        code.add_step(String::from("V"), vec![]);
608        code.add_step(String::from("count"), vec![]);
609
610        assert_eq!(&code, g.v(()).count().bytecode());
611    }
612
613    #[test]
614    fn group_count_test() {
615        let g = empty();
616
617        let mut code = Bytecode::new();
618
619        code.add_step(String::from("V"), vec![]);
620        code.add_step(String::from("groupCount"), vec![]);
621
622        assert_eq!(&code, g.v(()).group_count().bytecode());
623
624        let mut code = Bytecode::new();
625
626        code.add_step(String::from("V"), vec![]);
627        code.add_step(String::from("groupCount"), vec!["m".into()]);
628
629        assert_eq!(&code, g.v(()).group_count_as("m").bytecode());
630    }
631
632    #[test]
633    fn group_count_by_test() {
634        let g = empty();
635
636        let mut code = Bytecode::new();
637
638        code.add_step(String::from("V"), vec![]);
639        code.add_step(String::from("groupCount"), vec![]);
640        code.add_step(String::from("by"), vec![]);
641
642        assert_eq!(&code, g.v(()).group_count().by(()).bytecode());
643
644        let mut code = Bytecode::new();
645
646        code.add_step(String::from("V"), vec![]);
647        code.add_step(String::from("groupCount"), vec![]);
648        code.add_step(String::from("by"), vec!["name".into()]);
649
650        assert_eq!(&code, g.v(()).group_count().by("name").bytecode());
651
652        let mut code = Bytecode::new();
653
654        code.add_step(String::from("V"), vec![]);
655        code.add_step(String::from("groupCount"), vec![]);
656        code.add_step(String::from("by"), vec![T::Label.into()]);
657
658        assert_eq!(&code, g.v(()).group_count().by(T::Label).bytecode());
659    }
660
661    #[test]
662    fn group_by_test() {
663        let g = empty();
664
665        let mut code = Bytecode::new();
666
667        code.add_step(String::from("V"), vec![]);
668        code.add_step(String::from("group"), vec![]);
669        code.add_step(String::from("by"), vec![]);
670
671        assert_eq!(&code, g.v(()).group().by(()).bytecode());
672
673        let mut code = Bytecode::new();
674
675        code.add_step(String::from("V"), vec![]);
676        code.add_step(String::from("group"), vec![]);
677        code.add_step(String::from("by"), vec!["name".into()]);
678
679        assert_eq!(&code, g.v(()).group().by("name").bytecode());
680
681        let mut code = Bytecode::new();
682
683        code.add_step(String::from("V"), vec![]);
684        code.add_step(String::from("group"), vec![]);
685        code.add_step(String::from("by"), vec![T::Label.into()]);
686
687        assert_eq!(&code, g.v(()).group().by(T::Label).bytecode());
688
689        let mut code = Bytecode::new();
690
691        code.add_step(String::from("V"), vec![]);
692        code.add_step(String::from("group"), vec![]);
693        code.add_step(String::from("by"), vec![T::Label.into()]);
694        code.add_step(
695            String::from("by"),
696            vec![__.count().bytecode().clone().into()],
697        );
698
699        assert_eq!(
700            &code,
701            g.v(()).group().by(T::Label).by(__.count()).bytecode()
702        );
703
704        let mut code = Bytecode::new();
705
706        code.add_step(String::from("V"), vec![]);
707        code.add_step(String::from("group"), vec!["m".into()]);
708        code.add_step(String::from("by"), vec![T::Label.into()]);
709
710        assert_eq!(&code, g.v(()).group_as("m").by(T::Label).bytecode());
711    }
712
713    #[test]
714    fn select_test() {
715        let g = empty();
716
717        let mut code = Bytecode::new();
718
719        code.add_step(String::from("V"), vec![]);
720        code.add_step(String::from("select"), vec!["name".into()]);
721
722        assert_eq!(&code, g.v(()).select("name").bytecode());
723
724        let mut code = Bytecode::new();
725
726        code.add_step(String::from("V"), vec![]);
727        code.add_step(
728            String::from("select"),
729            vec!["name".into(), "surname".into()],
730        );
731
732        assert_eq!(&code, g.v(()).select(vec!["name", "surname"]).bytecode());
733
734        assert_eq!(&code, g.v(()).select(["name", "surname"]).bytecode());
735    }
736
737    #[test]
738    fn fold_test() {
739        let g = empty();
740
741        let mut code = Bytecode::new();
742
743        code.add_step(String::from("V"), vec![]);
744        code.add_step(String::from("values"), vec!["name".into()]);
745        code.add_step(String::from("fold"), vec![]);
746
747        assert_eq!(&code, g.v(()).values("name").fold().bytecode());
748    }
749
750    #[test]
751    fn unfold_test() {
752        let g = empty();
753
754        let mut code = Bytecode::new();
755
756        code.add_step(String::from("V"), vec![]);
757        code.add_step(String::from("propertyMap"), vec![]);
758        code.add_step(String::from("unfold"), vec![]);
759
760        assert_eq!(&code, g.v(()).property_map(()).unfold().bytecode());
761    }
762
763    #[test]
764    fn path_test() {
765        let g = empty();
766
767        let mut code = Bytecode::new();
768
769        code.add_step(String::from("V"), vec![]);
770        code.add_step(String::from("path"), vec![]);
771
772        assert_eq!(&code, g.v(()).path().bytecode());
773    }
774
775    #[test]
776    fn limit_test() {
777        let g = empty();
778
779        let mut code = Bytecode::new();
780
781        code.add_step(String::from("V"), vec![]);
782        code.add_step(String::from("limit"), vec![GValue::Int64(1)]);
783
784        assert_eq!(&code, g.v(()).limit(1).bytecode());
785    }
786
787    #[test]
788    fn dedup_test() {
789        let g = empty();
790
791        let mut code = Bytecode::new();
792
793        code.add_step(String::from("V"), vec![]);
794        code.add_step(String::from("values"), vec![]);
795        code.add_step(String::from("dedup"), vec![]);
796
797        assert_eq!(&code, g.v(()).values(()).dedup(()).bytecode());
798    }
799
800    #[test]
801    fn numerical_test() {
802        let g = empty();
803
804        // sum
805        let mut code = Bytecode::new();
806
807        code.add_step(String::from("V"), vec![]);
808        code.add_step(String::from("values"), vec!["test".into()]);
809        code.add_step(String::from("sum"), vec![Scope::Global.into()]);
810
811        assert_eq!(&code, g.v(()).values("test").sum(()).bytecode());
812
813        // max
814        let mut code = Bytecode::new();
815
816        code.add_step(String::from("V"), vec![]);
817        code.add_step(String::from("values"), vec!["test".into()]);
818        code.add_step(String::from("max"), vec![Scope::Global.into()]);
819
820        assert_eq!(&code, g.v(()).values("test").max(()).bytecode());
821
822        // mean
823
824        let mut code = Bytecode::new();
825
826        code.add_step(String::from("V"), vec![]);
827        code.add_step(String::from("values"), vec!["test".into()]);
828        code.add_step(String::from("mean"), vec![Scope::Global.into()]);
829
830        assert_eq!(&code, g.v(()).values("test").mean(()).bytecode());
831
832        // min
833
834        let mut code = Bytecode::new();
835
836        code.add_step(String::from("V"), vec![]);
837        code.add_step(String::from("values"), vec!["test".into()]);
838        code.add_step(String::from("min"), vec![Scope::Global.into()]);
839
840        assert_eq!(&code, g.v(()).values("test").min(()).bytecode());
841    }
842
843    #[test]
844    fn where_test() {
845        let g = empty();
846
847        // sum
848        let mut code = Bytecode::new();
849
850        code.add_step(String::from("V"), vec![]);
851        code.add_step(String::from("values"), vec!["age".into()]);
852        code.add_step(String::from("where"), vec![P::eq(23).into()]);
853
854        assert_eq!(&code, g.v(()).values("age").where_(P::eq(23)).bytecode());
855    }
856
857    #[test]
858    fn not_test() {
859        let g = empty();
860
861        // sum
862        let mut code = Bytecode::new();
863
864        code.add_step(String::from("V"), vec![]);
865        code.add_step(
866            String::from("not"),
867            vec![__.has_label("person").bytecode().clone().into()],
868        );
869
870        assert_eq!(&code, g.v(()).not(__.has_label("person")).bytecode());
871    }
872
873    #[test]
874    fn order_test() {
875        let g = empty();
876
877        let mut code = Bytecode::new();
878
879        code.add_step(String::from("V"), vec![]);
880        code.add_step(String::from("values"), vec!["name".into()]);
881        code.add_step(String::from("order"), vec![Scope::Global.into()]);
882
883        assert_eq!(&code, g.v(()).values("name").order(()).bytecode());
884
885        let mut code = Bytecode::new();
886
887        code.add_step(String::from("V"), vec![]);
888        code.add_step(String::from("values"), vec!["name".into()]);
889        code.add_step(String::from("order"), vec![Scope::Global.into()]);
890        code.add_step(String::from("by"), vec![Order::Desc.into()]);
891
892        assert_eq!(
893            &code,
894            g.v(()).values("name").order(()).by(Order::Desc).bytecode()
895        );
896    }
897
898    #[test]
899    fn match_test() {
900        let g = empty();
901
902        let mut code = Bytecode::new();
903
904        code.add_step(String::from("V"), vec![]);
905        code.add_step(
906            String::from("match"),
907            vec![
908                __.as_("a").out(()).as_("b").bytecode().clone().into(),
909                __.as_("b").out(()).as_("c").bytecode().clone().into(),
910            ],
911        );
912        code.add_step(String::from("select"), vec!["a".into(), "c".into()]);
913
914        // with vec
915        assert_eq!(
916            &code,
917            g.v(())
918                .match_(vec![
919                    __.as_("a").out(()).as_("b"),
920                    __.as_("b").out(()).as_("c")
921                ])
922                .select(vec!["a", "c"])
923                .bytecode()
924        );
925
926        // without vec
927        assert_eq!(
928            &code,
929            g.v(())
930                .match_([__.as_("a").out(()).as_("b"), __.as_("b").out(()).as_("c")])
931                .select(["a", "c"])
932                .bytecode()
933        );
934    }
935
936    #[test]
937    fn drop_test() {
938        let g = empty();
939
940        let mut code = Bytecode::new();
941
942        code.add_step(String::from("V"), vec![]);
943        code.add_step(String::from("drop"), vec![]);
944
945        assert_eq!(&code, g.v(()).drop().bytecode());
946    }
947
948    #[test]
949    fn or_test() {
950        let g = empty();
951
952        let mut code = Bytecode::new();
953
954        code.add_step(String::from("V"), vec![]);
955        code.add_step(String::from("or"), vec![]);
956
957        assert_eq!(&code, g.v(()).or(()).bytecode());
958    }
959
960    #[test]
961    fn coalesce_test() {
962        let g = empty();
963
964        let mut code = Bytecode::new();
965
966        code.add_step(String::from("V"), vec![]);
967        code.add_step(String::from("hasLabel"), vec!["Person".into()]);
968        code.add_step(
969            String::from("coalesce"),
970            vec![
971                __.values("nickname").bytecode().clone().into(),
972                __.values("name").bytecode().clone().into(),
973            ],
974        );
975
976        assert_eq!(
977            &code,
978            g.v(())
979                .has_label("Person")
980                .coalesce::<GValue, _>([__.values("nickname"), __.values("name")])
981                .bytecode()
982        );
983    }
984
985    // g.V().hasLabel('person').coalesce(values('nickname'), values('name'))
986}
gremlin_client/process/traversal/graph_traversal_source.rs

gremlin_client/process/traversal/
graph_traversal_source.rs
