feat: import exactly relationship.properties when specified (#791)

Author: venikkin

common/src/main/scala/org/neo4j/spark/service/MappingService.scala

@@ -119,8 +119,17 @@ class Neo4jWriteMappingStrategy(private val options: Neo4jOptions)
 
       if (options.relationshipMetadata.relationshipKeys.contains(key)) {
         relMap.get(KEYS).put(options.relationshipMetadata.relationshipKeys.getOrElse(key, key), value)
-      } else if (!source.includesProperty(key) && !target.includesProperty(key)) {
-        relMap.get(PROPERTIES).put(options.relationshipMetadata.properties.getOrElse(key, key), value)
+      } else {
+        val propertyKey = options.relationshipMetadata.properties match {
+          case Some(relProperties) => relProperties.get(key)
+          case None =>
+            if (!source.includesProperty(key) && !target.includesProperty(key)) {
+              Some(key)
+            } else {
+              None
+            }
+        }
+        propertyKey.foreach(k => relMap.get(PROPERTIES).put(k, value))
       }
     }
   }

common/src/main/scala/org/neo4j/spark/service/SchemaService.scala

@@ -869,7 +869,7 @@ class SchemaService(
           .map(f => (f.name, f.name))
           .toMap
         val propsFromMeta: Map[String, String] =
-          options.relationshipMetadata.relationshipKeys ++ options.relationshipMetadata.properties
+          options.relationshipMetadata.relationshipKeys ++ options.relationshipMetadata.properties.getOrElse(Map.empty)
         createEntityTypeConstraint(
           "RELATIONSHIP",
           options.relationshipMetadata.relationshipType,

common/src/main/scala/org/neo4j/spark/util/Neo4jOptions.scala

@@ -57,10 +57,12 @@ class Neo4jOptions(private val options: java.util.Map[String, String]) extends S
   }
 
   private def getParameter(parameter: String, defaultValue: String = ""): String =
-    Some(options.getOrDefault(parameter, defaultValue))
+    getParameterOption(parameter).getOrElse(defaultValue)
+
+  private def getParameterOption(parameter: String): Option[String] =
+    Some(options.get(parameter))
       .flatMap(Option(_)) // to turn null into None
       .map(_.trim)
-      .getOrElse(defaultValue)
 
   private def getAuthenticationParameters: Map[String, String] = {
     val authType = getParameter(AUTH_TYPE, DEFAULT_AUTH_TYPE)
@@ -176,26 +178,28 @@ class Neo4jOptions(private val options: java.util.Map[String, String]) extends S
 
   val nodeMetadata: Neo4jNodeMetadata = initNeo4jNodeMetadata()
 
-  private def mapPropsString(str: String): Map[String, String] = str.split(",")
-    .map(_.trim)
-    .filter(_.nonEmpty)
-    .map(s => {
-      val keys = if (s.startsWith("`")) {
-        val pattern = "`[^`]+`".r
-        val groups = pattern findAllIn s
-        groups
-          .map(_.replaceAll("`", ""))
-          .toArray
-      } else {
-        s.split(":")
-      }
-      if (keys.length == 2) {
-        (keys(0), keys(1))
-      } else {
-        (keys(0), keys(0))
-      }
-    })
-    .toMap
+  private def mapPropsString(strOpt: Option[String]): Option[Map[String, String]] = strOpt.map(str =>
+    str.split(",")
+      .map(_.trim)
+      .filter(_.nonEmpty)
+      .map(s => {
+        val keys = if (s.startsWith("`")) {
+          val pattern = "`[^`]+`".r
+          val groups = pattern findAllIn s
+          groups
+            .map(_.replaceAll("`", ""))
+            .toArray
+        } else {
+          s.split(":")
+        }
+        if (keys.length == 2) {
+          (keys(0), keys(1))
+        } else {
+          (keys(0), keys(0))
+        }
+      })
+      .toMap
+  )
 
   private def initNeo4jNodeMetadata(
     nodeKeysString: String = getParameter(NODE_KEYS, ""),
@@ -204,8 +208,8 @@ class Neo4jOptions(private val options: java.util.Map[String, String]) extends S
     skipNullKeys: Boolean = getParameter(NODE_KEYS_SKIP_NULLS, "false").toBoolean
   ): Neo4jNodeMetadata = {
 
-    val nodeKeys = mapPropsString(nodeKeysString)
-    val nodeProps = mapPropsString(nodePropsString)
+    val nodeKeys = mapPropsString(Some(nodeKeysString)).getOrElse(Map.empty[String, String])
+    val nodeProps = mapPropsString(Some(nodePropsString)).getOrElse(Map.empty[String, String])
 
     val labels = labelsString
       .split(":")
@@ -252,7 +256,7 @@ class Neo4jOptions(private val options: java.util.Map[String, String]) extends S
 
     val nodeMap = getParameter(RELATIONSHIP_NODES_MAP, DEFAULT_RELATIONSHIP_NODES_MAP.toString).toBoolean
 
-    val relProps = mapPropsString(getParameter(RELATIONSHIP_PROPERTIES))
+    val relProps = mapPropsString(getParameterOption(RELATIONSHIP_PROPERTIES))
 
     val writeStrategy = RelationshipSaveStrategy.withCaseInsensitiveName(getParameter(
       RELATIONSHIP_SAVE_STRATEGY,
@@ -267,7 +271,7 @@ class Neo4jOptions(private val options: java.util.Map[String, String]) extends S
       DEFAULT_RELATIONSHIP_TARGET_SAVE_MODE.toString
     ))
 
-    val relationshipKeys = mapPropsString(getParameter(RELATIONSHIP_KEYS, ""))
+    val relationshipKeys = mapPropsString(getParameterOption(RELATIONSHIP_KEYS)).getOrElse(Map.empty)
 
     Neo4jRelationshipMetadata(
       source,
@@ -389,7 +393,7 @@ case class Neo4jRelationshipMetadata(
   target: Neo4jNodeMetadata,
   sourceSaveMode: NodeSaveMode.Value,
   targetSaveMode: NodeSaveMode.Value,
-  properties: Map[String, String],
+  properties: Option[Map[String, String]],
   relationshipType: String,
   nodeMap: Boolean,
   saveStrategy: RelationshipSaveStrategy.Value,

common/src/main/scala/org/neo4j/spark/util/Validations.scala

@@ -48,7 +48,7 @@ case class ValidateSchemaOptions(neo4jOptions: Neo4jOptions, schema: StructType)
       Neo4jOptions.NODE_KEYS -> schema.getMissingFields(neo4jOptions.nodeMetadata.nodeKeys.keySet),
       Neo4jOptions.NODE_PROPS -> schema.getMissingFields(neo4jOptions.nodeMetadata.properties.keySet),
       Neo4jOptions.RELATIONSHIP_PROPERTIES -> schema.getMissingFields(
-        neo4jOptions.relationshipMetadata.properties.keySet
+        neo4jOptions.relationshipMetadata.properties.getOrElse(Map.empty).keySet
       ),
       Neo4jOptions.RELATIONSHIP_SOURCE_NODE_PROPS -> schema.getMissingFields(
         neo4jOptions.relationshipMetadata.source.properties.keySet

common/src/test/scala/org/neo4j/spark/util/Neo4jOptionsTest.scala

@@ -204,7 +204,7 @@ class Neo4jOptionsTest {
 
     val neo4jOptions: Neo4jOptions = new Neo4jOptions(options)
 
-    assertEquals(neo4jOptions.relationshipMetadata.properties, Map.empty)
+    assertEquals(neo4jOptions.relationshipMetadata.properties, None)
   }
 
   @Test