Issue #542: Add a strategy to merge edge nodes properties when creating relationships using Relationship pattern strategy (#544)

* Issue #542: Add a strategy to merge edge nodes properties when creating relationships using Relationship pattern strategy

* some refactoring

Co-authored-by: Andrea Santurbano <[email protected]>

Author: mroiter-larus

.gitignore

@@ -31,4 +31,3 @@ Thumbs.db
 bin
 doc/node
 doc/node_modules
-

common/src/main/kotlin/streams/service/sink/strategy/NodePatternIngestionStrategy.kt

@@ -15,7 +15,7 @@ class NodePatternIngestionStrategy(private val nodePatternConfiguration: NodePat
                 |MERGE (n${getLabelsAsString(nodePatternConfiguration.labels)}{${
                     getNodeMergeKeys("keys", nodePatternConfiguration.keys)
                 }})
-                |SET n = event.properties
+                |SET n ${if (nodePatternConfiguration.mergeProperties) "+" else ""}= event.properties
                 |SET n += event.keys
             """.trimMargin()
 

common/src/main/kotlin/streams/service/sink/strategy/PatternConfiguration.kt

@@ -42,14 +42,14 @@ private fun cleanProperties(type: PatternConfigurationType, properties: List<Str
 interface PatternConfiguration
 
 data class NodePatternConfiguration(val keys: Set<String>, val type: PatternConfigurationType,
-                                    val labels: List<String>, val properties: List<String>): PatternConfiguration {
+                                    val labels: List<String>, val properties: List<String>, val mergeProperties: Boolean): PatternConfiguration {
     companion object {
 
         // (:LabelA{!id,foo,bar})
         @JvmStatic private val cypherNodePatternConfigured = """\((:\w+\s*(?::\s*(?:\w+)\s*)*)\s*(?:\{\s*(-?[\w!\.]+\s*(?:,\s*-?[!\w\*\.]+\s*)*)\})?\)$""".toRegex()
         // LabelA{!id,foo,bar}
         @JvmStatic private val simpleNodePatternConfigured = """^(\w+\s*(?::\s*(?:\w+)\s*)*)\s*(?:\{\s*(-?[\w!\.]+\s*(?:,\s*-?[!\w\*\.]+\s*)*)\})?$""".toRegex()
-        fun parse(pattern: String): NodePatternConfiguration {
+        fun parse(pattern: String, mergeProperties: Boolean): NodePatternConfiguration {
             val isCypherPattern = pattern.startsWith("(")
             val regex = if (isCypherPattern) cypherNodePatternConfigured else simpleNodePatternConfigured
             val matcher = regex.matchEntire(pattern)
@@ -75,25 +75,26 @@ data class NodePatternConfiguration(val keys: Set<String>, val type: PatternConf
                 val cleanedProperties = cleanProperties(type, properties)
 
                 return NodePatternConfiguration(keys = keys, type = type,
-                        labels = labels, properties = cleanedProperties)
+                        labels = labels, properties = cleanedProperties, mergeProperties)
             }
         }
     }
+
 }
 
 
 data class RelationshipPatternConfiguration(val start: NodePatternConfiguration, val end: NodePatternConfiguration,
                                             val relType: String, val type: PatternConfigurationType,
-                                            val properties: List<String>): PatternConfiguration {
+                                            val properties: List<String>, val mergeProperties: Boolean): PatternConfiguration {
     companion object {
 
         // we don't allow ALL for start/end nodes in rels
         // it's public for testing purpose
-        fun getNodeConf(pattern: String): NodePatternConfiguration {
-            val start = NodePatternConfiguration.parse(pattern)
+        fun getNodeConf(pattern: String, mergeProperties: Boolean): NodePatternConfiguration {
+            val start = NodePatternConfiguration.parse(pattern, mergeProperties)
             return if (start.type == PatternConfigurationType.ALL) {
                 NodePatternConfiguration(keys = start.keys, type = PatternConfigurationType.INCLUDE,
-                        labels = start.labels, properties = start.properties)
+                        labels = start.labels, properties = start.properties, mergeProperties)
             } else {
                 start
             }
@@ -148,7 +149,7 @@ data class RelationshipPatternConfiguration(val start: NodePatternConfiguration,
             }
         }
 
-        fun parse(pattern: String): RelationshipPatternConfiguration {
+        fun parse(pattern: String, mergeNodeProps: Boolean, mergeRelProps: Boolean): RelationshipPatternConfiguration {
             val isCypherPattern = pattern.startsWith("(")
             val regex = if (isCypherPattern) {
                 cypherRelationshipPatternConfigured
@@ -169,20 +170,20 @@ data class RelationshipPatternConfiguration(val start: NodePatternConfiguration,
                 val metadata = RelationshipPatternMetaData.create(isCypherPattern, isLeftToRight, matcher.groupValues)
 
                 val start = try {
-                    getNodeConf(metadata.startPattern)
+                    getNodeConf(metadata.startPattern, mergeNodeProps)
                 } catch (e: Exception) {
                     throw IllegalArgumentException("The Relationship pattern $pattern is invalid")
                 }
                 val end = try {
-                    getNodeConf(metadata.endPattern)
+                    getNodeConf(metadata.endPattern, mergeNodeProps)
                 } catch (e: Exception) {
                     throw IllegalArgumentException("The Relationship pattern $pattern is invalid")
                 }
                 val type = getPatternConfiguredType(metadata.properties)
                 isHomogeneousPattern(type, metadata.properties, pattern, "Relationship")
                 val cleanedProperties = cleanProperties(type, metadata.properties)
                 return RelationshipPatternConfiguration(start = start, end = end, relType = metadata.relType,
-                        properties = cleanedProperties, type = type)
+                        properties = cleanedProperties, type = type, mergeProperties = mergeRelProps)
             }
         }
 

common/src/main/kotlin/streams/service/sink/strategy/RelationshipPatternIngestionStrategy.kt

@@ -15,15 +15,15 @@ class RelationshipPatternIngestionStrategy(private val relationshipPatternConfig
                 |MERGE (start${getLabelsAsString(relationshipPatternConfiguration.start.labels)}{${
                     getNodeMergeKeys("start.keys", relationshipPatternConfiguration.start.keys)
                 }})
-                |SET start = event.start.properties
+                |SET start ${if (relationshipPatternConfiguration.mergeProperties) "+" else ""}= event.start.properties
                 |SET start += event.start.keys
                 |MERGE (end${getLabelsAsString(relationshipPatternConfiguration.end.labels)}{${
                     getNodeMergeKeys("end.keys", relationshipPatternConfiguration.end.keys)
                 }})
-                |SET end = event.end.properties
+                |SET end ${if (relationshipPatternConfiguration.mergeProperties) "+" else ""}= event.end.properties
                 |SET end += event.end.keys
                 |MERGE (start)-[r:${relationshipPatternConfiguration.relType}]->(end)
-                |SET r = event.properties
+                |SET r ${if (relationshipPatternConfiguration.mergeProperties) "+" else ""}= event.properties
             """.trimMargin()
 
     private val deleteRelationshipTemplate: String = """

common/src/main/kotlin/streams/service/sink/strategy/SourceIdIngestionStrategy.kt

@@ -7,7 +7,11 @@ import streams.utils.IngestionUtils.getLabelsAsString
 import streams.utils.SchemaUtils
 import streams.utils.StreamsUtils
 
-data class SourceIdIngestionStrategyConfig(val labelName: String = "SourceEvent", val idName: String = "sourceId")
+data class SourceIdIngestionStrategyConfig(val labelName: String = "SourceEvent", val idName: String = "sourceId") {
+    companion object {
+        val DEFAULT = SourceIdIngestionStrategyConfig()
+    }
+}
 
 class SourceIdIngestionStrategy(config: SourceIdIngestionStrategyConfig = SourceIdIngestionStrategyConfig()): IngestionStrategy {
 

common/src/test/kotlin/streams/service/sink/strategy/NodePatternIngestionStrategyTest.kt

@@ -10,7 +10,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should get all properties`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id})", true)
         val strategy = NodePatternIngestionStrategy(config)
         val data = mapOf("id" to 1, "foo" to "foo", "bar" to "bar", "foobar" to "foobar")
 
@@ -22,7 +22,7 @@ class NodePatternIngestionStrategyTest {
         assertEquals("""
                 |${StreamsUtils.UNWIND}
                 |MERGE (n:LabelA:LabelB{id: event.keys.id})
-                |SET n = event.properties
+                |SET n += event.properties
                 |SET n += event.keys
             """.trimMargin(), queryEvents[0].query)
         assertEquals(listOf(mapOf("keys" to mapOf("id" to 1),
@@ -37,7 +37,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should get nested properties`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id, foo.bar})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id, foo.bar})", false)
         val strategy = NodePatternIngestionStrategy(config)
         val data = mapOf("id" to 1, "foo" to mapOf("bar" to "bar", "foobar" to "foobar"))
 
@@ -65,7 +65,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should exclude nested properties`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id, -foo})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id, -foo})", false)
         val strategy = NodePatternIngestionStrategy(config)
         val map = mapOf("id" to 1, "foo" to mapOf("bar" to "bar", "foobar" to "foobar"), "prop" to 100)
 
@@ -93,7 +93,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should include nested properties`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id, foo})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id, foo})", true)
         val strategy = NodePatternIngestionStrategy(config)
         val data = mapOf("id" to 1, "foo" to mapOf("bar" to "bar", "foobar" to "foobar"), "prop" to 100)
 
@@ -106,7 +106,7 @@ class NodePatternIngestionStrategyTest {
         assertEquals("""
                 |${StreamsUtils.UNWIND}
                 |MERGE (n:LabelA:LabelB{id: event.keys.id})
-                |SET n = event.properties
+                |SET n += event.properties
                 |SET n += event.keys
             """.trimMargin(),
                 queryEvents[0].query)
@@ -121,7 +121,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should exclude the properties`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id,-foo,-bar})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id,-foo,-bar})", false)
         val strategy = NodePatternIngestionStrategy(config)
         val data = mapOf("id" to 1, "foo" to "foo", "bar" to "bar", "foobar" to "foobar")
 
@@ -146,7 +146,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should include the properties`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id,foo,bar})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id,foo,bar})", false)
         val strategy = NodePatternIngestionStrategy(config)
         val data = mapOf("id" to 1, "foo" to "foo", "bar" to "bar", "foobar" to "foobar")
 
@@ -170,7 +170,7 @@ class NodePatternIngestionStrategyTest {
     @Test
     fun `should delete the node`() {
         // given
-        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id})")
+        val config = NodePatternConfiguration.parse("(:LabelA:LabelB{!id})", true)
         val strategy = NodePatternIngestionStrategy(config)
         val data = mapOf("id" to 1, "foo" to "foo", "bar" to "bar", "foobar" to "foobar")