logic: Improved performance of depending file path retrieval for refresh

src/lib/data/PersistentStorage.cpp

@@ -1148,28 +1148,31 @@ FilePath PersistentStorage::getFileNodePath(Id fileId) const
 std::set<FilePath> PersistentStorage::getDependingFilePathsForIncludes(const std::set<FilePath>& filePaths)
 {
 	std::set<FilePath> dependingFilePaths;
-	for (const FilePath& filePath: filePaths)
+	std::set<Id> processedFileNodeIds;
+
+	std::vector<Id> fileNodeIds;
+	for (const FilePath& filePath : filePaths)
 	{
-		std::set<FilePath> dependingFilePathsSubset = getDependingFilePathsForIncludes(filePath);
+		fileNodeIds.push_back(getFileNodeId(filePath));
-		dependingFilePaths.insert(dependingFilePathsSubset.begin(), dependingFilePathsSubset.end());
 	}
-	return dependingFilePaths;
-}
 
-std::set<FilePath> PersistentStorage::getDependingFilePathsForIncludes(const FilePath& filePath)
+	while (fileNodeIds.size())
-{
-	std::set<FilePath> dependingFilePaths;
-
-	std::vector<StorageEdge> incomingEdges = m_sqliteStorage.getEdgesByTargetType(
-		getFileNodeId(filePath), Edge::typeToInt(Edge::EDGE_INCLUDE)
-	);
-	for (const StorageEdge& incomingEdge: incomingEdges)
 	{
-		FilePath dependingFilePath = getFileNodePath(incomingEdge.sourceNodeId);
+		std::vector<StorageEdge> incomingEdges =
-		dependingFilePaths.insert(dependingFilePath);
+			m_sqliteStorage.getEdgesByTargetType(fileNodeIds, Edge::typeToInt(Edge::EDGE_INCLUDE));
 
-		std::set<FilePath> dependingFilePathsSubset = getDependingFilePathsForIncludes(dependingFilePath);
+		processedFileNodeIds.insert(fileNodeIds.begin(), fileNodeIds.end());
-		dependingFilePaths.insert(dependingFilePathsSubset.begin(), dependingFilePathsSubset.end());
+		fileNodeIds.clear();
+
+		for (const StorageEdge& incomingEdge: incomingEdges)
+		{
+			dependingFilePaths.insert(getFileNodePath(incomingEdge.sourceNodeId));
+
+			if (processedFileNodeIds.find(incomingEdge.sourceNodeId) == processedFileNodeIds.end())
+			{
+				fileNodeIds.push_back(incomingEdge.sourceNodeId);
+			}
+		}
 	}
 
 	return dependingFilePaths;
@@ -1179,11 +1182,29 @@ std::set<FilePath> PersistentStorage::getDependingFilePathsForImports(const std:
 {
 	std::map<Id, std::set<Id>> fileIdToDependingFileIds;
 
-	for (const StorageEdge& importEdge: m_sqliteStorage.getEdgesByType(Edge::typeToInt(Edge::EDGE_IMPORT)))
+	std::multimap<Id, Id> importEdgeTargetIdToSourceIds;
+	std::vector<Id> importedTargetIds;
+
+	for (const StorageEdge& importEdge : m_sqliteStorage.getEdgesByType(Edge::typeToInt(Edge::EDGE_IMPORT)))
 	{
-		for (const StorageSourceLocation& importedElementLoc: m_sqliteStorage.getSourceLocationsForElementId(importEdge.targetNodeId))
+		importedTargetIds.push_back(importEdge.targetNodeId);
+		importEdgeTargetIdToSourceIds.emplace(importEdge.targetNodeId, importEdge.sourceNodeId);
+	}
+
+	if (!importedTargetIds.size())
+	{
+		return std::set<FilePath>();
+	}
+
+	for (const std::pair<StorageSourceLocation, Id>& p :
+		m_sqliteStorage.getSourceLocationsAndElementIdsForElementIds(importedTargetIds))
+	{
+		std::pair <std::multimap<Id, Id>::const_iterator, std::multimap<Id, Id>::const_iterator> ret =
+			importEdgeTargetIdToSourceIds.equal_range(p.second);
+
+		for (std::multimap<Id, Id>::const_iterator it = ret.first; it != ret.second; it++)
 		{
-			fileIdToDependingFileIds[importedElementLoc.fileNodeId].insert(importEdge.sourceNodeId);
+			fileIdToDependingFileIds[p.first.fileNodeId].insert(it->second);
 		}
 	}
 
@@ -1205,10 +1226,8 @@ std::set<FilePath> PersistentStorage::getDependingFilePathsForImports(const std:
 			{
 				for (Id dependingFileNodeId: it->second)
 				{
-					const size_t countBeforeInsert = dependingFileNodeIds.size();
+					bool inserted = dependingFileNodeIds.insert(dependingFileNodeId).second;
-					dependingFileNodeIds.insert(dependingFileNodeId);
+					if (inserted)
-					const size_t countAfterInsert = dependingFileNodeIds.size();
-					if (countBeforeInsert != countAfterInsert)
 					{
 						tempWorking.insert(dependingFileNodeId);
 					}

src/lib/data/PersistentStorage.h

@@ -127,7 +127,6 @@ private:
 	FilePath getFileNodePath(Id fileId) const;
 
 	std::set<FilePath> getDependingFilePathsForIncludes(const std::set<FilePath>& filePaths);
-	std::set<FilePath> getDependingFilePathsForIncludes(const FilePath& filePath);
 	std::set<FilePath> getDependingFilePathsForImports(const std::set<FilePath>& filePaths);
 
 	Id getLastVisibleParentNodeId(const Id nodeId) const;

src/lib/data/SqliteStorage.cpp

@@ -514,6 +514,11 @@ std::vector<StorageEdge> SqliteStorage::getEdgesByTargetType(Id targetId, int ty
 	return getAll<StorageEdge>("WHERE target_node_id == " + std::to_string(targetId) + " AND type == " + std::to_string(type));
 }
 
+std::vector<StorageEdge> SqliteStorage::getEdgesByTargetType(const std::vector<Id>& targetIds, int type) const
+{
+	return getAll<StorageEdge>("WHERE target_node_id IN (" + utility::join(utility::toStrings(targetIds), ',') + ") AND type == " + std::to_string(type));
+}
+
 StorageNode SqliteStorage::getNodeById(Id id) const
 {
 	if (id != 0)

src/lib/data/SqliteStorage.h

@@ -86,6 +86,7 @@ public:
 	std::vector<StorageEdge> getEdgesByType(int type) const;
 	std::vector<StorageEdge> getEdgesBySourceType(Id sourceId, int type) const;
 	std::vector<StorageEdge> getEdgesByTargetType(Id targetId, int type) const;
+	std::vector<StorageEdge> getEdgesByTargetType(const std::vector<Id>& targetIds, int type) const;
 
 	StorageNode getNodeById(Id id) const;
 	StorageNode getNodeBySerializedName(const std::string& serializedName) const;