[s1ck#49] implemented between and precedes

src/main/antlr4/org/s1ck/gdl/GDL.g4

@@ -183,6 +183,8 @@ intervalFunc
             : overlapsIntervallOperator
             | asOfOperator
             | fromToOperator
+            | betweenOperator
+            | precedesOperator
             ;
 overlapsIntervallOperator
     : 'overlaps(' interval ')'
@@ -196,10 +198,19 @@ fromToOperator
     : 'fromTo(' timePoint ',' timePoint ')'
     ;
 
+betweenOperator
+    : 'between(' timePoint ',' timePoint ')'
+    ;
+
+precedesOperator
+    : 'precedes(' interval ')'
+    ;
+
 stampFunc
     : beforePointOperator
     | afterPointOperator
     | asOfOperator
+    | precedesOperator
     ;
 
 beforePointOperator

src/main/java/org/s1ck/gdl/GDLLoader.java

@@ -437,6 +437,12 @@ else if(intervalFunc.asOfOperator()!=null){
     else if(intervalFunc.fromToOperator()!=null){
       return createFromToPredicates(from, to, intervalFunc.fromToOperator());
     }
+    else if(intervalFunc.betweenOperator()!=null){
+      return createBetweenPredicates(from, to, intervalFunc.betweenOperator());
+    }
+    else if(intervalFunc.precedesOperator()!=null){
+      return createPrecedesPredicates(to, intervalFunc.precedesOperator());
+    }
     return null;
   }
 
@@ -477,6 +483,36 @@ private Predicate createFromToPredicates(TimePoint from, TimePoint to, GDLParser
     );
   }
 
+  /**
+   * Creates a predicate a.between(x,y) = a.from<=y AND a.to>x
+   * @param from from value of the calling interval
+   * @param to to value of the calling interval
+   * @param ctx context of the call, containing x and y
+   * @return between predicate
+   */
+  private Predicate createBetweenPredicates(TimePoint from, TimePoint to, GDLParser.BetweenOperatorContext ctx){
+    TimePoint x = buildTimePoint(ctx.timePoint(0));
+    TimePoint y = buildTimePoint(ctx.timePoint(1));
+    return new And(
+            new Comparison(from, Comparator.LTE, y),
+            new Comparison(to, Comparator.GT, x)
+    );
+  }
+
+  /**
+   * Creates a predicate a.precedes(b) = a <= b.
+   * Function is used for interval and timestamp function {@code precedes}, as they both
+   * only compare two time stamps
+   * @param point the time stamp of the caller to compare
+   * @param ctx the context containing the value to be compared
+   * @return precedes predicate
+   */
+  private Predicate createPrecedesPredicates(TimePoint point, GDLParser.PrecedesOperatorContext ctx){
+    TimePoint[] arg = buildIntervall(ctx.interval());
+    TimePoint arg_from = arg[0];
+    return new Comparison(point, Comparator.LTE, arg_from);
+  }
+
   /**
    * Creates an array {@code {from, to}} representing an intervall.
    * @param ctx context from which to derive {@code from} and {@code to}
@@ -541,6 +577,9 @@ else if(stampFunc.beforePointOperator()!=null) {
     else if(stampFunc.afterPointOperator()!=null){
       return createAfterPredicates(tp, stampFunc.afterPointOperator());
     }
+    else if(stampFunc.precedesOperator()!=null){
+      return createPrecedesPredicates(tp, stampFunc.precedesOperator());
+    }
     return null;
   }
 

src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java

@@ -104,6 +104,39 @@ public void fromToTest(){
         assertEquals(result.toString(), expected.toString());
     }
 
+    @Test
+    public void betweenTest(){
+        GDLLoader loader = getLoaderFromGDLString("MATCH (a)-->(b) " +
+                "WHERE a.tx.between(b.tx_from, 2020-04-28T10:39:15)");
+        Predicate result = loader.getPredicates().get();
+        Predicate expected = new And(
+                new Comparison(
+                        new TimeSelector("a", TimeSelector.TimeField.TX_FROM),
+                        Comparator.LTE,
+                        new TimeLiteral("2020-04-28T10:39:15")
+                ),
+                new Comparison(
+                        new TimeSelector("a", TimeSelector.TimeField.TX_TO),
+                        Comparator.GT,
+                        new TimeSelector("b", TimeSelector.TimeField.TX_FROM)
+                )
+        ).switchSides();
+        assertEquals(result.toString(), expected.toString());
+    }
+
+    @Test
+    public void precedesTest(){
+        GDLLoader loader = getLoaderFromGDLString("MATCH (a)-->(b) " +
+                "WHERE a.tx.precedes(b.val)");
+        Predicate result = loader.getPredicates().get();
+        Predicate expected = new Comparison(
+                new TimeSelector("a", TimeSelector.TimeField.TX_TO),
+                Comparator.LTE,
+                new TimeSelector("b", TimeSelector.TimeField.VAL_FROM)
+        ).switchSides();
+        assertEquals(result.toString(), expected.toString());
+    }
+
     @Test
     public void graphTimeStampTest(){