Merge pull request #137 from pontusmelke/explain-rule-planner

EXPLAIN and rule planner

cypher-shell/src/integration-test/java/org/neo4j/shell/Version.java

@@ -0,0 +1,45 @@
+package org.neo4j.shell;
+
+import static java.lang.String.format;
+
+@SuppressWarnings("WeakerAccess")
+public class Version implements Comparable<Version> {
+    private final int major;
+    private final int minor;
+    private final int patch;
+
+    Version(int major, int minor, int patch) {
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+    }
+
+    public int major() {
+        return major;
+    }
+
+    public int minor() {
+        return minor;
+    }
+
+    public int patch() {
+        return patch;
+    }
+
+    @Override
+    public int compareTo(Version o) {
+        int comp = Integer.compare(major, o.major);
+        if (comp == 0) {
+            comp = Integer.compare(minor, o.minor);
+            if (comp == 0) {
+                comp = Integer.compare(patch, o.patch);
+            }
+        }
+        return comp;
+    }
+
+    @Override
+    public String toString() {
+        return format("%d.%d.%d", major, minor, patch);
+    }
+}

cypher-shell/src/integration-test/java/org/neo4j/shell/Versions.java

@@ -0,0 +1,47 @@
+package org.neo4j.shell;
+
+import static java.lang.Integer.parseInt;
+import static java.lang.String.format;
+
+@SuppressWarnings({"WeakerAccess", "unused"})
+public final class Versions {
+
+    private Versions() {
+        throw new UnsupportedOperationException("Don't instantiate");
+    }
+
+    public static int majorVersion(String version) {
+        return version(version).major();
+    }
+
+    public static int minorVersion(String version) {
+        return version(version).minor();
+    }
+
+    public static int patch(String version) {
+        return version(version).patch();
+    }
+
+    public static Version version(String version) {
+        if (version == null) {
+            throw new AssertionError("null is not a valid version string");
+        }
+        //remove -alpha, and -beta etc
+        int offset = version.indexOf("-");
+        if (offset > 0) {
+            version = version.substring(0, offset);
+        }
+        String[] split = version.split("\\.");
+        switch (split.length) {
+            case 1:
+                return new Version(parseInt(split[0]), 0, 0);
+            case 2:
+                return new Version(parseInt(split[0]), parseInt(split[1]), 0);
+            case 3:
+                return new Version(parseInt(split[0]), parseInt(split[1]), parseInt(split[2]));
+            default:
+                throw new AssertionError(
+                        format("%s is not a proper version string, it should be of the form X.Y.Z ", version));
+        }
+    }
+}

cypher-shell/src/integration-test/java/org/neo4j/shell/commands/CypherShellVerboseIntegrationTest.java

@@ -1,6 +1,5 @@
 package org.neo4j.shell.commands;
 
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -20,10 +19,9 @@
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
+import static org.junit.Assume.assumeTrue;
+import static org.mockito.Mockito.*;
+import static org.neo4j.shell.Versions.majorVersion;
 
 public class CypherShellVerboseIntegrationTest {
     @Rule
@@ -228,4 +226,24 @@ public void cypherWithOrder() throws CommandException {
             assertThat( actual, containsString( "n.age ASC" ) );
         }
     }
+
+    @Test
+    public void cypherWithExplainAndRulePlanner() throws CommandException {
+        //given (there is no rule planner in neo4j 4.0)
+        assumeTrue( majorVersion( shell.getServerVersion() ) < 4 );
+
+        //when
+        shell.execute("CYPHER planner=rule EXPLAIN MATCH (e:E) WHERE e.bucket='Live' and e.id = 23253473 RETURN count(e)");
+
+        //then
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(logger, times(1)).printOut(captor.capture());
+
+        List<String> result = captor.getAllValues();
+        String actual = result.get(0);
+        assertThat(actual, containsString("\"EXPLAIN\""));
+        assertThat(actual, containsString("\"READ_ONLY\""));
+        assertThat(actual, containsString("\"RULE\""));
+        assertThat(actual, containsString("\"INTERPRETED\""));
+    }
 }

cypher-shell/src/main/java/org/neo4j/shell/prettyprint/TablePlanFormatter.java

@@ -1,17 +1,24 @@
 package org.neo4j.shell.prettyprint;
 
-import org.neo4j.driver.v1.Value;
-import org.neo4j.driver.v1.Values;
-import org.neo4j.driver.v1.summary.Plan;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
 import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import org.neo4j.driver.v1.Value;
+import org.neo4j.driver.v1.Values;
+import org.neo4j.driver.v1.summary.Plan;
 
 import static java.util.Arrays.asList;
 import static java.util.stream.Collectors.joining;
@@ -105,7 +112,7 @@ String formatPlan(@Nonnull Plan plan) {
     private String serialize(@Nonnull String key, @Nonnull Value v) {
         switch (key) {
             case "ColumnsLeft":
-                return "keep columns" + String.join(SEPARATOR, v.asList(Value::asString));
+                return removeGeneratedNames(v.asString());
             case "LegacyExpression":
                 return removeGeneratedNames(v.asString());
             case "Expression":