diff --git a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/BaseToObjectValueWriter.java b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/BaseToObjectValueWriter.java
index f3c3d5e998361..0859bc8df8c1c 100644
--- a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/BaseToObjectValueWriter.java
+++ b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/BaseToObjectValueWriter.java
@@ -94,7 +94,16 @@ public void writeNodeReference( long nodeId ) throws RuntimeException
     @Override
     public void writeNode( long nodeId, TextArray ignore, MapValue properties ) throws RuntimeException
     {
-        writeValue( newNodeProxyById( nodeId ) );
+        if ( nodeId >= 0 )
+        {
+            writeValue( newNodeProxyById( nodeId ) );
+        }
+    }
+
+    @Override
+    public void writeVirtualNodeHack( Object node )
+    {
+        writeValue( node );
     }
 
     @Override
@@ -107,7 +116,16 @@ public void writeEdgeReference( long edgeId ) throws RuntimeException
     public void writeEdge( long edgeId, long startNodeId, long endNodeId, TextValue type, MapValue properties )
             throws RuntimeException
     {
-        writeValue( newRelationshipProxyById( edgeId ) );
+        if ( edgeId >= 0 )
+        {
+            writeValue( newRelationshipProxyById( edgeId ) );
+        }
+    }
+
+    @Override
+    public void writeVirtualEdgeHack( Object relationship )
+    {
+        writeValue( relationship );
     }
 
     @Override
diff --git a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/NodeProxyWrappingNodeValue.java b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/NodeProxyWrappingNodeValue.java
index 59bb07fe00c51..93435480ed8a3 100644
--- a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/NodeProxyWrappingNodeValue.java
+++ b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/NodeProxyWrappingNodeValue.java
@@ -64,6 +64,12 @@ public <E extends Exception> void writeTo( AnyValueWriter<E> writer ) throws E
             p = VirtualValues.EMPTY_MAP;
 
         }
+
+        if ( id() < 0 )
+        {
+            writer.writeVirtualNodeHack( node );
+        }
+
         writer.writeNode( node.getId(), l, p );
     }
 
diff --git a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/RelationshipProxyWrappingEdgeValue.java b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/RelationshipProxyWrappingEdgeValue.java
index 1ba19a62b72c4..c7aea4341981e 100644
--- a/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/RelationshipProxyWrappingEdgeValue.java
+++ b/community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/javacompat/RelationshipProxyWrappingEdgeValue.java
@@ -61,6 +61,12 @@ public <E extends Exception> void writeTo( AnyValueWriter<E> writer ) throws E
             p = VirtualValues.EMPTY_MAP;
 
         }
+
+        if ( id() < 0 )
+        {
+            writer.writeVirtualEdgeHack( relationship );
+        }
+
         writer.writeEdge( id(), startNode().id(), endNode().id(), type(), p );
     }
 
diff --git a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/helpers/RuntimeTextValueConverter.scala b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/helpers/RuntimeTextValueConverter.scala
index 4a8331b81a257..7e19363a58de5 100644
--- a/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/helpers/RuntimeTextValueConverter.scala
+++ b/community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/helpers/RuntimeTextValueConverter.scala
@@ -21,7 +21,7 @@ package org.neo4j.cypher.internal.compatibility.v3_3.runtime.helpers
 
 import org.neo4j.cypher.internal.compatibility.v3_3.runtime.commands.values.KeyToken
 import org.neo4j.cypher.internal.spi.v3_3.QueryContext
-import org.neo4j.graphdb.{Node, Path, Relationship}
+import org.neo4j.graphdb.{Entity, Node, Path, Relationship}
 
 import scala.collection.Map
 
@@ -34,7 +34,7 @@ class RuntimeTextValueConverter(scalaValues: RuntimeScalaValueConverter)(implici
   def asTextValue(a: Any): String = {
     val scalaValue = scalaValues.asShallowScalaValue(a)
     scalaValue match {
-      case node: Node => s"$node${props(node)}"
+      case node: Node => s"Node[${node.getId}]${props(node)}"
       case relationship: Relationship => s":${relationship.getType.name()}[${relationship.getId}]${props(relationship)}"
       case path: Path => path.toString
       case map: Map[_, _] => makeString(map)
@@ -52,15 +52,17 @@ class RuntimeTextValueConverter(scalaValues: RuntimeScalaValueConverter)(implici
 
   private def props(n: Node): String = {
     val ops = context.nodeOps
-    val properties = ops.propertyKeyIds(n.getId)
+    val properties = if (isVirtualEntityHack(n)) Iterator.empty else ops.propertyKeyIds(n.getId)
     val keyValStrings = properties.map(pkId => s"${context.getPropertyKeyName(pkId)}:${asTextValue(ops.getProperty(n.getId, pkId).asObject())}")
     keyValStrings.mkString("{", ",", "}")
   }
 
   private def props(r: Relationship): String = {
     val ops = context.relationshipOps
-    val properties = ops.propertyKeyIds(r.getId)
+    val properties = if (isVirtualEntityHack(r)) Iterator.empty else ops.propertyKeyIds(r.getId)
     val keyValStrings = properties.map(pkId => s"${context.getPropertyKeyName(pkId)}:${asTextValue(ops.getProperty(r.getId, pkId).asObject())}")
     keyValStrings.mkString("{", ",", "}")
   }
+
+  private def isVirtualEntityHack(entity:Entity): Boolean = entity.getId < 0
 }
diff --git a/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/SchemaProcedure.java b/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/SchemaProcedure.java
index 980a2265285ea..0bb0126422ada 100644
--- a/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/SchemaProcedure.java
+++ b/community/kernel/src/main/java/org/neo4j/kernel/builtinprocs/SchemaProcedure.java
@@ -21,6 +21,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@@ -63,8 +64,8 @@ public SchemaProcedure( final GraphDatabaseAPI graphDatabaseAPI, final KernelTra
 
     public GraphResult buildSchemaGraph()
     {
-        final Map<String,NodeImpl> nodes = new HashMap<>();
-        final Map<String,Set<RelationshipImpl>> relationships = new HashMap<>();
+        final Map<String,VirtualNodeHack> nodes = new HashMap<>();
+        final Map<String,Set<VirtualRelationshipHack>> relationships = new HashMap<>();
 
         try ( Statement statement = kernelTransaction.acquireStatement() )
         {
@@ -122,15 +123,15 @@ public GraphResult buildSchemaGraph()
                         int relId = readOperations.relationshipTypeGetForName( relationshipTypeGetName );
                         try ( ResourceIterator<Label> labelsInUse = graphDatabaseAPI.getAllLabelsInUse().iterator() )
                         {
-                            List<NodeImpl> startNodes = new LinkedList<>();
-                            List<NodeImpl> endNodes = new LinkedList<>();
+                            List<VirtualNodeHack> startNodes = new LinkedList<>();
+                            List<VirtualNodeHack> endNodes = new LinkedList<>();
 
                             while ( labelsInUse.hasNext() )
                             {
                                 Label labelToken = labelsInUse.next();
                                 String labelName = labelToken.name();
                                 Map<String,Object> properties = new HashMap<>();
-                                NodeImpl node = getOrCreateLabel( labelName, properties, nodes );
+                                VirtualNodeHack node = getOrCreateLabel( labelName, properties, nodes );
                                 int labelId = readOperations.labelGetForName( labelName );
 
                                 if ( readOperations.countsForRelationship( labelId, relId, ReadOperations.ANY_LABEL ) > 0 )
@@ -143,11 +144,11 @@ public GraphResult buildSchemaGraph()
                                 }
                             }
 
-                            for ( NodeImpl startNode : startNodes )
+                            for ( VirtualNodeHack startNode : startNodes )
                             {
-                                for ( NodeImpl endNode : endNodes )
+                                for ( VirtualNodeHack endNode : endNodes )
                                 {
-                                    RelationshipImpl relationship =
+                                    VirtualRelationshipHack relationship =
                                             addRelationship( startNode, endNode, relationshipTypeGetName, relationships );
                                 }
                             }
@@ -172,22 +173,22 @@ public GraphResult( List<Node> nodes, List<Relationship> relationships )
         }
     }
 
-    private NodeImpl getOrCreateLabel( String label, Map<String,Object> properties,
-            final Map<String,NodeImpl> nodeMap )
+    private VirtualNodeHack getOrCreateLabel( String label, Map<String,Object> properties,
+            final Map<String,VirtualNodeHack> nodeMap )
     {
         if ( nodeMap.containsKey( label ) )
         {
             return nodeMap.get( label );
         }
-        NodeImpl node = new NodeImpl( label, properties );
+        VirtualNodeHack node = new VirtualNodeHack( label, properties );
         nodeMap.put( label, node );
         return node;
     }
 
-    private RelationshipImpl addRelationship( NodeImpl startNode, NodeImpl endNode, String relType,
-            final Map<String,Set<RelationshipImpl>> relationshipMap )
+    private VirtualRelationshipHack addRelationship( VirtualNodeHack startNode, VirtualNodeHack endNode, String relType,
+            final Map<String,Set<VirtualRelationshipHack>> relationshipMap )
     {
-        Set<RelationshipImpl> relationshipsForType;
+        Set<VirtualRelationshipHack> relationshipsForType;
         if ( !relationshipMap.containsKey( relType ) )
         {
             relationshipsForType = new HashSet<>();
@@ -197,7 +198,7 @@ private RelationshipImpl addRelationship( NodeImpl startNode, NodeImpl endNode,
         {
             relationshipsForType = relationshipMap.get( relType );
         }
-        RelationshipImpl relationship = new RelationshipImpl( startNode, endNode, relType );
+        VirtualRelationshipHack relationship = new VirtualRelationshipHack( startNode, endNode, relType );
         if ( !relationshipsForType.contains( relationship ) )
         {
             relationshipsForType.add( relationship );
@@ -205,11 +206,11 @@ private RelationshipImpl addRelationship( NodeImpl startNode, NodeImpl endNode,
         return relationship;
     }
 
-    private GraphResult getGraphResult( final Map<String,NodeImpl> nodeMap,
-            final Map<String,Set<RelationshipImpl>> relationshipMap )
+    private GraphResult getGraphResult( final Map<String,VirtualNodeHack> nodeMap,
+            final Map<String,Set<VirtualRelationshipHack>> relationshipMap )
     {
         List<Relationship> relationships = new LinkedList<>();
-        for ( Set<RelationshipImpl> relationship : relationshipMap.values() )
+        for ( Set<VirtualRelationshipHack> relationship : relationshipMap.values() )
         {
             relationships.addAll( relationship );
         }
@@ -220,7 +221,7 @@ private GraphResult getGraphResult( final Map<String,NodeImpl> nodeMap,
         return graphResult;
     }
 
-    private static class RelationshipImpl implements Relationship
+    private static class VirtualRelationshipHack implements Relationship
     {
 
         private static AtomicLong MIN_ID = new AtomicLong( -1 );
@@ -230,7 +231,7 @@ private static class RelationshipImpl implements Relationship
         private final Node endNode;
         private final RelationshipType relationshipType;
 
-        RelationshipImpl( final NodeImpl startNode, final NodeImpl endNode, final String type )
+        VirtualRelationshipHack( final VirtualNodeHack startNode, final VirtualNodeHack endNode, final String type )
         {
             this.id = MIN_ID.getAndDecrement();
             this.startNode = startNode;
@@ -265,7 +266,7 @@ public RelationshipType getType()
         @Override
         public Map<String,Object> getAllProperties()
         {
-            return new HashMap<String,Object>();
+            return new HashMap<>();
         }
 
         @Override
@@ -339,18 +340,24 @@ public Map<String,Object> getProperties( String... keys )
         {
             return null;
         }
+
+        @Override
+        public String toString()
+        {
+            return String.format( "VirtualRelationshipHack[%s]", id );
+        }
     }
 
-    private static class NodeImpl implements Node
+    private static class VirtualNodeHack implements Node
     {
 
-        private final HashMap<String,Object> propertyMap = new HashMap<String,Object>();
+        private final HashMap<String,Object> propertyMap = new HashMap<>();
 
         private static AtomicLong MIN_ID = new AtomicLong( -1 );
         private final long id;
         private final Label label;
 
-        NodeImpl( final String label, Map<String,Object> properties )
+        VirtualNodeHack( final String label, Map<String,Object> properties )
         {
             this.id = MIN_ID.getAndDecrement();
             this.label = Label.label( label );
@@ -373,7 +380,7 @@ public Map<String,Object> getAllProperties()
         @Override
         public Iterable<Label> getLabels()
         {
-            return Arrays.asList( label );
+            return Collections.singletonList( label );
         }
 
         @Override
@@ -549,5 +556,11 @@ public Map<String,Object> getProperties( String... keys )
         {
             return null;
         }
+
+        @Override
+        public String toString()
+        {
+            return String.format( "VirtualNodeHack[%s]", id );
+        }
     }
 }
diff --git a/community/values/src/main/java/org/neo4j/values/AnyValueWriter.java b/community/values/src/main/java/org/neo4j/values/AnyValueWriter.java
index ffe6c08cc3519..9b9479cb5464e 100644
--- a/community/values/src/main/java/org/neo4j/values/AnyValueWriter.java
+++ b/community/values/src/main/java/org/neo4j/values/AnyValueWriter.java
@@ -32,7 +32,6 @@
  */
 public interface AnyValueWriter<E extends Exception> extends ValueWriter<E>
 {
-
     void writeNodeReference( long nodeId ) throws E;
 
     void writeNode( long nodeId, TextArray labels, MapValue properties ) throws E;
@@ -54,4 +53,14 @@ public interface AnyValueWriter<E extends Exception> extends ValueWriter<E>
     void beginPoint( CoordinateReferenceSystem coordinateReferenceSystem ) throws E;
 
     void endPoint() throws E;
+
+    default void writeVirtualNodeHack( Object node )
+    {
+        // do nothing, this is an ugly hack.
+    }
+
+    default void writeVirtualEdgeHack( Object relationship )
+    {
+        // do nothing, this is an ugly hack.
+    }
 }
diff --git a/enterprise/cypher/acceptance-spec-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/BuiltInProcedureAcceptanceTest.scala b/enterprise/cypher/acceptance-spec-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/BuiltInProcedureAcceptanceTest.scala
index 770619eaf1489..570c26e1c3656 100644
--- a/enterprise/cypher/acceptance-spec-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/BuiltInProcedureAcceptanceTest.scala
+++ b/enterprise/cypher/acceptance-spec-suite/src/test/scala/org/neo4j/internal/cypher/acceptance/BuiltInProcedureAcceptanceTest.scala
@@ -20,6 +20,9 @@
 package org.neo4j.internal.cypher.acceptance
 
 import org.neo4j.cypher.SyntaxException
+import org.neo4j.graphdb.{Label, Node, Relationship}
+
+import scala.collection.JavaConversions._
 
 class BuiltInProcedureAcceptanceTest extends ProcedureCallAcceptanceTest with CypherComparisonSupport {
 
@@ -39,18 +42,41 @@ class BuiltInProcedureAcceptanceTest extends ProcedureCallAcceptanceTest with Cy
         Map("label" -> "C")))
   }
 
-  test("db.schema should not throw an exception") {
+  test("should be able to use db.schema") {
+
+    // Given
     val neo = createLabeledNode("Neo")
     val d1 = createLabeledNode("Department")
     val e1 = createLabeledNode("Employee")
     relate(e1, d1, "WORKS_AT", "Hallo")
     relate(d1, neo, "PART_OF", "Hallo")
 
+    // When
     val query = "CALL db.schema()"
-    val result = succeedWith(Configs.Procs, query)
-    println(result.dumpToString())
+    val result = succeedWith(Configs.Procs, query).toList
+
+    // Then
+    result.size should equal(1)
+
+    // And then nodes
+    val nodes = result.head("nodes").asInstanceOf[Seq[Node]]
+
+    val nodeState: Set[(List[Label], Map[String,AnyRef])] =
+      nodes.map(n => (n.getLabels.toList, n.getAllProperties.toMap)).toSet
+
+    val empty = new java.util.ArrayList()
+    nodeState should equal(
+      Set(
+        (List(Label.label("Neo")),        Map("indexes" -> empty, "constraints" -> empty, "name" -> "Neo")),
+        (List(Label.label("Department")), Map("indexes" -> empty, "constraints" -> empty, "name" -> "Department")),
+        (List(Label.label("Employee")),   Map("indexes" -> empty, "constraints" -> empty, "name" -> "Employee"))
+      ))
+
+    // And then relationships
+    val relationships = result.head("relationships").asInstanceOf[Seq[Relationship]]
 
-    // TODO this is not the proper acceptance test yet
+    val relationshipState: Set[String] = relationships.map(_.getType.name()).toSet
+    relationshipState should equal(Set("WORKS_AT", "PART_OF"))
   }
 
   test("should not be able to filter as part of standalone call") {