Merge "[CPS] RI: Code Refactoring # Replace '[\s\S]' to '.' as it is same as '.'...
[cps.git] / cps-ri / src / main / java / org / onap / cps / spi / impl / CpsDataPersistenceServiceImpl.java
index 95058ee..cca5d9c 100644 (file)
@@ -23,6 +23,7 @@
 
 package org.onap.cps.spi.impl;
 
+import com.google.common.base.Strings;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSet.Builder;
 import io.micrometer.core.annotation.Timed;
@@ -81,88 +82,85 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     private final JsonObjectMapper jsonObjectMapper;
     private final SessionManager sessionManager;
 
-    private static final String REG_EX_FOR_OPTIONAL_LIST_INDEX = "(\\[@[\\s\\S]+?])?)";
+    private static final String REG_EX_FOR_OPTIONAL_LIST_INDEX = "(\\[@.+?])?)";
+    private static final String QUERY_ACROSS_ANCHORS = null;
+    private static final AnchorEntity ALL_ANCHORS = null;
 
     @Override
     public void addChildDataNode(final String dataspaceName, final String anchorName, final String parentNodeXpath,
                                  final DataNode newChildDataNode) {
-        addNewChildDataNode(dataspaceName, anchorName, parentNodeXpath, newChildDataNode);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+        addNewChildDataNode(anchorEntity, parentNodeXpath, newChildDataNode);
     }
 
     @Override
     public void addChildDataNodes(final String dataspaceName, final String anchorName,
                                   final String parentNodeXpath, final Collection<DataNode> dataNodes) {
-        addChildrenDataNodes(dataspaceName, anchorName, parentNodeXpath, dataNodes);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+        addChildrenDataNodes(anchorEntity, parentNodeXpath, dataNodes);
     }
 
     @Override
     public void addListElements(final String dataspaceName, final String anchorName, final String parentNodeXpath,
                                 final Collection<DataNode> newListElements) {
-        addChildrenDataNodes(dataspaceName, anchorName, parentNodeXpath, newListElements);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+        addChildrenDataNodes(anchorEntity, parentNodeXpath, newListElements);
     }
 
     @Override
     public void addMultipleLists(final String dataspaceName, final String anchorName, final String parentNodeXpath,
                                  final Collection<Collection<DataNode>> newLists) {
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
         final Collection<String> failedXpaths = new HashSet<>();
-        newLists.forEach(newList -> {
+        for (final Collection<DataNode> newList : newLists) {
             try {
-                addChildrenDataNodes(dataspaceName, anchorName, parentNodeXpath, newList);
+                addChildrenDataNodes(anchorEntity, parentNodeXpath, newList);
             } catch (final AlreadyDefinedExceptionBatch e) {
                 failedXpaths.addAll(e.getAlreadyDefinedXpaths());
             }
-        });
-
+        }
         if (!failedXpaths.isEmpty()) {
             throw new AlreadyDefinedExceptionBatch(failedXpaths);
         }
-
     }
 
-    private void addNewChildDataNode(final String dataspaceName, final String anchorName,
-                                     final String parentNodeXpath, final DataNode newChild) {
-        final FragmentEntity parentFragmentEntity =
-            getFragmentEntity(dataspaceName, anchorName, parentNodeXpath);
-        final FragmentEntity newChildAsFragmentEntity =
-                convertToFragmentWithAllDescendants(parentFragmentEntity.getDataspace(),
-                        parentFragmentEntity.getAnchor(), newChild);
+    private void addNewChildDataNode(final AnchorEntity anchorEntity, final String parentNodeXpath,
+                                     final DataNode newChild) {
+        final FragmentEntity parentFragmentEntity = getFragmentEntity(anchorEntity, parentNodeXpath);
+        final FragmentEntity newChildAsFragmentEntity = convertToFragmentWithAllDescendants(anchorEntity, newChild);
         newChildAsFragmentEntity.setParentId(parentFragmentEntity.getId());
         try {
             fragmentRepository.save(newChildAsFragmentEntity);
         } catch (final DataIntegrityViolationException e) {
-            throw AlreadyDefinedException.forDataNode(newChild.getXpath(), anchorName, e);
+            throw AlreadyDefinedException.forDataNode(newChild.getXpath(), anchorEntity.getName(), e);
         }
-
     }
 
-    private void addChildrenDataNodes(final String dataspaceName, final String anchorName, final String parentNodeXpath,
+    private void addChildrenDataNodes(final AnchorEntity anchorEntity, final String parentNodeXpath,
                                       final Collection<DataNode> newChildren) {
-        final FragmentEntity parentFragmentEntity =
-            getFragmentEntity(dataspaceName, anchorName, parentNodeXpath);
+        final FragmentEntity parentFragmentEntity = getFragmentEntity(anchorEntity, parentNodeXpath);
         final List<FragmentEntity> fragmentEntities = new ArrayList<>(newChildren.size());
         try {
-            newChildren.forEach(newChildAsDataNode -> {
+            for (final DataNode newChildAsDataNode : newChildren) {
                 final FragmentEntity newChildAsFragmentEntity =
-                        convertToFragmentWithAllDescendants(parentFragmentEntity.getDataspace(),
-                                parentFragmentEntity.getAnchor(), newChildAsDataNode);
+                    convertToFragmentWithAllDescendants(anchorEntity, newChildAsDataNode);
                 newChildAsFragmentEntity.setParentId(parentFragmentEntity.getId());
                 fragmentEntities.add(newChildAsFragmentEntity);
-            });
+            }
             fragmentRepository.saveAll(fragmentEntities);
         } catch (final DataIntegrityViolationException e) {
             log.warn("Exception occurred : {} , While saving : {} children, retrying using individual save operations",
                     e, fragmentEntities.size());
-            retrySavingEachChildIndividually(dataspaceName, anchorName, parentNodeXpath, newChildren);
+            retrySavingEachChildIndividually(anchorEntity, parentNodeXpath, newChildren);
         }
     }
 
-    private void retrySavingEachChildIndividually(final String dataspaceName, final String anchorName,
-                                                  final String parentNodeXpath,
+    private void retrySavingEachChildIndividually(final AnchorEntity anchorEntity, final String parentNodeXpath,
                                                   final Collection<DataNode> newChildren) {
         final Collection<String> failedXpaths = new HashSet<>();
         for (final DataNode newChild : newChildren) {
             try {
-                addNewChildDataNode(dataspaceName, anchorName, parentNodeXpath, newChild);
+                addNewChildDataNode(anchorEntity, parentNodeXpath, newChild);
             } catch (final AlreadyDefinedException e) {
                 failedXpaths.add(newChild.getXpath());
             }
@@ -172,40 +170,29 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
         }
     }
 
-    @Override
-    public void storeDataNode(final String dataspaceName, final String anchorName, final DataNode dataNode) {
-        storeDataNodes(dataspaceName, anchorName, Collections.singletonList(dataNode));
-    }
-
     @Override
     public void storeDataNodes(final String dataspaceName, final String anchorName,
                                final Collection<DataNode> dataNodes) {
-        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
-        final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
         final List<FragmentEntity> fragmentEntities = new ArrayList<>(dataNodes.size());
         try {
             for (final DataNode dataNode: dataNodes) {
-                final FragmentEntity fragmentEntity = convertToFragmentWithAllDescendants(dataspaceEntity, anchorEntity,
-                        dataNode);
+                final FragmentEntity fragmentEntity = convertToFragmentWithAllDescendants(anchorEntity, dataNode);
                 fragmentEntities.add(fragmentEntity);
             }
             fragmentRepository.saveAll(fragmentEntities);
         } catch (final DataIntegrityViolationException exception) {
             log.warn("Exception occurred : {} , While saving : {} data nodes, Retrying saving data nodes individually",
                     exception, dataNodes.size());
-            storeDataNodesIndividually(dataspaceName, anchorName, dataNodes);
+            storeDataNodesIndividually(anchorEntity, dataNodes);
         }
     }
 
-    private void storeDataNodesIndividually(final String dataspaceName, final String anchorName,
-                                           final Collection<DataNode> dataNodes) {
-        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
-        final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
+    private void storeDataNodesIndividually(final AnchorEntity anchorEntity, final Collection<DataNode> dataNodes) {
         final Collection<String> failedXpaths = new HashSet<>();
         for (final DataNode dataNode: dataNodes) {
             try {
-                final FragmentEntity fragmentEntity = convertToFragmentWithAllDescendants(dataspaceEntity, anchorEntity,
-                        dataNode);
+                final FragmentEntity fragmentEntity = convertToFragmentWithAllDescendants(anchorEntity, dataNode);
                 fragmentRepository.save(fragmentEntity);
             } catch (final DataIntegrityViolationException e) {
                 failedXpaths.add(dataNode.getXpath());
@@ -220,30 +207,25 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
      * Convert DataNode object into Fragment and places the result in the fragments placeholder. Performs same action
      * for all DataNode children recursively.
      *
-     * @param dataspaceEntity       dataspace
      * @param anchorEntity          anchorEntity
      * @param dataNodeToBeConverted dataNode
      * @return a Fragment built from current DataNode
      */
-    private FragmentEntity convertToFragmentWithAllDescendants(final DataspaceEntity dataspaceEntity,
-                                                               final AnchorEntity anchorEntity,
+    private FragmentEntity convertToFragmentWithAllDescendants(final AnchorEntity anchorEntity,
                                                                final DataNode dataNodeToBeConverted) {
-        final FragmentEntity parentFragment = toFragmentEntity(dataspaceEntity, anchorEntity, dataNodeToBeConverted);
+        final FragmentEntity parentFragment = toFragmentEntity(anchorEntity, dataNodeToBeConverted);
         final Builder<FragmentEntity> childFragmentsImmutableSetBuilder = ImmutableSet.builder();
         for (final DataNode childDataNode : dataNodeToBeConverted.getChildDataNodes()) {
-            final FragmentEntity childFragment =
-                    convertToFragmentWithAllDescendants(parentFragment.getDataspace(), parentFragment.getAnchor(),
-                            childDataNode);
+            final FragmentEntity childFragment = convertToFragmentWithAllDescendants(anchorEntity, childDataNode);
             childFragmentsImmutableSetBuilder.add(childFragment);
         }
         parentFragment.setChildFragments(childFragmentsImmutableSetBuilder.build());
         return parentFragment;
     }
 
-    private FragmentEntity toFragmentEntity(final DataspaceEntity dataspaceEntity,
-                                            final AnchorEntity anchorEntity, final DataNode dataNode) {
+    private FragmentEntity toFragmentEntity(final AnchorEntity anchorEntity, final DataNode dataNode) {
         return FragmentEntity.builder()
-                .dataspace(dataspaceEntity)
+                .dataspace(anchorEntity.getDataspace())
                 .anchor(anchorEntity)
                 .xpath(dataNode.getXpath())
                 .attributes(jsonObjectMapper.asJsonString(dataNode.getLeaves()))
@@ -256,7 +238,7 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     public Collection<DataNode> getDataNodes(final String dataspaceName, final String anchorName,
                                              final String xpath,
                                              final FetchDescendantsOption fetchDescendantsOption) {
-        final String targetXpath = isRootXpath(xpath) ? xpath : CpsPathUtil.getNormalizedXpath(xpath);
+        final String targetXpath = getNormalizedXpath(xpath);
         final Collection<DataNode> dataNodes = getDataNodesForMultipleXpaths(dataspaceName, anchorName,
                 Collections.singletonList(targetXpath), fetchDescendantsOption);
         if (dataNodes.isEmpty()) {
@@ -271,15 +253,15 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     public Collection<DataNode> getDataNodesForMultipleXpaths(final String dataspaceName, final String anchorName,
                                                               final Collection<String> xpaths,
                                                               final FetchDescendantsOption fetchDescendantsOption) {
-        final Collection<FragmentEntity> fragmentEntities = getFragmentEntities(dataspaceName, anchorName, xpaths);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+        final Collection<FragmentEntity> fragmentEntities =
+            getFragmentEntities(anchorEntity, xpaths, fetchDescendantsOption);
         return toDataNodes(fragmentEntities, fetchDescendantsOption);
     }
 
-    private Collection<FragmentEntity> getFragmentEntities(final String dataspaceName, final String anchorName,
-                                                           final Collection<String> xpaths) {
-        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
-        final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
-
+    private Collection<FragmentEntity> getFragmentEntities(final AnchorEntity anchorEntity,
+                                                           final Collection<String> xpaths,
+                                                           final FetchDescendantsOption fetchDescendantsOption) {
         final Collection<String> nonRootXpaths = new HashSet<>(xpaths);
         final boolean haveRootXpath = nonRootXpaths.removeIf(CpsDataPersistenceServiceImpl::isRootXpath);
 
@@ -291,47 +273,37 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
                 log.warn("Error parsing xpath \"{}\": {}", xpath, e.getMessage());
             }
         }
-        final Collection<FragmentEntity> fragmentEntities =
-            new HashSet<>(fragmentRepository.findByAnchorAndMultipleCpsPaths(anchorEntity.getId(), normalizedXpaths));
-
         if (haveRootXpath) {
-            final List<FragmentExtract> fragmentExtracts = fragmentRepository.getTopLevelFragments(dataspaceEntity,
-                anchorEntity);
-            fragmentEntities.addAll(FragmentEntityArranger.toFragmentEntityTrees(anchorEntity, fragmentExtracts));
+            normalizedXpaths.addAll(fragmentRepository.findAllXpathByAnchorAndParentIdIsNull(anchorEntity));
         }
 
-        return fragmentEntities;
+        final List<FragmentExtract> fragmentExtracts =
+            fragmentRepository.findExtractsWithDescendants(anchorEntity.getId(), normalizedXpaths,
+                fetchDescendantsOption.getDepth());
+
+        return FragmentEntityArranger.toFragmentEntityTrees(anchorEntity, fragmentExtracts);
     }
 
-    private FragmentEntity getFragmentEntity(final String dataspaceName, final String anchorName, final String xpath) {
-        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
-        final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
+    private FragmentEntity getFragmentEntity(final AnchorEntity anchorEntity, final String xpath) {
         final FragmentEntity fragmentEntity;
         if (isRootXpath(xpath)) {
-            final List<FragmentExtract> fragmentExtracts = fragmentRepository.getTopLevelFragments(dataspaceEntity,
-                    anchorEntity);
+            final List<FragmentExtract> fragmentExtracts = fragmentRepository.findAllExtractsByAnchor(anchorEntity);
             fragmentEntity = FragmentEntityArranger.toFragmentEntityTrees(anchorEntity, fragmentExtracts)
                 .stream().findFirst().orElse(null);
         } else {
-            final String normalizedXpath = getNormalizedXpath(xpath);
-            fragmentEntity =
-                fragmentRepository.getByDataspaceAndAnchorAndXpath(dataspaceEntity, anchorEntity, normalizedXpath);
+            fragmentEntity = fragmentRepository.getByAnchorAndXpath(anchorEntity, getNormalizedXpath(xpath));
         }
         if (fragmentEntity == null) {
-            throw new DataNodeNotFoundException(dataspaceEntity.getName(), anchorEntity.getName(), xpath);
+            throw new DataNodeNotFoundException(anchorEntity.getDataspace().getName(), anchorEntity.getName(), xpath);
         }
         return fragmentEntity;
-
     }
 
     private Collection<FragmentEntity> buildFragmentEntitiesFromFragmentExtracts(final AnchorEntity anchorEntity,
                                                                                  final String normalizedXpath) {
         final List<FragmentExtract> fragmentExtracts =
-                fragmentRepository.findByAnchorIdAndParentXpath(anchorEntity.getId(), normalizedXpath);
-        log.debug("Fetched {} fragment entities by anchor {} and cps path {}.",
-                fragmentExtracts.size(), anchorEntity.getName(), normalizedXpath);
+            fragmentRepository.findByAnchorAndParentXpath(anchorEntity, normalizedXpath);
         return FragmentEntityArranger.toFragmentEntityTrees(anchorEntity, fragmentExtracts);
-
     }
 
     @Override
@@ -339,8 +311,8 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
             description = "Time taken to query data nodes")
     public List<DataNode> queryDataNodes(final String dataspaceName, final String anchorName, final String cpsPath,
                                          final FetchDescendantsOption fetchDescendantsOption) {
-        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
-        final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
+        final AnchorEntity anchorEntity = (Strings.isNullOrEmpty(anchorName)) ? ALL_ANCHORS
+                : getAnchorEntity(dataspaceName, anchorName);
         final CpsPathQuery cpsPathQuery;
         try {
             cpsPathQuery = CpsPathUtil.getCpsPathQuery(cpsPath);
@@ -352,40 +324,47 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
         if (canUseRegexQuickFind(fetchDescendantsOption, cpsPathQuery)) {
             return getDataNodesUsingRegexQuickFind(fetchDescendantsOption, anchorEntity, cpsPathQuery);
         }
-        fragmentEntities = fragmentRepository.findByAnchorAndCpsPath(anchorEntity.getId(), cpsPathQuery);
+        fragmentEntities = (anchorEntity == ALL_ANCHORS) ? fragmentRepository.findByCpsPath(cpsPathQuery)
+                : fragmentRepository.findByAnchorAndCpsPath(anchorEntity.getId(), cpsPathQuery);
         if (cpsPathQuery.hasAncestorAxis()) {
-            fragmentEntities = getAncestorFragmentEntities(anchorEntity.getId(), cpsPathQuery, fragmentEntities);
+            final Collection<String> ancestorXpaths = processAncestorXpath(fragmentEntities, cpsPathQuery);
+            fragmentEntities = (anchorEntity == ALL_ANCHORS) ? getAncestorFragmentEntitiesAcrossAnchors(cpsPathQuery,
+            fragmentEntities) : getFragmentEntities(anchorEntity, ancestorXpaths, fetchDescendantsOption);
         }
         return createDataNodesFromProxiedFragmentEntities(fetchDescendantsOption, anchorEntity, fragmentEntities);
     }
 
+    @Override
+    public List<DataNode> queryDataNodesAcrossAnchors(final String dataspaceName, final String cpsPath,
+                                         final FetchDescendantsOption fetchDescendantsOption) {
+        return queryDataNodes(dataspaceName, QUERY_ACROSS_ANCHORS, cpsPath, fetchDescendantsOption);
+    }
+
     private static boolean canUseRegexQuickFind(final FetchDescendantsOption fetchDescendantsOption,
                                                 final CpsPathQuery cpsPathQuery) {
         return fetchDescendantsOption.equals(FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS)
+            && !cpsPathQuery.hasAncestorAxis()
             && !cpsPathQuery.hasLeafConditions()
-            && !cpsPathQuery.hasTextFunctionCondition();
+            && !cpsPathQuery.hasTextFunctionCondition()
+            && !cpsPathQuery.hasContainsFunctionCondition();
     }
 
     private List<DataNode> getDataNodesUsingRegexQuickFind(final FetchDescendantsOption fetchDescendantsOption,
                                                            final AnchorEntity anchorEntity,
                                                            final CpsPathQuery cpsPathQuery) {
-        Collection<FragmentEntity> fragmentEntities;
-        final String xpathRegex = FragmentQueryBuilder.getXpathSqlRegex(cpsPathQuery, true);
-        final List<FragmentExtract> fragmentExtracts =
-            fragmentRepository.quickFindWithDescendants(anchorEntity.getId(), xpathRegex);
-        fragmentEntities = FragmentEntityArranger.toFragmentEntityTrees(anchorEntity, fragmentExtracts);
-        if (cpsPathQuery.hasAncestorAxis()) {
-            fragmentEntities = getAncestorFragmentEntities(anchorEntity.getId(), cpsPathQuery, fragmentEntities);
-        }
+        final String xpathRegex = FragmentQueryBuilder.getXpathSqlRegexForQuickFindWithDescendants(cpsPathQuery);
+        final List<FragmentExtract> fragmentExtracts = (anchorEntity == ALL_ANCHORS)
+            ? fragmentRepository.quickFindWithDescendantsAcrossAnchors(xpathRegex)
+            : fragmentRepository.quickFindWithDescendants(anchorEntity.getId(), xpathRegex);
+        final Collection<FragmentEntity> fragmentEntities =
+            FragmentEntityArranger.toFragmentEntityTrees(anchorEntity, fragmentExtracts);
         return createDataNodesFromFragmentEntities(fetchDescendantsOption, fragmentEntities);
     }
 
-    private Collection<FragmentEntity> getAncestorFragmentEntities(final int anchorId,
-                                                                   final CpsPathQuery cpsPathQuery,
-                                                                   final Collection<FragmentEntity> fragmentEntities) {
+    private Collection<FragmentEntity> getAncestorFragmentEntitiesAcrossAnchors(final CpsPathQuery cpsPathQuery,
+        final Collection<FragmentEntity> fragmentEntities) {
         final Collection<String> ancestorXpaths = processAncestorXpath(fragmentEntities, cpsPathQuery);
-        return ancestorXpaths.isEmpty() ? Collections.emptyList()
-            : fragmentRepository.findByAnchorAndMultipleCpsPaths(anchorId, ancestorXpaths);
+        return ancestorXpaths.isEmpty() ? Collections.emptyList() : fragmentRepository.findAllByXpathIn(ancestorXpaths);
     }
 
     private List<DataNode> createDataNodesFromProxiedFragmentEntities(
@@ -398,8 +377,10 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
                 dataNodes.add(toDataNode(proxiedFragmentEntity, fetchDescendantsOption));
             } else {
                 final String normalizedXpath = getNormalizedXpath(proxiedFragmentEntity.getXpath());
+                final AnchorEntity anchorEntityForFragmentExtract = (anchorEntity == ALL_ANCHORS)
+                        ? proxiedFragmentEntity.getAnchor() : anchorEntity;
                 final Collection<FragmentEntity> unproxiedFragmentEntities =
-                    buildFragmentEntitiesFromFragmentExtracts(anchorEntity, normalizedXpath);
+                    buildFragmentEntitiesFromFragmentExtracts(anchorEntityForFragmentExtract, normalizedXpath);
                 for (final FragmentEntity unproxiedFragmentEntity : unproxiedFragmentEntities) {
                     dataNodes.add(toDataNode(unproxiedFragmentEntity, fetchDescendantsOption));
                 }
@@ -418,13 +399,14 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     }
 
     private static String getNormalizedXpath(final String xpathSource) {
-        final String normalizedXpath;
+        if (isRootXpath(xpathSource)) {
+            return xpathSource;
+        }
         try {
-            normalizedXpath = CpsPathUtil.getNormalizedXpath(xpathSource);
+            return CpsPathUtil.getNormalizedXpath(xpathSource);
         } catch (final PathParsingException e) {
             throw new CpsPathException(e.getMessage());
         }
-        return normalizedXpath;
     }
 
     @Override
@@ -447,8 +429,8 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
                                                     final CpsPathQuery cpsPathQuery) {
         final Set<String> ancestorXpath = new HashSet<>();
         final Pattern pattern =
-                Pattern.compile("([\\s\\S]*\\/" + Pattern.quote(cpsPathQuery.getAncestorSchemaNodeIdentifier())
-                        + REG_EX_FOR_OPTIONAL_LIST_INDEX + "\\/[\\s\\S]*");
+                Pattern.compile("(.*/" + Pattern.quote(cpsPathQuery.getAncestorSchemaNodeIdentifier())
+                        + REG_EX_FOR_OPTIONAL_LIST_INDEX + "/.*");
         for (final FragmentEntity fragmentEntity : fragmentEntities) {
             final Matcher matcher = pattern.matcher(fragmentEntity.getXpath());
             if (matcher.matches()) {
@@ -468,6 +450,8 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
         return new DataNodeBuilder()
                 .withXpath(fragmentEntity.getXpath())
                 .withLeaves(leaves)
+                .withDataspace(fragmentEntity.getAnchor().getDataspace().getName())
+                .withAnchor(fragmentEntity.getAnchor().getName())
                 .withChildDataNodes(childDataNodes).build();
     }
 
@@ -493,36 +477,25 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     @Override
     public void updateDataLeaves(final String dataspaceName, final String anchorName, final String xpath,
                                  final Map<String, Serializable> updateLeaves) {
-        final FragmentEntity fragmentEntity = getFragmentEntity(dataspaceName, anchorName, xpath);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+        final FragmentEntity fragmentEntity = getFragmentEntity(anchorEntity, xpath);
         final String currentLeavesAsString = fragmentEntity.getAttributes();
         final String mergedLeaves = mergeLeaves(updateLeaves, currentLeavesAsString);
         fragmentEntity.setAttributes(mergedLeaves);
         fragmentRepository.save(fragmentEntity);
     }
 
-    @Override
-    public void updateDataNodeAndDescendants(final String dataspaceName, final String anchorName,
-                                             final DataNode dataNode) {
-        final FragmentEntity fragmentEntity = getFragmentEntity(dataspaceName, anchorName, dataNode.getXpath());
-        updateFragmentEntityAndDescendantsWithDataNode(fragmentEntity, dataNode);
-        try {
-            fragmentRepository.save(fragmentEntity);
-        } catch (final StaleStateException staleStateException) {
-            throw new ConcurrencyException("Concurrent Transactions",
-                    String.format("dataspace :'%s', Anchor : '%s' and xpath: '%s' is updated by another transaction.",
-                            dataspaceName, anchorName, dataNode.getXpath()));
-        }
-    }
-
     @Override
     public void updateDataNodesAndDescendants(final String dataspaceName, final String anchorName,
-                                              final List<DataNode> updatedDataNodes) {
+                                              final Collection<DataNode> updatedDataNodes) {
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+
         final Map<String, DataNode> xpathToUpdatedDataNode = updatedDataNodes.stream()
             .collect(Collectors.toMap(DataNode::getXpath, dataNode -> dataNode));
 
         final Collection<String> xpaths = xpathToUpdatedDataNode.keySet();
         final Collection<FragmentEntity> existingFragmentEntities =
-            getFragmentEntities(dataspaceName, anchorName, xpaths);
+            getFragmentEntities(anchorEntity, xpaths, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS);
 
         for (final FragmentEntity existingFragmentEntity : existingFragmentEntities) {
             final DataNode updatedDataNode = xpathToUpdatedDataNode.get(existingFragmentEntity.getXpath());
@@ -532,45 +505,41 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
         try {
             fragmentRepository.saveAll(existingFragmentEntities);
         } catch (final StaleStateException staleStateException) {
-            retryUpdateDataNodesIndividually(dataspaceName, anchorName, existingFragmentEntities);
+            retryUpdateDataNodesIndividually(anchorEntity, existingFragmentEntities);
         }
     }
 
-    private void retryUpdateDataNodesIndividually(final String dataspaceName, final String anchorName,
+    private void retryUpdateDataNodesIndividually(final AnchorEntity anchorEntity,
                                                   final Collection<FragmentEntity> fragmentEntities) {
         final Collection<String> failedXpaths = new HashSet<>();
-
-        fragmentEntities.forEach(dataNodeFragment -> {
+        for (final FragmentEntity dataNodeFragment : fragmentEntities) {
             try {
                 fragmentRepository.save(dataNodeFragment);
             } catch (final StaleStateException e) {
                 failedXpaths.add(dataNodeFragment.getXpath());
             }
-        });
-
+        }
         if (!failedXpaths.isEmpty()) {
             final String failedXpathsConcatenated = String.join(",", failedXpaths);
             throw new ConcurrencyException("Concurrent Transactions", String.format(
                     "DataNodes : %s in Dataspace :'%s' with Anchor : '%s'  are updated by another transaction.",
-                    failedXpathsConcatenated, dataspaceName, anchorName));
+                    failedXpathsConcatenated, anchorEntity.getDataspace().getName(), anchorEntity.getName()));
         }
     }
 
     private void updateFragmentEntityAndDescendantsWithDataNode(final FragmentEntity existingFragmentEntity,
                                                                 final DataNode newDataNode) {
-
         existingFragmentEntity.setAttributes(jsonObjectMapper.asJsonString(newDataNode.getLeaves()));
 
         final Map<String, FragmentEntity> existingChildrenByXpath = existingFragmentEntity.getChildFragments().stream()
                 .collect(Collectors.toMap(FragmentEntity::getXpath, childFragmentEntity -> childFragmentEntity));
 
         final Collection<FragmentEntity> updatedChildFragments = new HashSet<>();
-
         for (final DataNode newDataNodeChild : newDataNode.getChildDataNodes()) {
             final FragmentEntity childFragment;
             if (isNewDataNode(newDataNodeChild, existingChildrenByXpath)) {
-                childFragment = convertToFragmentWithAllDescendants(
-                        existingFragmentEntity.getDataspace(), existingFragmentEntity.getAnchor(), newDataNodeChild);
+                childFragment = convertToFragmentWithAllDescendants(existingFragmentEntity.getAnchor(),
+                    newDataNodeChild);
             } else {
                 childFragment = existingChildrenByXpath.get(newDataNodeChild.getXpath());
                 updateFragmentEntityAndDescendantsWithDataNode(childFragment, newDataNodeChild);
@@ -586,18 +555,18 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     @Transactional
     public void replaceListContent(final String dataspaceName, final String anchorName, final String parentNodeXpath,
                                    final Collection<DataNode> newListElements) {
-        final FragmentEntity parentEntity = getFragmentEntity(dataspaceName, anchorName, parentNodeXpath);
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
+        final FragmentEntity parentEntity = getFragmentEntity(anchorEntity, parentNodeXpath);
         final String listElementXpathPrefix = getListElementXpathPrefix(newListElements);
         final Map<String, FragmentEntity> existingListElementFragmentEntitiesByXPath =
                 extractListElementFragmentEntitiesByXPath(parentEntity.getChildFragments(), listElementXpathPrefix);
-        deleteListElements(parentEntity.getChildFragments(), existingListElementFragmentEntitiesByXPath);
+        parentEntity.getChildFragments().removeAll(existingListElementFragmentEntitiesByXPath.values());
         final Set<FragmentEntity> updatedChildFragmentEntities = new HashSet<>();
         for (final DataNode newListElement : newListElements) {
             final FragmentEntity existingListElementEntity =
                     existingListElementFragmentEntitiesByXPath.get(newListElement.getXpath());
             final FragmentEntity entityToBeAdded = getFragmentForReplacement(parentEntity, newListElement,
                     existingListElementEntity);
-
             updatedChildFragmentEntities.add(entityToBeAdded);
         }
         parentEntity.getChildFragments().addAll(updatedChildFragmentEntities);
@@ -609,8 +578,7 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     public void deleteDataNodes(final String dataspaceName, final String anchorName) {
         final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
         anchorRepository.findByDataspaceAndName(dataspaceEntity, anchorName)
-                .ifPresent(
-                        anchorEntity -> fragmentRepository.deleteByAnchorIn(Set.of(anchorEntity)));
+            .ifPresent(anchorEntity -> fragmentRepository.deleteByAnchorIn(Collections.singletonList(anchorEntity)));
     }
 
     @Override
@@ -626,21 +594,37 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
     @Transactional
     public void deleteDataNodes(final String dataspaceName, final String anchorName,
                                 final Collection<String> xpathsToDelete) {
-        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
-        final AnchorEntity anchorEntity = anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
+        deleteDataNodes(dataspaceName, anchorName, xpathsToDelete, false);
+    }
+
+    private void deleteDataNodes(final String dataspaceName, final String anchorName,
+                                 final Collection<String> xpathsToDelete, final boolean onlySupportListDeletion) {
+        final boolean haveRootXpath = xpathsToDelete.stream().anyMatch(CpsDataPersistenceServiceImpl::isRootXpath);
+        if (haveRootXpath) {
+            deleteDataNodes(dataspaceName, anchorName);
+            return;
+        }
+
+        final AnchorEntity anchorEntity = getAnchorEntity(dataspaceName, anchorName);
 
         final Collection<String> deleteChecklist = new HashSet<>(xpathsToDelete.size());
         for (final String xpath : xpathsToDelete) {
             try {
                 deleteChecklist.add(CpsPathUtil.getNormalizedXpath(xpath));
             } catch (final PathParsingException e) {
-                log.debug("Error parsing xpath \"{}\": {}", xpath, e.getMessage());
+                log.warn("Error parsing xpath \"{}\": {}", xpath, e.getMessage());
             }
         }
 
         final Collection<String> xpathsToExistingContainers =
             fragmentRepository.findAllXpathByAnchorAndXpathIn(anchorEntity, deleteChecklist);
-        deleteChecklist.removeAll(xpathsToExistingContainers);
+        if (onlySupportListDeletion) {
+            final Collection<String> xpathsToExistingListElements = xpathsToExistingContainers.stream()
+                .filter(CpsPathUtil::isPathToListElement).collect(Collectors.toList());
+            deleteChecklist.removeAll(xpathsToExistingListElements);
+        } else {
+            deleteChecklist.removeAll(xpathsToExistingContainers);
+        }
 
         final Collection<String> xpathsToExistingLists = deleteChecklist.stream()
             .filter(xpath -> fragmentRepository.existsByAnchorAndXpathStartsWith(anchorEntity, xpath + "["))
@@ -670,66 +654,13 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
 
     private void deleteDataNode(final String dataspaceName, final String anchorName, final String targetXpath,
                                 final boolean onlySupportListNodeDeletion) {
-        final String parentNodeXpath;
-        FragmentEntity parentFragmentEntity = null;
-        boolean targetDeleted;
-        if (isRootXpath(targetXpath)) {
-            deleteDataNodes(dataspaceName, anchorName);
-            targetDeleted = true;
-        } else {
-            if (isRootContainerNodeXpath(targetXpath)) {
-                parentNodeXpath = targetXpath;
-            } else {
-                parentNodeXpath = CpsPathUtil.getNormalizedParentXpath(targetXpath);
-            }
-            parentFragmentEntity = getFragmentEntity(dataspaceName, anchorName, parentNodeXpath);
-            if (CpsPathUtil.isPathToListElement(targetXpath)) {
-                targetDeleted = deleteDataNode(parentFragmentEntity, targetXpath);
-            } else {
-                targetDeleted = deleteAllListElements(parentFragmentEntity, targetXpath);
-                final boolean tryToDeleteDataNode = !targetDeleted && !onlySupportListNodeDeletion;
-                if (tryToDeleteDataNode) {
-                    targetDeleted = deleteDataNode(parentFragmentEntity, targetXpath);
-                }
-            }
-        }
-        if (!targetDeleted) {
-            final String additionalInformation = onlySupportListNodeDeletion
-                    ? "The target is probably not a List." : "";
-            throw new DataNodeNotFoundException(parentFragmentEntity.getDataspace().getName(),
-                    parentFragmentEntity.getAnchor().getName(), targetXpath, additionalInformation);
-        }
-    }
-
-    private boolean deleteDataNode(final FragmentEntity parentFragmentEntity, final String targetXpath) {
-        final String normalizedTargetXpath = CpsPathUtil.getNormalizedXpath(targetXpath);
-        if (parentFragmentEntity.getXpath().equals(normalizedTargetXpath)) {
-            fragmentRepository.deleteFragmentEntity(parentFragmentEntity.getId());
-            return true;
-        }
-        if (parentFragmentEntity.getChildFragments()
-                .removeIf(fragment -> fragment.getXpath().equals(normalizedTargetXpath))) {
-            fragmentRepository.save(parentFragmentEntity);
-            return true;
-        }
-        return false;
-    }
-
-    private boolean deleteAllListElements(final FragmentEntity parentFragmentEntity, final String listXpath) {
-        final String normalizedListXpath = CpsPathUtil.getNormalizedXpath(listXpath);
-        final String deleteTargetXpathPrefix = normalizedListXpath + "[";
-        if (parentFragmentEntity.getChildFragments()
-                .removeIf(fragment -> fragment.getXpath().startsWith(deleteTargetXpathPrefix))) {
-            fragmentRepository.save(parentFragmentEntity);
-            return true;
+        final String normalizedXpath = getNormalizedXpath(targetXpath);
+        try {
+            deleteDataNodes(dataspaceName, anchorName, Collections.singletonList(normalizedXpath),
+                onlySupportListNodeDeletion);
+        } catch (final DataNodeNotFoundExceptionBatch dataNodeNotFoundExceptionBatch) {
+            throw new DataNodeNotFoundException(dataspaceName, anchorName, targetXpath);
         }
-        return false;
-    }
-
-    private static void deleteListElements(
-            final Collection<FragmentEntity> fragmentEntities,
-            final Map<String, FragmentEntity> existingListElementFragmentEntitiesByXPath) {
-        fragmentEntities.removeAll(existingListElementFragmentEntitiesByXPath.values());
     }
 
     private static String getListElementXpathPrefix(final Collection<DataNode> newListElements) {
@@ -745,8 +676,7 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
                                                      final DataNode newListElement,
                                                      final FragmentEntity existingListElementEntity) {
         if (existingListElementEntity == null) {
-            return convertToFragmentWithAllDescendants(
-                    parentEntity.getDataspace(), parentEntity.getAnchor(), newListElement);
+            return convertToFragmentWithAllDescendants(parentEntity.getAnchor(), newListElement);
         }
         if (newListElement.getChildDataNodes().isEmpty()) {
             copyAttributesFromNewListElement(existingListElementEntity, newListElement);
@@ -762,10 +692,6 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
         return !existingListElementsByXpath.containsKey(replacementDataNode.getXpath());
     }
 
-    private static boolean isRootContainerNodeXpath(final String xpath) {
-        return 0 == xpath.lastIndexOf('/');
-    }
-
     private void copyAttributesFromNewListElement(final FragmentEntity existingListElementEntity,
                                                   final DataNode newListElement) {
         final FragmentEntity replacementFragmentEntity =
@@ -794,4 +720,9 @@ public class CpsDataPersistenceServiceImpl implements CpsDataPersistenceService
         }
         return jsonObjectMapper.asJsonString(currentLeavesAsMap);
     }
+
+    private AnchorEntity getAnchorEntity(final String dataspaceName, final String anchorName) {
+        final DataspaceEntity dataspaceEntity = dataspaceRepository.getByName(dataspaceName);
+        return anchorRepository.getByDataspaceAndName(dataspaceEntity, anchorName);
+    }
 }