diff --git a/src/main/antlr4/org/s1ck/gdl/GDL.g4 b/src/main/antlr4/org/s1ck/gdl/GDL.g4
index cb17c08..3745777 100644
--- a/src/main/antlr4/org/s1ck/gdl/GDL.g4
+++ b/src/main/antlr4/org/s1ck/gdl/GDL.g4
@@ -148,6 +148,7 @@ timeFunc
 interval
     : intervalSelector
     | intervalFromStamps
+    | complexInterval
     ;
 
 
@@ -161,8 +162,14 @@ intervalFromStamps
     ;
 
 // TODO: change (only placeholder yet)
-complexIntervall
-    : Identifier '.' IntervalConst
+complexInterval
+    : complexIntervalArgument '.merge(' complexIntervalArgument ')'
+    | complexIntervalArgument '.join(' complexIntervalArgument ')'
+    ;
+
+complexIntervalArgument
+    : intervalSelector
+    | intervalFromStamps
     ;
 
 // TODO: add functions that yield timePoint
diff --git a/src/main/java/org/s1ck/gdl/GDLLoader.java b/src/main/java/org/s1ck/gdl/GDLLoader.java
index 2d18bab..87eea92 100644
--- a/src/main/java/org/s1ck/gdl/GDLLoader.java
+++ b/src/main/java/org/s1ck/gdl/GDLLoader.java
@@ -433,10 +433,17 @@ public void enterIntvF(GDLParser.IntvFContext ctx){
    * @return complex predicate that encodes the interval function. Atoms are time stamp comparisons
    */
   private Predicate buildIntervalFunction(GDLParser.IntvFContext ctx) {
+    int predicateSizeBefore = currentPredicates.size();
     TimePoint[] intv = buildIntervall(ctx.interval());
     TimePoint from = intv[0];
     TimePoint to = intv[1];
-    return createIntervalPredicates(from, to, ctx.intervalFunc());
+    Predicate predicate = createIntervalPredicates(from, to, ctx.intervalFunc());
+    // additional constraints?
+    int countConstraints = currentPredicates.size() - predicateSizeBefore;
+    for(int i = 0; i<countConstraints; i++){
+      predicate = new And(predicate, currentPredicates.removeFirst());
+    }
+    return predicate;
   }
 
   /**
@@ -449,22 +456,24 @@ private Predicate buildIntervalFunction(GDLParser.IntvFContext ctx) {
    *    {@code from} and {@code to}.
    */
   private Predicate createIntervalPredicates(TimePoint from, TimePoint to, GDLParser.IntervalFuncContext intervalFunc) {
+    Predicate predicate = null;
     if(intervalFunc.overlapsIntervallOperator()!=null){
-      return createOverlapsPredicates(from, to, intervalFunc.overlapsIntervallOperator());
+      predicate = createOverlapsPredicates(from, to, intervalFunc.overlapsIntervallOperator());
     }
     else if(intervalFunc.fromToOperator()!=null){
-      return createFromToPredicates(from, to, intervalFunc.fromToOperator());
+      predicate = createFromToPredicates(from, to, intervalFunc.fromToOperator());
     }
     else if(intervalFunc.betweenOperator()!=null){
-      return createBetweenPredicates(from, to, intervalFunc.betweenOperator());
+      predicate = createBetweenPredicates(from, to, intervalFunc.betweenOperator());
     }
     else if(intervalFunc.precedesOperator()!=null){
-      return createPrecedesPredicates(to, intervalFunc.precedesOperator());
+      predicate = createPrecedesPredicates(to, intervalFunc.precedesOperator());
     }
     else if(intervalFunc.succeedsOperator()!=null){
-      return createSucceedsPredicates(from, intervalFunc.succeedsOperator());
+      predicate = createSucceedsPredicates(from, intervalFunc.succeedsOperator());
     }
-    return null;
+    // additional constraints added during interval processing?
+    return predicate;
   }
 
   /**
@@ -553,22 +562,74 @@ private TimePoint[] buildIntervall(GDLParser.IntervalContext ctx) {
     if (ctx.intervalSelector()!=null){
       GDLParser.IntervalSelectorContext selector = ctx.intervalSelector();
       // throws exception, if variable invalid
-      String var = selector.Identifier()!=null ?
-              resolveIdentifier(selector.Identifier().getText()) : TimeSelector.GLOBAL_SELECTOR;
-      String intId = selector.IntervalConst().getText();
-      TimePoint from = new TimeSelector(var, intId+"_from");
-      TimePoint to = new TimeSelector(var, intId+"_to");
-      return new TimePoint[]{from, to};
+      return buildIntervalFromSelector(selector);
     }
     else if(ctx.intervalFromStamps()!=null){
       GDLParser.IntervalFromStampsContext fs = ctx.intervalFromStamps();
-      TimePoint from = buildTimePoint(fs.timePoint(0));
-      TimePoint to = buildTimePoint(fs.timePoint(1));
-      return new TimePoint[]{from,to};
+      return buildIntervalFromStamps(fs);
+    }
+    else if(ctx.complexInterval()!=null){
+      GDLParser.ComplexIntervalArgumentContext arg1 = ctx.complexInterval()
+              .complexIntervalArgument(0);
+      GDLParser.ComplexIntervalArgumentContext arg2 = ctx.complexInterval()
+              .complexIntervalArgument(1);
+      boolean join = ctx.getText().contains(".join(");
+      return buildIntervalFromComplex(arg1, arg2, join);
     }
     return null;
   }
 
+  private TimePoint[] buildIntervalFromSelector(GDLParser.IntervalSelectorContext ctx){
+    String var = ctx.Identifier()!=null ?
+            resolveIdentifier(ctx.Identifier().getText()) : TimeSelector.GLOBAL_SELECTOR;
+    String intId = ctx.IntervalConst().getText();
+    TimePoint from = new TimeSelector(var, intId+"_from");
+    TimePoint to = new TimeSelector(var, intId+"_to");
+    return new TimePoint[]{from, to};
+  }
+
+  private TimePoint[] buildIntervalFromStamps(GDLParser.IntervalFromStampsContext ctx){
+    TimePoint from = buildTimePoint(ctx.timePoint(0));
+    TimePoint to = buildTimePoint(ctx.timePoint(1));
+    return new TimePoint[]{from,to};
+  }
+
+  private TimePoint[] buildIntervalFromComplex(GDLParser.ComplexIntervalArgumentContext arg1,
+                                               GDLParser.ComplexIntervalArgumentContext arg2,
+                                               boolean join){
+    TimePoint[] i1 = null;
+    TimePoint[] i2 = null;
+    if(arg1.intervalFromStamps()!=null){
+      i1 = buildIntervalFromStamps(arg1.intervalFromStamps());
+    }
+    else{
+      i1 = buildIntervalFromSelector(arg1.intervalSelector());
+    }
+    if(arg2.intervalFromStamps()!=null){
+      i2 = buildIntervalFromStamps(arg2.intervalFromStamps());
+    }
+    else{
+      i2 = buildIntervalFromSelector(arg2.intervalSelector());
+    }
+    // constraint: merge and join only when overlapping or meeting
+    Comparison constraint = new Comparison(
+            new MaxTimePoint(i1[0], i2[0]), LTE, new MinTimePoint(i1[1], i2[1])
+    );
+    currentPredicates.addFirst(constraint);
+    // now build complex intervall from i1, i2
+    if(join){
+      TimePoint start = new MinTimePoint(i1[0],i2[0]);
+      TimePoint end = new MaxTimePoint(i1[1],i2[1]);
+      return new TimePoint[]{start, end};
+    }
+    // merge
+    else{
+      TimePoint start = new MaxTimePoint(i1[0],i2[0]);
+      TimePoint end = new MinTimePoint(i1[1],i2[1]);
+      return new TimePoint[]{start, end};
+    }
+  }
+
   /**
    * Builds a {@code Predicate} from the given TimeStamp-Function (caller is a timestamp)
    * time stamp functions are e.g. succeeds(x), before(x),...
diff --git a/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java b/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java
index cb22113..73eb51e 100644
--- a/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java
+++ b/src/test/java/org/s1ck/gdl/GDLLoaderTemporalTest.java
@@ -17,6 +17,10 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
+import static org.s1ck.gdl.model.comparables.time.TimeSelector.TimeField.TX_FROM;
+import static org.s1ck.gdl.model.comparables.time.TimeSelector.TimeField.TX_TO;
+import static org.s1ck.gdl.utils.Comparator.GTE;
+import static org.s1ck.gdl.utils.Comparator.LTE;
 
 public class GDLLoaderTemporalTest {
 
@@ -117,14 +121,14 @@ public void betweenTest(){
         Predicate result = loader.getPredicates().get();
         Predicate expected = new And(
                 new Comparison(
-                        new TimeSelector("a", TimeSelector.TimeField.TX_FROM),
-                        Comparator.LTE,
+                        new TimeSelector("a", TX_FROM),
+                        LTE,
                         new TimeLiteral("2020-04-28T10:39:15")
                 ),
                 new Comparison(
-                        new TimeSelector("a", TimeSelector.TimeField.TX_TO),
+                        new TimeSelector("a", TX_TO),
                         Comparator.GT,
-                        new TimeSelector("b", TimeSelector.TimeField.TX_FROM)
+                        new TimeSelector("b", TX_FROM)
                 )
         );
         assertPredicateEquals(result, expected);
@@ -136,8 +140,8 @@ public void precedesTest(){
                 "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("a", TX_TO),
+                LTE,
                 new TimeSelector("b", TimeSelector.TimeField.VAL_FROM)
         );
         assertPredicateEquals(result, expected);
@@ -147,8 +151,8 @@ public void precedesTest(){
                 "WHERE a.tx_to.precedes(b.val)");
         result = loader.getPredicates().get();
         expected = new Comparison(
-                new TimeSelector("a", TimeSelector.TimeField.TX_TO),
-                Comparator.LTE,
+                new TimeSelector("a", TX_TO),
+                LTE,
                 new TimeSelector("b", TimeSelector.TimeField.VAL_FROM)
         );
         assertPredicateEquals(result, expected);
@@ -161,8 +165,8 @@ public void succeedsTest(){
         Predicate result = loader.getPredicates().get();
         Predicate expected = new Comparison(
                 new TimeSelector("a", TimeSelector.TimeField.VAL_FROM),
-                Comparator.GTE,
-                new TimeSelector("b", TimeSelector.TimeField.TX_TO)
+                GTE,
+                new TimeSelector("b", TX_TO)
         );
         assertPredicateEquals(result, expected);
 
@@ -171,8 +175,8 @@ public void succeedsTest(){
                 "WHERE a.tx_to.succeeds(b.val)");
         result = loader.getPredicates().get();
         expected = new Comparison(
-                new TimeSelector("a", TimeSelector.TimeField.TX_TO),
-                Comparator.GTE,
+                new TimeSelector("a", TX_TO),
+                GTE,
                 new TimeSelector("b", TimeSelector.TimeField.VAL_TO)
         );
         assertPredicateEquals(result, expected);
@@ -185,13 +189,13 @@ public void asOfTest(){
         Predicate result = loader.getPredicates().get();
         Predicate expected = new And(
                 new Comparison(
-                        new TimeSelector("e", TimeSelector.TimeField.TX_FROM),
-                        Comparator.LTE,
+                        new TimeSelector("e", TX_FROM),
+                        LTE,
                         new TimeLiteral("1970-01-01")
                 ),
                 new Comparison(
-                        new TimeSelector("e", TimeSelector.TimeField.TX_TO),
-                        Comparator.GTE,
+                        new TimeSelector("e", TX_TO),
+                        GTE,
                         new TimeLiteral("1970-01-01")
                 )
         );
@@ -203,12 +207,12 @@ public void globalPredicateTest(){
         TimeLiteral l1 = new TimeLiteral("1970-01-01");
         TimeLiteral l2 = new TimeLiteral("2020-05-01");
 
-        TimeSelector aFrom = new TimeSelector("a", TimeSelector.TimeField.TX_FROM);
-        TimeSelector aTo = new TimeSelector("a", TimeSelector.TimeField.TX_TO);
-        TimeSelector bFrom = new TimeSelector("b", TimeSelector.TimeField.TX_FROM);
-        TimeSelector bTo = new TimeSelector("b", TimeSelector.TimeField.TX_TO);
-        TimeSelector eFrom = new TimeSelector("e", TimeSelector.TimeField.TX_FROM);
-        TimeSelector eTo = new TimeSelector("e", TimeSelector.TimeField.TX_TO);
+        TimeSelector aFrom = new TimeSelector("a", TX_FROM);
+        TimeSelector aTo = new TimeSelector("a", TX_TO);
+        TimeSelector bFrom = new TimeSelector("b", TX_FROM);
+        TimeSelector bTo = new TimeSelector("b", TX_TO);
+        TimeSelector eFrom = new TimeSelector("e", TX_FROM);
+        TimeSelector eTo = new TimeSelector("e", TX_TO);
         // only lhs global
         GDLLoader loader = getLoaderFromGDLString("MATCH (a)-[e]->(b) " +
                 "WHERE tx.between(1970-01-01, 2020-05-01)");
@@ -217,10 +221,10 @@ public void globalPredicateTest(){
                 // all froms <= l2
                 new And(
                         new And(
-                                new Comparison(eFrom, Comparator.LTE, l2),
-                                new Comparison(aFrom, Comparator.LTE, l2)
+                                new Comparison(eFrom, LTE, l2),
+                                new Comparison(aFrom, LTE, l2)
                         ),
-                        new Comparison(bFrom, Comparator.LTE, l2)
+                        new Comparison(bFrom, LTE, l2)
                 ),
                 new And(
                         new And(
@@ -238,10 +242,10 @@ public void globalPredicateTest(){
         Predicate result2 = loader.getPredicates().get();
         Or expected2 = new Or(
                 new Or(
-                        new Comparison(l1, Comparator.LTE, eFrom),
-                        new Comparison(l1, Comparator.LTE, aFrom)
+                        new Comparison(l1, LTE, eFrom),
+                        new Comparison(l1, LTE, aFrom)
                 ),
-                new Comparison(l1, Comparator.LTE, bFrom)
+                new Comparison(l1, LTE, bFrom)
         );
         assertPredicateEquals(expected2, result2);
 
@@ -281,6 +285,150 @@ public void globalPredicateTest(){
         assertPredicateEquals(expected3, result3);
     }
 
+    @Test
+    public void intervallMergeAndJoinTest(){
+        GDLLoader loader = getLoaderFromGDLString("MATCH (a)-[e]->(b) " +
+                "WHERE a.tx.merge(b.tx).succeeds(Interval(1970-01-01, 2020-05-01))");
+        TimeSelector aTxFrom = new TimeSelector("a", TX_FROM);
+        TimeSelector aTxTo = new TimeSelector("a", TX_TO);
+        TimeSelector bTxFrom = new TimeSelector("b", TX_FROM);
+        TimeSelector bTxTo = new TimeSelector("b",TX_TO);
+        TimeLiteral tl1 = new TimeLiteral("1970-01-01");
+        TimeLiteral tl2 = new TimeLiteral("2020-05-01");
+        Predicate expected = new And(
+                //succeeds
+                new Or(
+                    new Comparison(aTxFrom, GTE, tl2),
+                    new Comparison(bTxFrom, GTE, tl2)
+                ),
+                //overlaps/meets
+                new And(
+                        new And(
+                                new Comparison(aTxFrom, LTE, aTxTo),
+                                new Comparison(aTxFrom, LTE, bTxTo)
+                        ),
+                        new And(
+                                new Comparison(bTxFrom, LTE, aTxTo),
+                                new Comparison(bTxFrom, LTE, bTxTo)
+                        )
+                )
+        );
+        Predicate result = loader.getPredicates().get();
+        assertPredicateEquals(expected, result);
+
+        /*
+         * Join
+         */
+        loader = getLoaderFromGDLString("MATCH (a)-[e]->(b) " +
+                "WHERE a.tx.join(b.tx).succeeds(Interval(1970-01-01, 2020-05-01))");
+        expected = new And(
+                //succeeds
+                new And(
+                        new Comparison(aTxFrom, GTE, tl2),
+                        new Comparison(bTxFrom, GTE, tl2)
+                ),
+                //overlaps/meets
+                new And(
+                        new And(
+                                new Comparison(aTxFrom, LTE, aTxTo),
+                                new Comparison(aTxFrom, LTE, bTxTo)
+                        ),
+                        new And(
+                                new Comparison(bTxFrom, LTE, aTxTo),
+                                new Comparison(bTxFrom, LTE, bTxTo)
+                        )
+                )
+        );
+        result = loader.getPredicates().get();
+        assertPredicateEquals(expected, result);
+        /*
+         * Combine Merge And Join
+         */
+        loader = getLoaderFromGDLString("MATCH (a)-[e]->(b) " +
+                "WHERE a.tx.join(b.tx).precedes(a.tx.merge(b.tx))");
+        expected = new And(
+                new And(
+                        // actual precedes predicate
+                        new And(
+                                new Or(
+                                      new Comparison(aTxTo, LTE, aTxFrom),
+                                      new Comparison(aTxTo, LTE, bTxFrom)
+                                ),
+                                new Or(
+                                        new Comparison(bTxTo, LTE, aTxFrom),
+                                        new Comparison(bTxTo, LTE, bTxFrom)
+                                )
+                        ),
+                        //first overlap/meet
+                        new And(
+                                new And(
+                                        new Comparison(aTxFrom, LTE, aTxTo),
+                                        new Comparison(aTxFrom, LTE, bTxTo)
+                                ),
+                                new And(
+                                        new Comparison(bTxFrom, LTE, aTxTo),
+                                        new Comparison(bTxFrom, LTE, bTxTo)
+                                )
+                        )
+                ),
+                //second overlap/meet
+                new And(
+                        new And(
+                                new Comparison(aTxFrom, LTE, aTxTo),
+                                new Comparison(aTxFrom, LTE, bTxTo)
+                        ),
+                        new And(
+                                new Comparison(bTxFrom, LTE, aTxTo),
+                                new Comparison(bTxFrom, LTE, bTxTo)
+                        )
+                )
+        );
+        result = loader.getPredicates().get();
+        assertPredicateEquals(expected, result);
+        loader = getLoaderFromGDLString("MATCH (a)-[e]->(b) " +
+                "WHERE a.tx.merge(b.tx).precedes(a.tx.join(b.tx))");
+        expected = new And(
+                new And(
+                        // actual preceeds predicate
+                        new Or(
+                                new And(
+                                        new Comparison(aTxTo, LTE, aTxFrom),
+                                        new Comparison(aTxTo, LTE, bTxFrom)
+                                ),
+                                new And(
+                                        new Comparison(bTxTo, LTE, aTxFrom),
+                                        new Comparison(bTxTo, LTE, bTxFrom)
+                                )
+                        ),
+                        //first overlap/meet
+                        new And(
+                                new And(
+                                        new Comparison(aTxFrom, LTE, aTxTo),
+                                        new Comparison(aTxFrom, LTE, bTxTo)
+                                ),
+                                new And(
+                                        new Comparison(bTxFrom, LTE, aTxTo),
+                                        new Comparison(bTxFrom, LTE, bTxTo)
+                                )
+                        )
+                ),
+                //second overlap/meet
+                new And(
+                        new And(
+                                new Comparison(aTxFrom, LTE, aTxTo),
+                                new Comparison(aTxFrom, LTE, bTxTo)
+                        ),
+                        new And(
+                                new Comparison(bTxFrom, LTE, aTxTo),
+                                new Comparison(bTxFrom, LTE, bTxTo)
+                        )
+                )
+        );
+        result = loader.getPredicates().get();
+        assertPredicateEquals(result, expected);
+        System.out.println(loader.getPredicates());
+    }
+
 
     @Test
     public void graphTimeStampTest(){