graphson: support embedded nodes as properties (#378)

mpollmeier · web-flow · commit 3fe9d2812335 · 2023-06-15T17:50:41.000+02:00
* graphson: support embedded nodes as properties

* fix other test (side effect)

* fmt
diff --git a/formats/src/main/scala/overflowdb/formats/graphson/GraphSONExporter.scala b/formats/src/main/scala/overflowdb/formats/graphson/GraphSONExporter.scala
@@ -87,6 +87,7 @@ object GraphSONExporter extends Exporter {
       case x: Float                 => FloatValue(x)
       case x: Int                   => IntValue(x)
       case x: Long                  => LongValue(x)
+      case x: Node                  => NodeIdValue(x.id())
     }
   }
 
diff --git a/formats/src/main/scala/overflowdb/formats/graphson/GraphSONImporter.scala b/formats/src/main/scala/overflowdb/formats/graphson/GraphSONImporter.scala
@@ -25,15 +25,16 @@ object GraphSONImporter extends Importer {
   }
 
   private def addNode(n: Vertex, graph: Graph): Unit = {
-    graph.addNode(n.id.`@value`, n.label, flattenProperties(n.properties): _*)
+    graph.addNode(n.id.`@value`, n.label, flattenProperties(n.properties, graph): _*)
   }
 
-  private def flattenProperties(m: Map[String, Property]): Array[_] = {
+  private def flattenProperties(m: Map[String, Property], graph: Graph): Array[_] = {
     m.view
       .mapValues { v =>
         v.`@value` match {
-          case x: ListValue => x.`@value`.map(_.`@value`)
-          case x            => x.`@value`
+          case ListValue(value, _)   => value.map(_.`@value`)
+          case NodeIdValue(value, _) => graph.node(value)
+          case x                     => x.`@value`
         }
       }
       .flatMap { case (k, v) => Seq(k, v) }
@@ -43,6 +44,6 @@ object GraphSONImporter extends Importer {
   private def addEdge(e: Edge, graph: Graph): Unit = {
     val src = graph.node(e.outV.`@value`)
     val tgt = graph.node(e.inV.`@value`)
-    src.addEdge(e.label, tgt, flattenProperties(e.properties): _*)
+    src.addEdge(e.label, tgt, flattenProperties(e.properties, graph): _*)
   }
 }
diff --git a/formats/src/main/scala/overflowdb/formats/graphson/GraphSONProtocol.scala b/formats/src/main/scala/overflowdb/formats/graphson/GraphSONProtocol.scala
@@ -33,7 +33,12 @@ object GraphSONProtocol extends DefaultJsonProtocol {
             "@value" -> JsNumber(x.`@value`),
             "@type" -> JsString(x.`@type`)
           )
-        case _ => serializationError("PropertyValue expected")
+        case x: NodeIdValue =>
+          JsObject(
+            "@value" -> JsNumber(x.`@value`),
+            "@type" -> JsString(x.`@type`)
+          )
+        case x => serializationError(s"unsupported propertyValue: $x")
       }
     }
 
@@ -56,6 +61,7 @@ object GraphSONProtocol extends DefaultJsonProtocol {
         else if (typ.equals(Type.Int.typ)) IntValue(v.toIntExact)
         else if (typ.equals(Type.Float.typ)) FloatValue(v.toFloat)
         else if (typ.equals(Type.Double.typ)) DoubleValue(v.toDouble)
+        else if (typ.equals(Type.NodeId.typ)) NodeIdValue(v.toLongExact)
         else deserializationError("Valid number type or list expected")
       case _ => deserializationError("PropertyValue expected")
     }
diff --git a/formats/src/main/scala/overflowdb/formats/graphson/package.scala b/formats/src/main/scala/overflowdb/formats/graphson/package.scala
@@ -15,6 +15,7 @@ package object graphson {
     val Float = GraphSONVal(5, "g:Float")
     val Double = GraphSONVal(6, "g:Double")
     val List = GraphSONVal(7, "g:List")
+    val NodeId = GraphSONVal(8, "g:VertexId")
 
     def fromRuntimeClass(clazz: Class[_]): Type.Value = {
       if (clazz.isAssignableFrom(classOf[Boolean]) || clazz.isAssignableFrom(classOf[java.lang.Boolean]))
@@ -78,6 +79,8 @@ package object graphson {
   case class ListValue(override val `@value`: Array[PropertyValue], `@type`: String = Type.List.typ)
       extends PropertyValue
 
+  case class NodeIdValue(override val `@value`: Long, `@type`: String = Type.NodeId.typ) extends PropertyValue
+
   case class Property(id: LongValue, `@value`: PropertyValue, `@type`: String = "g:Property")
 
 }
diff --git a/formats/src/test/scala/overflowdb/formats/graphson/GraphSONTests.scala b/formats/src/test/scala/overflowdb/formats/graphson/GraphSONTests.scala
@@ -111,6 +111,30 @@ class GraphSONTests extends AnyWordSpec {
         }
       }
     }
+
+    "using 'contained node' property" in {
+      val graph = SimpleDomain.newGraph()
+
+      val node1 = graph.addNode(1, TestNode.LABEL)
+      graph.addNode(2, TestNode.LABEL, TestNode.CONTAINED_TESTNODE_PROPERTY, node1, TestNode.INT_PROPERTY, 11)
+
+      File.usingTemporaryDirectory(getClass.getName) { exportRootDirectory =>
+        val exportResult = GraphSONExporter.runExport(graph, exportRootDirectory.pathAsString)
+        exportResult.nodeCount shouldBe 2
+        val Seq(graphJsonFile) = exportResult.files
+
+        // import graphml into new graph, use difftool for round trip of conversion
+        val reimported = SimpleDomain.newGraph()
+        GraphSONImporter.runImport(reimported, graphJsonFile)
+        val diff = DiffTool.compare(graph, reimported)
+        val diffString = diff.asScala.mkString(lineSeparator)
+        withClue(
+          s"original graph contained two list properties, these should also be present in reimported graph $diffString $lineSeparator"
+        ) {
+          diff.size shouldBe 0
+        }
+      }
+    }
   }
 
 }
diff --git a/formats/src/test/scala/overflowdb/formats/neo4jcsv/Neo4jCsvTests.scala b/formats/src/test/scala/overflowdb/formats/neo4jcsv/Neo4jCsvTests.scala
@@ -131,14 +131,14 @@ class Neo4jCsvTests extends AnyWordSpec {
       // assert csv file contents
       val nodeHeaderFile = fuzzyFindFile(exportedFiles, TestNode.LABEL, HeaderFileSuffix)
       nodeHeaderFile.contentAsString.trim shouldBe
-        ":ID,:LABEL,FunkyListProperty:string[],IntListProperty:int[],IntProperty:int,StringListProperty:string[],StringProperty:string"
+        ":ID,:LABEL,ContainedTestNodeProperty,FunkyListProperty:string[],IntListProperty:int[],IntProperty:int,StringListProperty:string[],StringProperty:string"
 
       val nodeDataFileLines = fuzzyFindFile(exportedFiles, TestNode.LABEL, DataFileSuffix).lines.toSeq
       nodeDataFileLines.size shouldBe 3
-      nodeDataFileLines should contain("2,testNode,,,,,stringProp2")
-      nodeDataFileLines should contain("3,testNode,,,13,,DEFAULT_STRING_VALUE")
+      nodeDataFileLines should contain("2,testNode,,,,,,stringProp2")
+      nodeDataFileLines should contain("3,testNode,,,,13,,DEFAULT_STRING_VALUE")
       nodeDataFileLines should contain(
-        "1,testNode,apoplectic;bucolic,21;31;41,11,stringListProp1a;stringListProp1b,stringProp1"
+        "1,testNode,,apoplectic;bucolic,21;31;41,11,stringListProp1a;stringListProp1b,stringProp1"
       )
 
       val edgeHeaderFile = fuzzyFindFile(exportedFiles, TestEdge.LABEL, HeaderFileSuffix)
@@ -153,11 +153,12 @@ class Neo4jCsvTests extends AnyWordSpec {
         """LOAD CSV FROM 'file:/nodes_testNode_data.csv' AS line
           |CREATE (:testNode {
           |id: toInteger(line[0]),
-          |FunkyListProperty: toStringList(split(line[2], ";")),
-          |IntListProperty: toIntegerList(split(line[3], ";")),
-          |IntProperty: toInteger(line[4]),
-          |StringListProperty: toStringList(split(line[5], ";")),
-          |StringProperty: line[6]
+          |ContainedTestNodeProperty: line[2],
+          |FunkyListProperty: toStringList(split(line[3], ";")),
+          |IntListProperty: toIntegerList(split(line[4], ";")),
+          |IntProperty: toInteger(line[5]),
+          |StringListProperty: toStringList(split(line[6], ";")),
+          |StringProperty: line[7]
           |});
           |""".stripMargin
 
diff --git a/testdomains/src/main/java/overflowdb/testdomains/simple/TestNode.java b/testdomains/src/main/java/overflowdb/testdomains/simple/TestNode.java
@@ -14,6 +14,7 @@ public class TestNode extends NodeRef<TestNodeDb> {
   public static final String STRING_LIST_PROPERTY = "StringListProperty";
   public static final String INT_LIST_PROPERTY = "IntListProperty";
   public static final String FUNKY_LIST_PROPERTY = "FunkyListProperty";
+  public static final String CONTAINED_TESTNODE_PROPERTY = "ContainedTestNodeProperty";
 
   public TestNode(Graph graph, long id) {
     super(graph, id);
@@ -42,6 +43,8 @@ public List<Integer> intListProperty() {
 
   public FunkyList funkyList() { return get().funkyList(); }
 
+  public TestNode containedTestNode() { return get().containedTestNode(); }
+
   @Override
   public Object propertyDefaultValue(String propertyKey) {
     if (STRING_PROPERTY.equals(propertyKey))
diff --git a/testdomains/src/main/java/overflowdb/testdomains/simple/TestNodeDb.java b/testdomains/src/main/java/overflowdb/testdomains/simple/TestNodeDb.java
@@ -17,6 +17,7 @@ protected TestNodeDb(NodeRef ref) {
   private List<String> _stringListProperty;
   private int[] _intListProperty; // to test primitive arrays serialization
   private FunkyList _funkyList;
+  private TestNode _containedTestNode;
 
   public String stringProperty() {
     if (_stringProperty != null)
@@ -41,6 +42,10 @@ public FunkyList funkyList() {
     return _funkyList;
   }
 
+  public TestNode containedTestNode() {
+    return _containedTestNode;
+  }
+
   @Override
   public NodeLayoutInformation layoutInformation() {
     return layoutInformation;
@@ -59,6 +64,8 @@ public Object property(String key) {
       return _intListProperty;
     } else if (key == TestNode.FUNKY_LIST_PROPERTY) {
       return funkyList();
+    } else if (key == TestNode.CONTAINED_TESTNODE_PROPERTY) {
+      return containedTestNode();
     } else {
       return propertyDefaultValue(key);
     }
@@ -111,6 +118,8 @@ protected void updateSpecificProperty(String key, Object value) {
       } else {
         this._funkyList = (FunkyList) value;
       }
+    } else if (TestNode.CONTAINED_TESTNODE_PROPERTY.equals(key)) {
+      this._containedTestNode = (TestNode) value;
     } else {
       throw new RuntimeException("property with key=" + key + " not (yet) supported by " + this.getClass().getName());
     }
@@ -128,14 +137,16 @@ protected void removeSpecificProperty(String key) {
       this._intListProperty = null;
     } else if (TestNode.FUNKY_LIST_PROPERTY.equals(key)) {
       this._funkyList = null;
+    } else if (TestNode.CONTAINED_TESTNODE_PROPERTY.equals(key)) {
+      this._containedTestNode = null;
     } else {
       throw new RuntimeException("property with key=" + key + " not (yet) supported by " + this.getClass().getName());
     }
   }
 
   public static NodeLayoutInformation layoutInformation = new NodeLayoutInformation(
       TestNode.LABEL,
-      new HashSet<>(Arrays.asList(TestNode.STRING_PROPERTY, TestNode.INT_PROPERTY, TestNode.STRING_LIST_PROPERTY, TestNode.INT_LIST_PROPERTY, TestNode.FUNKY_LIST_PROPERTY)),
+      new HashSet<>(Arrays.asList(TestNode.STRING_PROPERTY, TestNode.INT_PROPERTY, TestNode.STRING_LIST_PROPERTY, TestNode.INT_LIST_PROPERTY, TestNode.FUNKY_LIST_PROPERTY, TestNode.CONTAINED_TESTNODE_PROPERTY)),
       Arrays.asList(TestEdge.layoutInformation),
       Arrays.asList(TestEdge.layoutInformation));
 

Original file line number	Diff line number	Diff line change
`@@ -87,6 +87,7 @@ object GraphSONExporter extends Exporter {`
`87`	`87`	`case x: Float => FloatValue(x)`
`88`	`88`	`case x: Int => IntValue(x)`
`89`	`89`	`case x: Long => LongValue(x)`
	`90`	`+ case x: Node => NodeIdValue(x.id())`
`90`	`91`	`}`
`91`	`92`	`}`
`92`	`93`
Original file line number	Diff line number	Diff line change
`@@ -25,15 +25,16 @@ object GraphSONImporter extends Importer {`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`private def addNode(n: Vertex, graph: Graph): Unit = {`
`28`		- graph.addNode(n.id.`@value`, n.label, flattenProperties(n.properties): _*)
	`28`	+ graph.addNode(n.id.`@value`, n.label, flattenProperties(n.properties, graph): _*)
`29`	`29`	`}`
`30`	`30`
`31`		`- private def flattenProperties(m: Map[String, Property]): Array[_] = {`
	`31`	`+ private def flattenProperties(m: Map[String, Property], graph: Graph): Array[_] = {`
`32`	`32`	`m.view`
`33`	`33`	`.mapValues { v =>`
`34`	`34`	v.`@value` match {
`35`		- case x: ListValue => x.`@value`.map(_.`@value`)
`36`		- case x => x.`@value`
	`35`	+ case ListValue(value, _) => value.map(_.`@value`)
	`36`	`+ case NodeIdValue(value, _) => graph.node(value)`
	`37`	+ case x => x.`@value`
`37`	`38`	`}`
`38`	`39`	`}`
`39`	`40`	`.flatMap { case (k, v) => Seq(k, v) }`
`@@ -43,6 +44,6 @@ object GraphSONImporter extends Importer {`
`43`	`44`	`private def addEdge(e: Edge, graph: Graph): Unit = {`
`44`	`45`	val src = graph.node(e.outV.`@value`)
`45`	`46`	val tgt = graph.node(e.inV.`@value`)
`46`		`- src.addEdge(e.label, tgt, flattenProperties(e.properties): _*)`
	`47`	`+ src.addEdge(e.label, tgt, flattenProperties(e.properties, graph): _*)`
`47`	`48`	`}`
`48`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,12 @@ object GraphSONProtocol extends DefaultJsonProtocol {`
`33`	`33`	"@value" -> JsNumber(x.`@value`),
`34`	`34`	"@type" -> JsString(x.`@type`)
`35`	`35`	`)`
`36`		`- case _ => serializationError("PropertyValue expected")`
	`36`	`+ case x: NodeIdValue =>`
	`37`	`+ JsObject(`
	`38`	+ "@value" -> JsNumber(x.`@value`),
	`39`	+ "@type" -> JsString(x.`@type`)
	`40`	`+ )`
	`41`	`+ case x => serializationError(s"unsupported propertyValue: $x")`
`37`	`42`	`}`
`38`	`43`	`}`
`39`	`44`
`@@ -56,6 +61,7 @@ object GraphSONProtocol extends DefaultJsonProtocol {`
`56`	`61`	`else if (typ.equals(Type.Int.typ)) IntValue(v.toIntExact)`
`57`	`62`	`else if (typ.equals(Type.Float.typ)) FloatValue(v.toFloat)`
`58`	`63`	`else if (typ.equals(Type.Double.typ)) DoubleValue(v.toDouble)`
	`64`	`+ else if (typ.equals(Type.NodeId.typ)) NodeIdValue(v.toLongExact)`
`59`	`65`	`else deserializationError("Valid number type or list expected")`
`60`	`66`	`case _ => deserializationError("PropertyValue expected")`
`61`	`67`	`}`