automatic fork branch ids start at 1

Author: ChrisHegarty

x-pack/plugin/esql/qa/testFixtures/src/main/resources/fork.csv-spec

@@ -13,8 +13,8 @@ from employees
 ;
 
 emp_no:integer | _fork:keyword
-10001          | fork0
-10002          | fork1
+10001          | fork1
+10002          | fork2
 ;
 
 forkWithWhereSortAndLimit
@@ -28,11 +28,11 @@ from employees
 ;
 
 emp_no:integer | first_name:keyword | _fork:keyword
-10002          | Bezalel            | fork1
-10009          | Sumant             | fork0
-10014          | Berni              | fork1
-10048          | Florian            | fork0
-10058          | Berhard            | fork1
-10060          | Breannda           | fork1
-10094          | Arumugam           | fork1
+10002          | Bezalel            | fork2
+10009          | Sumant             | fork1
+10014          | Berni              | fork2
+10048          | Florian            | fork1
+10058          | Berhard            | fork2
+10060          | Breannda           | fork2
+10094          | Arumugam           | fork2
 ;

x-pack/plugin/esql/src/internalClusterTest/java/org/elasticsearch/xpack/esql/action/ForkIT.java

@@ -44,10 +44,10 @@ public void testSimple() {
             assertColumnNames(resp.columns(), List.of("id", "_fork", "content"));
             assertColumnTypes(resp.columns(), List.of("integer", "keyword", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of(3, "fork1", "This dog is really brown"),
-                List.of(4, "fork1", "The dog is brown but this document is very very long"),
-                List.of(6, "fork0", "The quick brown fox jumps over the lazy dog"),
-                List.of(6, "fork1", "The quick brown fox jumps over the lazy dog")
+                List.of(3, "fork2", "This dog is really brown"),
+                List.of(4, "fork2", "The dog is brown but this document is very very long"),
+                List.of(6, "fork1", "The quick brown fox jumps over the lazy dog"),
+                List.of(6, "fork2", "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -67,11 +67,11 @@ public void testSortAndLimitInFirstSubQuery() {
             assertColumnNames(resp.columns(), List.of("id", "_fork", "content"));
             assertColumnTypes(resp.columns(), List.of("integer", "keyword", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of(2, "fork1", "This is a brown dog"),
-                List.of(3, "fork1", "This dog is really brown"),
-                List.of(4, "fork1", "The dog is brown but this document is very very long"),
-                List.of(6, "fork0", "The quick brown fox jumps over the lazy dog"),
-                List.of(6, "fork1", "The quick brown fox jumps over the lazy dog")
+                List.of(2, "fork2", "This is a brown dog"),
+                List.of(3, "fork2", "This dog is really brown"),
+                List.of(4, "fork2", "The dog is brown but this document is very very long"),
+                List.of(6, "fork1", "The quick brown fox jumps over the lazy dog"),
+                List.of(6, "fork2", "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -91,11 +91,11 @@ public void testSortAndLimitInFirstSubQueryASC() {
             assertColumnNames(resp.columns(), List.of("id", "_fork", "content"));
             assertColumnTypes(resp.columns(), List.of("integer", "keyword", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of(1, "fork0", "This is a brown fox"),
-                List.of(2, "fork1", "This is a brown dog"),
-                List.of(3, "fork1", "This dog is really brown"),
-                List.of(4, "fork1", "The dog is brown but this document is very very long"),
-                List.of(6, "fork1", "The quick brown fox jumps over the lazy dog")
+                List.of(1, "fork1", "This is a brown fox"),
+                List.of(2, "fork2", "This is a brown dog"),
+                List.of(3, "fork2", "This dog is really brown"),
+                List.of(4, "fork2", "The dog is brown but this document is very very long"),
+                List.of(6, "fork2", "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -115,9 +115,9 @@ public void testSortAndLimitInSecondSubQuery() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork1", 4, "The dog is brown but this document is very very long"),
-                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog")
+                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork2", 4, "The dog is brown but this document is very very long"),
+                List.of("fork2", 6, "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -137,8 +137,8 @@ public void testSortAndLimitInBothSubQueries() {
             assertColumnNames(resp.columns(), List.of("id", "_fork", "content"));
             assertColumnTypes(resp.columns(), List.of("integer", "keyword", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of(1, "fork0", "This is a brown fox"),
-                List.of(2, "fork1", "This is a brown dog")
+                List.of(1, "fork1", "This is a brown fox"),
+                List.of(2, "fork2", "This is a brown dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -157,10 +157,10 @@ public void testWhereWhere() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 1, "This is a brown fox"),
-                List.of("fork1", 3, "This dog is really brown"),
-                List.of("fork1", 4, "The dog is brown but this document is very very long"),
-                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog")
+                List.of("fork1", 1, "This is a brown fox"),
+                List.of("fork2", 3, "This dog is really brown"),
+                List.of("fork2", 4, "The dog is brown but this document is very very long"),
+                List.of("fork2", 6, "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -179,12 +179,12 @@ public void testWhereSort() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 1, "This is a brown fox"),
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork1", 2, "This is a brown dog"),
-                List.of("fork1", 3, "This dog is really brown"),
-                List.of("fork1", 4, "The dog is brown but this document is very very long"),
-                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog")
+                List.of("fork1", 1, "This is a brown fox"),
+                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork2", 2, "This is a brown dog"),
+                List.of("fork2", 3, "This dog is really brown"),
+                List.of("fork2", 4, "The dog is brown but this document is very very long"),
+                List.of("fork2", 6, "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -202,12 +202,12 @@ public void testWhereSortOnlyInFork() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 1, "This is a brown fox"),
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork1", 2, "This is a brown dog"),
-                List.of("fork1", 3, "This dog is really brown"),
-                List.of("fork1", 4, "The dog is brown but this document is very very long"),
-                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog")
+                List.of("fork1", 1, "This is a brown fox"),
+                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork2", 2, "This is a brown dog"),
+                List.of("fork2", 3, "This dog is really brown"),
+                List.of("fork2", 4, "The dog is brown but this document is very very long"),
+                List.of("fork2", 6, "The quick brown fox jumps over the lazy dog")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -226,11 +226,11 @@ public void testLimitOnlyInSecondSubQuery() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 1, "This is a brown fox"),
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
                 List.of("fork1", 1, "This is a brown fox"),
-                List.of("fork1", 2, "This is a brown dog"),
-                List.of("fork1", 3, "This dog is really brown")
+                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork2", 1, "This is a brown fox"),
+                List.of("fork2", 2, "This is a brown dog"),
+                List.of("fork2", 3, "This dog is really brown")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -286,11 +286,11 @@ public void testThreeSubQueries() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork1", 3, "This dog is really brown"),
-                List.of("fork1", 4, "The dog is brown but this document is very very long"),
                 List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork2", 5, "There is also a white cat")
+                List.of("fork2", 3, "This dog is really brown"),
+                List.of("fork2", 4, "The dog is brown but this document is very very long"),
+                List.of("fork2", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork3", 5, "There is also a white cat")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -312,11 +312,11 @@ public void testFiveSubQueries() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> expectedValues = List.of(
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork1", 2, "This is a brown dog"),
-                List.of("fork2", 5, "There is also a white cat"),
-                List.of("fork3", 1, "This is a brown fox"),
-                List.of("fork4", 3, "This dog is really brown")
+                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork2", 2, "This is a brown dog"),
+                List.of("fork3", 5, "There is also a white cat"),
+                List.of("fork4", 1, "This is a brown fox"),
+                List.of("fork5", 3, "This dog is really brown")
             );
             assertValues(resp.values(), expectedValues);
         }
@@ -338,27 +338,27 @@ public void testFourSubQueriesWithSortAndLimit() {
             assertColumnNames(resp.columns(), List.of("_fork", "id", "content"));
             assertColumnTypes(resp.columns(), List.of("keyword", "integer", "text"));
             Iterable<Iterable<Object>> fork0 = List.of(
-                List.of("fork0", 6, "The quick brown fox jumps over the lazy dog"),
-                List.of("fork0", 5, "There is also a white cat")
+                List.of("fork1", 6, "The quick brown fox jumps over the lazy dog"),
+                List.of("fork1", 5, "There is also a white cat")
             );
             Iterable<Iterable<Object>> fork1 = List.of(
-                List.of("fork1", 2, "This is a brown dog"),
-                List.of("fork1", 3, "This dog is really brown"),
-                List.of("fork1", 4, "The dog is brown but this document is very very long")
+                List.of("fork2", 2, "This is a brown dog"),
+                List.of("fork2", 3, "This dog is really brown"),
+                List.of("fork2", 4, "The dog is brown but this document is very very long")
             );
             Iterable<Iterable<Object>> fork2 = List.of(
-                List.of("fork2", 2, "This is a brown dog"),
-                List.of("fork2", 1, "This is a brown fox")
+                List.of("fork3", 2, "This is a brown dog"),
+                List.of("fork3", 1, "This is a brown fox")
             );
             Iterable<Iterable<Object>> fork3 = List.of(
-                List.of("fork3", 3, "This dog is really brown"),
-                List.of("fork3", 4, "The dog is brown but this document is very very long"),
-                List.of("fork3", 5, "There is also a white cat")
+                List.of("fork4", 3, "This dog is really brown"),
+                List.of("fork4", 4, "The dog is brown but this document is very very long"),
+                List.of("fork4", 5, "There is also a white cat")
             );
-            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork0")), fork0);
-            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork1")), fork1);
-            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork2")), fork2);
-            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork3")), fork3);
+            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork1")), fork0);
+            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork2")), fork1);
+            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork3")), fork2);
+            assertValues(valuesFilter(resp.values(), row -> row.next().equals("fork4")), fork3);
             assertThat(getValuesList(resp.values()).size(), equalTo(10));
         }
     }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/Analyzer.java

@@ -187,7 +187,7 @@ public LogicalPlan analyze(LogicalPlan plan) {
         List<LogicalPlan> analyzedPlans = new ArrayList<>();
 
         LogicalPlan forkAnalyzed = plan.transformDown(Fork.class, fr -> {
-            int count = 0;
+            int count = 1; // automatic fork branch ids start at 1
             for (var subPlan : fr.subPlans()) {
                 LogicalPlan subPlanCopy = subPlan.transformUp(
                     LogicalPlan.class,