Merge pull request #26264 from nextcloud/unified-search-node-19

[stable19] Handle limit offset and sorting in files search
2021-04-01 18:17:50 +02:00 · 2021-04-01 18:17:50 +02:00 · 2814fc6442
parent d6889a7139 9c046efd2d
commit 2814fc6442
9 changed files with 417 additions and 210 deletions
--- a/lib/private/Files/Cache/Cache.php
+++ b/lib/private/Files/Cache/Cache.php
@ -188,10 +188,10 @@ class Cache implements ICache {
 		}
 		$data['permissions'] = (int)$data['permissions'];
 		if (isset($data['creation_time'])) {
-			$data['creation_time'] = (int) $data['creation_time'];
+			$data['creation_time'] = (int)$data['creation_time'];
 		}
 		if (isset($data['upload_time'])) {
-			$data['upload_time'] = (int) $data['upload_time'];
+			$data['upload_time'] = (int)$data['upload_time'];
 		}
 		return new CacheEntry($data);
 	}
@ -792,6 +792,10 @@ class Cache implements ICache {
 		$query->whereStorageId();

 		if ($this->querySearchHelper->shouldJoinTags($searchQuery->getSearchOperation())) {
+			$user = $searchQuery->getUser();
+			if ($user === null) {
+				throw new \InvalidArgumentException("Searching by tag requires the user to be set in the query");
+			}
 			$query
 				->innerJoin('file', 'vcategory_to_object', 'tagmap', $builder->expr()->eq('file.fileid', 'tagmap.objid'))
 				->innerJoin('tagmap', 'vcategory', 'tag', $builder->expr()->andX(
@ -799,7 +803,7 @@ class Cache implements ICache {
 					$builder->expr()->eq('tagmap.categoryid', 'tag.id')
 				))
 				->andWhere($builder->expr()->eq('tag.type', $builder->createNamedParameter('files')))
-				->andWhere($builder->expr()->eq('tag.uid', $builder->createNamedParameter($searchQuery->getUser()->getUID())));
+				->andWhere($builder->expr()->eq('tag.uid', $builder->createNamedParameter($user->getUID())));
 		}

 		$searchExpr = $this->querySearchHelper->searchOperatorToDBExpr($builder, $searchQuery->getSearchOperation());
--- a/lib/private/Files/Node/Folder.php
+++ b/lib/private/Files/Node/Folder.php
@ -31,14 +31,23 @@
 namespace OC\Files\Node;

 use OC\DB\QueryBuilder\Literal;
+use OC\Files\Search\SearchBinaryOperator;
+use OC\Files\Search\SearchComparison;
+use OC\Files\Search\SearchQuery;
+use OC\Files\Storage\Storage;
 use OCA\Files_Sharing\SharedStorage;
 use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\Files\Cache\ICacheEntry;
 use OCP\Files\Config\ICachedMountInfo;
 use OCP\Files\FileInfo;
 use OCP\Files\Mount\IMountPoint;
 use OCP\Files\NotFoundException;
 use OCP\Files\NotPermittedException;
+use OCP\Files\Search\ISearchBinaryOperator;
+use OCP\Files\Search\ISearchComparison;
+use OCP\Files\Search\ISearchOperator;
 use OCP\Files\Search\ISearchQuery;
+use OCP\IUserManager;

 class Folder extends Node implements \OCP\Files\Folder {
 	/**
@ -94,8 +103,8 @@ class Folder extends Node implements \OCP\Files\Folder {
 	/**
 	 * get the content of this directory
 	 *
-	 * @throws \OCP\Files\NotFoundException
 	 * @return Node[]
+	 * @throws \OCP\Files\NotFoundException
 	 */
 	public function getDirectoryListing() {
 		$folderContent = $this->view->getDirectoryContent($this->path);
@ -198,6 +207,17 @@ class Folder extends Node implements \OCP\Files\Folder {
 		throw new NotPermittedException('No create permission for path');
 	}

+	private function queryFromOperator(ISearchOperator $operator, string $uid = null): ISearchQuery {
+		if ($uid === null) {
+			$user = null;
+		} else {
+			/** @var IUserManager $userManager */
+			$userManager = \OC::$server->query(IUserManager::class);
+			$user = $userManager->get($uid);
+		}
+		return new SearchQuery($operator, 0, 0, [], $user);
+	}
+
 	/**
 	 * search for files with the name matching $query
 	 *
@ -206,10 +226,106 @@ class Folder extends Node implements \OCP\Files\Folder {
 	 */
 	public function search($query) {
 		if (is_string($query)) {
-			return $this->searchCommon('search', ['%' . $query . '%']);
-		} else {
-			return $this->searchCommon('searchQuery', [$query]);
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
 		}
+
+		// Limit+offset for queries with ordering
+		//
+		// Because we currently can't do ordering between the results from different storages in sql
+		// The only way to do ordering is requesting the $limit number of entries from all storages
+		// sorting them and returning the first $limit entries.
+		//
+		// For offset we have the same problem, we don't know how many entries from each storage should be skipped
+		// by a given $offset, so instead we query $offset + $limit from each storage and return entries $offset..($offset+$limit)
+		// after merging and sorting them.
+		//
+		// This is suboptimal but because limit and offset tend to be fairly small in real world use cases it should
+		// still be significantly better than disabling paging altogether
+
+		$limitToHome = $query->limitToHome();
+		if ($limitToHome && count(explode('/', $this->path)) !== 3) {
+			throw new \InvalidArgumentException('searching by owner is only allows on the users home folder');
+		}
+
+		$rootLength = strlen($this->path);
+		$mount = $this->root->getMount($this->path);
+		$storage = $mount->getStorage();
+		$internalPath = $mount->getInternalPath($this->path);
+		$internalPath = rtrim($internalPath, '/');
+		if ($internalPath !== '') {
+			$internalPath = $internalPath . '/';
+		}
+
+		$subQueryLimit = $query->getLimit() > 0 ? $query->getLimit() + $query->getOffset() : 0;
+		$rootQuery = new SearchQuery(
+			new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [
+				new SearchComparison(ISearchComparison::COMPARE_LIKE, 'path', $internalPath . '%'),
+				$query->getSearchOperation(),
+			]
+			),
+			$subQueryLimit,
+			0,
+			$query->getOrder(),
+			$query->getUser()
+		);
+
+		$files = [];
+
+		$cache = $storage->getCache('');
+
+		$results = $cache->searchQuery($rootQuery);
+		foreach ($results as $result) {
+			$files[] = $this->cacheEntryToFileInfo($mount, '', $internalPath, $result);
+		}
+
+		if (!$limitToHome) {
+			$mounts = $this->root->getMountsIn($this->path);
+			foreach ($mounts as $mount) {
+				$subQuery = new SearchQuery(
+					$query->getSearchOperation(),
+					$subQueryLimit,
+					0,
+					$query->getOrder(),
+					$query->getUser()
+				);
+
+				$storage = $mount->getStorage();
+				if ($storage) {
+					$cache = $storage->getCache('');
+
+					$relativeMountPoint = ltrim(substr($mount->getMountPoint(), $rootLength), '/');
+					$results = $cache->searchQuery($subQuery);
+					foreach ($results as $result) {
+						$files[] = $this->cacheEntryToFileInfo($mount, $relativeMountPoint, '', $result);
+					}
+				}
+			}
+		}
+
+		$order = $query->getOrder();
+		if ($order) {
+			usort($files, function (FileInfo $a,FileInfo  $b) use ($order) {
+				foreach ($order as $orderField) {
+					$cmp = $orderField->sortFileInfo($a, $b);
+					if ($cmp !== 0) {
+						return $cmp;
+					}
+				}
+				return 0;
+			});
+		}
+		$files = array_values(array_slice($files, $query->getOffset(), $query->getLimit() > 0 ? $query->getLimit() : null));
+
+		return array_map(function (FileInfo $file) {
+			return $this->createNode($file->getPath(), $file);
+		}, $files);
+	}
+
+	private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, string $trimRoot, ICacheEntry $cacheEntry): FileInfo {
+		$trimLength = strlen($trimRoot);
+		$cacheEntry['internalPath'] = $cacheEntry['path'];
+		$cacheEntry['path'] = $appendRoot . substr($cacheEntry['path'], $trimLength);
+		return new \OC\Files\FileInfo($this->path . '/' . $cacheEntry['path'], $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
 	}

 	/**
@ -219,7 +335,12 @@ class Folder extends Node implements \OCP\Files\Folder {
 	 * @return Node[]
 	 */
 	public function searchByMime($mimetype) {
-		return $this->searchCommon('searchByMime', [$mimetype]);
+		if (strpos($mimetype, '/') === false) {
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%'));
+		} else {
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype));
+		}
+		return $this->search($query);
 	}

 	/**
@ -230,66 +351,8 @@ class Folder extends Node implements \OCP\Files\Folder {
 	 * @return Node[]
 	 */
 	public function searchByTag($tag, $userId) {
-		return $this->searchCommon('searchByTag', [$tag, $userId]);
-	}
-
-	/**
-	 * @param string $method cache method
-	 * @param array $args call args
-	 * @return \OC\Files\Node\Node[]
-	 */
-	private function searchCommon($method, $args) {
-		$limitToHome = ($method === 'searchQuery')? $args[0]->limitToHome(): false;
-		if ($limitToHome && count(explode('/', $this->path)) !== 3) {
-			throw new \InvalidArgumentException('searching by owner is only allows on the users home folder');
-		}
-
-		$files = [];
-		$rootLength = strlen($this->path);
-		$mount = $this->root->getMount($this->path);
-		$storage = $mount->getStorage();
-		$internalPath = $mount->getInternalPath($this->path);
-		$internalPath = rtrim($internalPath, '/');
-		if ($internalPath !== '') {
-			$internalPath = $internalPath . '/';
-		}
-		$internalRootLength = strlen($internalPath);
-
-		$cache = $storage->getCache('');
-
-		$results = call_user_func_array([$cache, $method], $args);
-		foreach ($results as $result) {
-			if ($internalRootLength === 0 or substr($result['path'], 0, $internalRootLength) === $internalPath) {
-				$result['internalPath'] = $result['path'];
-				$result['path'] = substr($result['path'], $internalRootLength);
-				$result['storage'] = $storage;
-				$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
-			}
-		}
-
-		if (!$limitToHome) {
-			$mounts = $this->root->getMountsIn($this->path);
-			foreach ($mounts as $mount) {
-				$storage = $mount->getStorage();
-				if ($storage) {
-					$cache = $storage->getCache('');
-
-					$relativeMountPoint = ltrim(substr($mount->getMountPoint(), $rootLength), '/');
-					$results = call_user_func_array([$cache, $method], $args);
-					foreach ($results as $result) {
-						$result['internalPath'] = $result['path'];
-						$result['path'] = $relativeMountPoint . $result['path'];
-						$result['storage'] = $storage;
-						$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage,
-							$result['internalPath'], $result, $mount);
-					}
-				}
-			}
-		}
-
-		return array_map(function (FileInfo $file) {
-			return $this->createNode($file->getPath(), $file);
-		}, $files);
+		$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'tagname', $tag), $userId);
+		return $this->search($query);
 	}

 	/**
@ -318,7 +381,7 @@ class Folder extends Node implements \OCP\Files\Folder {

 		if (count($mountsContainingFile) === 0) {
 			if ($user === $this->getAppDataDirectoryName()) {
-				return $this->getByIdInRootMount((int) $id);
+				return $this->getByIdInRootMount((int)$id);
 			}
 			return [];
 		}
--- a/lib/private/Files/Search/SearchOrder.php
+++ b/lib/private/Files/Search/SearchOrder.php
@ -23,6 +23,7 @@

 namespace OC\Files\Search;

+use OCP\Files\FileInfo;
 use OCP\Files\Search\ISearchOrder;

 class SearchOrder implements ISearchOrder {
@ -55,4 +56,28 @@ class SearchOrder implements ISearchOrder {
 	public function getField() {
 		return $this->field;
 	}
+
+	public function sortFileInfo(FileInfo $a, FileInfo $b): int {
+		$cmp = $this->sortFileInfoNoDirection($a, $b);
+		return $cmp * ($this->direction === ISearchOrder::DIRECTION_ASCENDING ? 1 : -1);
+	}
+
+	private function sortFileInfoNoDirection(FileInfo $a, FileInfo $b): int {
+		switch ($this->field) {
+			case 'name':
+				return $a->getName() <=> $b->getName();
+			case 'mimetype':
+				return $a->getMimetype() <=> $b->getMimetype();
+			case 'mtime':
+				return $a->getMtime() <=> $b->getMtime();
+			case 'size':
+				return $a->getSize() <=> $b->getSize();
+			case 'fileid':
+				return $a->getId() <=> $b->getId();
+			case 'permissions':
+				return $a->getPermissions() <=> $b->getPermissions();
+			default:
+				return 0;
+		}
+	}
 }
--- a/lib/private/Files/Search/SearchQuery.php
+++ b/lib/private/Files/Search/SearchQuery.php
@ -37,7 +37,7 @@ class SearchQuery implements ISearchQuery {
 	private $offset;
 	/** @var  ISearchOrder[] */
 	private $order;
-	/** @var IUser */
+	/** @var ?IUser */
 	private $user;
 	private $limitToHome;

@ -48,7 +48,7 @@ class SearchQuery implements ISearchQuery {
 	 * @param int $limit
 	 * @param int $offset
 	 * @param array $order
-	 * @param IUser $user
+	 * @param ?IUser $user
 	 * @param bool $limitToHome
 	 */
 	public function __construct(
@ -56,7 +56,7 @@ class SearchQuery implements ISearchQuery {
 		int $limit,
 		int $offset,
 		array $order,
-		IUser $user,
+		?IUser $user = null,
 		bool $limitToHome = false
 	) {
 		$this->searchOperation = $searchOperation;
@ -96,7 +96,7 @@ class SearchQuery implements ISearchQuery {
 	}

 	/**
-	 * @return IUser
+	 * @return ?IUser
 	 */
 	public function getUser() {
 		return $this->user;
--- a/lib/private/Search/Provider/File.php
+++ b/lib/private/Search/Provider/File.php
@ -28,7 +28,14 @@

 namespace OC\Search\Provider;

-use OC\Files\Filesystem;
+use OC\Files\Search\SearchComparison;
+use OC\Files\Search\SearchOrder;
+use OC\Files\Search\SearchQuery;
+use OCP\Files\FileInfo;
+use OCP\Files\IRootFolder;
+use OCP\Files\Search\ISearchComparison;
+use OCP\Files\Search\ISearchOrder;
+use OCP\IUserSession;
 use OCP\Search\PagedProvider;

 /**
@ -45,35 +52,38 @@ class File extends PagedProvider {
 	 * @return \OCP\Search\Result[]
 	 */
 	public function search($query, int $limit = null, int $offset = null) {
-		if ($offset === null) {
-			$offset = 0;
+		/** @var IRootFolder $rootFolder */
+		$rootFolder = \OC::$server->query(IRootFolder::class);
+		/** @var IUserSession $userSession */
+		$userSession = \OC::$server->query(IUserSession::class);
+		$user = $userSession->getUser();
+		if (!$user) {
+			return [];
 		}
-		\OC_Util::setupFS();
-		$files = Filesystem::search($query);
+		$userFolder = $rootFolder->getUserFolder($user->getUID());
+		$fileQuery = new SearchQuery(
+			new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'),
+			(int)$limit,
+			(int)$offset,
+			[
+				new SearchOrder(ISearchOrder::DIRECTION_DESCENDING, 'mtime'),
+			],
+			$user
+		);
+		$files = $userFolder->search($fileQuery);
 		$results = [];
-		if ($limit !== null) {
-			$files = array_slice($files, $offset, $offset + $limit);
-		}
 		// edit results
 		foreach ($files as $fileData) {
-			// skip versions
-			if (strpos($fileData['path'], '_versions') === 0) {
-				continue;
-			}
-			// skip top-level folder
-			if ($fileData['name'] === 'files' && $fileData['parent'] === -1) {
-				continue;
-			}
 			// create audio result
-			if ($fileData['mimepart'] === 'audio') {
+			if ($fileData->getMimePart() === 'audio') {
 				$result = new \OC\Search\Result\Audio($fileData);
 			}
 			// create image result
-			elseif ($fileData['mimepart'] === 'image') {
+			elseif ($fileData->getMimePart() === 'image') {
 				$result = new \OC\Search\Result\Image($fileData);
 			}
 			// create folder result
-			elseif ($fileData['mimetype'] === 'httpd/unix-directory') {
+			elseif ($fileData->getMimetype() === FileInfo::MIMETYPE_FOLDER) {
 				$result = new \OC\Search\Result\Folder($fileData);
 			}
 			// or create file result
--- a/lib/private/Search/Result/File.php
+++ b/lib/private/Search/Result/File.php
@ -78,14 +78,13 @@ class File extends \OCP\Search\Result {
 	public function __construct(FileInfo $data) {
 		$path = $this->getRelativePath($data->getPath());

-		$info = pathinfo($path);
 		$this->id = $data->getId();
-		$this->name = $info['basename'];
+		$this->name = $data->getName();
 		$this->link = \OC::$server->getURLGenerator()->linkToRoute(
 			'files.view.index',
 			[
-				'dir' => $info['dirname'],
-				'scrollto' => $info['basename'],
+				'dir' => dirname($path),
+				'scrollto' => $data->getName(),
 			]
 		);
 		$this->permissions = $data->getPermissions();
--- a/lib/public/Files/Search/ISearchOrder.php
+++ b/lib/public/Files/Search/ISearchOrder.php
@ -24,6 +24,8 @@

 namespace OCP\Files\Search;

+use OCP\Files\FileInfo;
+
 /**
 * @since 12.0.0
 */
@ -46,4 +48,14 @@ interface ISearchOrder {
 	 * @since 12.0.0
 	 */
 	public function getField();
+
+	/**
+	 * Apply the sorting on 2 FileInfo objects
+	 *
+	 * @param FileInfo $a
+	 * @param FileInfo $b
+	 * @return int -1 if $a < $b, 0 if $a = $b, 1 if $a > $b (for ascending, reverse for descending)
+	 * @since 22.0.0
+	 */
+	public function sortFileInfo(FileInfo $a, FileInfo $b): int;
 }
--- a/lib/public/Files/Search/ISearchQuery.php
+++ b/lib/public/Files/Search/ISearchQuery.php
@ -62,7 +62,7 @@ interface ISearchQuery {
 	/**
 	 * The user that issued the search
 	 *
-	 * @return IUser
+	 * @return ?IUser
 	 * @since 12.0.0
 	 */
 	public function getUser();
--- a/tests/lib/Files/Node/FolderTest.php
+++ b/tests/lib/Files/Node/FolderTest.php
@ -14,13 +14,20 @@ use OC\Files\Config\CachedMountInfo;
 use OC\Files\FileInfo;
 use OC\Files\Mount\Manager;
 use OC\Files\Mount\MountPoint;
+use OC\Files\Node\Folder;
 use OC\Files\Node\Node;
 use OC\Files\Node\Root;
+use OC\Files\Search\SearchComparison;
+use OC\Files\Search\SearchOrder;
+use OC\Files\Search\SearchQuery;
 use OC\Files\Storage\Temporary;
 use OC\Files\Storage\Wrapper\Jail;
 use OC\Files\View;
 use OCP\Files\Mount\IMountPoint;
 use OCP\Files\NotFoundException;
+use OCP\Files\Search\ISearchComparison;
+use OCP\Files\Search\ISearchOrder;
+use OCP\Files\Search\ISearchQuery;
 use OCP\Files\Storage;

 /**
@ -32,7 +39,7 @@ use OCP\Files\Storage;
 */
 class FolderTest extends NodeTest {
 	protected function createTestNode($root, $view, $path) {
-		return new \OC\Files\Node\Folder($root, $view, $path);
+		return new Folder($root, $view, $path);
 	}

 	protected function getNodeClass() {
@ -65,10 +72,10 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn([
 				new FileInfo('/bar/foo/asd', null, 'foo/asd', ['fileid' => 2, 'path' => '/bar/foo/asd', 'name' => 'asd', 'size' => 100, 'mtime' => 50, 'mimetype' => 'text/plain'], null),
-				new FileInfo('/bar/foo/qwerty', null, 'foo/qwerty', ['fileid' => 3, 'path' => '/bar/foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'httpd/unix-directory'], null)
+				new FileInfo('/bar/foo/qwerty', null, 'foo/qwerty', ['fileid' => 3, 'path' => '/bar/foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'httpd/unix-directory'], null),
 			]);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$children = $node->getDirectoryListing();
 		$this->assertEquals(2, count($children));
 		$this->assertInstanceOf('\OC\Files\Node\File', $children[0]);
@ -96,7 +103,7 @@ class FolderTest extends NodeTest {
 			->method('get')
 			->with('/bar/foo/asd');

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$node->get('asd');
 	}

@ -113,14 +120,14 @@ class FolderTest extends NodeTest {
 			->method('getUser')
 			->willReturn($this->user);

-		$child = new \OC\Files\Node\Folder($root, $view, '/bar/foo/asd');
+		$child = new Folder($root, $view, '/bar/foo/asd');

 		$root->expects($this->once())
 			->method('get')
 			->with('/bar/foo/asd')
 			->willReturn($child);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$this->assertTrue($node->nodeExists('asd'));
 	}

@ -142,7 +149,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo/asd')
 			->will($this->throwException(new NotFoundException()));

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$this->assertFalse($node->nodeExists('asd'));
 	}

@ -169,8 +176,8 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo/asd')
 			->willReturn(true);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
-		$child = new \OC\Files\Node\Folder($root, $view, '/bar/foo/asd');
+		$node = new Folder($root, $view, '/bar/foo');
+		$child = new Folder($root, $view, '/bar/foo/asd');
 		$result = $node->newFolder('asd');
 		$this->assertEquals($child, $result);
 	}
@ -196,7 +203,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn($this->getFileInfo(['permissions' => \OCP\Constants::PERMISSION_READ]));

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$node->newFolder('asd');
 	}

@ -223,7 +230,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo/asd')
 			->willReturn(true);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$child = new \OC\Files\Node\File($root, $view, '/bar/foo/asd');
 		$result = $node->newFile('asd');
 		$this->assertEquals($child, $result);
@ -250,7 +257,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn($this->getFileInfo(['permissions' => \OCP\Constants::PERMISSION_READ]));

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$node->newFile('asd');
 	}

@ -272,7 +279,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn(100);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$this->assertEquals(100, $node->getFreeSpace());
 	}

@ -285,43 +292,35 @@ class FolderTest extends NodeTest {
 		$root = $this->getMockBuilder(Root::class)
 			->setConstructorArgs([$manager, $view, $this->user, $this->userMountCache, $this->logger, $this->userManager])
 			->getMock();
-		$root->expects($this->any())
-			->method('getUser')
+		$root->method('getUser')
 			->willReturn($this->user);
 		$storage = $this->createMock(Storage::class);
 		$storage->method('getId')->willReturn('');
 		$cache = $this->getMockBuilder(Cache::class)->setConstructorArgs([$storage])->getMock();

-		$storage->expects($this->once())
-			->method('getCache')
+		$storage->method('getCache')
 			->willReturn($cache);

 		$mount = $this->createMock(IMountPoint::class);
-		$mount->expects($this->once())
-			->method('getStorage')
+		$mount->method('getStorage')
 			->willReturn($storage);
-		$mount->expects($this->once())
-			->method('getInternalPath')
+		$mount->method('getInternalPath')
 			->willReturn('foo');

-		$cache->expects($this->once())
-			->method('search')
-			->with('%qw%')
+		$cache->method('searchQuery')
 			->willReturn([
-				['fileid' => 3, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']
+				new CacheEntry(['fileid' => 3, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']),
 			]);

-		$root->expects($this->once())
-			->method('getMountsIn')
+		$root->method('getMountsIn')
 			->with('/bar/foo')
 			->willReturn([]);

-		$root->expects($this->once())
-			->method('getMount')
+		$root->method('getMount')
 			->with('/bar/foo')
 			->willReturn($mount);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$result = $node->search('qw');
 		$this->assertEquals(1, count($result));
 		$this->assertEquals('/bar/foo/qwerty', $result[0]->getPath());
@ -346,32 +345,24 @@ class FolderTest extends NodeTest {
 		$cache = $this->getMockBuilder(Cache::class)->setConstructorArgs([$storage])->getMock();

 		$mount = $this->createMock(IMountPoint::class);
-		$mount->expects($this->once())
-			->method('getStorage')
+		$mount->method('getStorage')
 			->willReturn($storage);
-		$mount->expects($this->once())
-			->method('getInternalPath')
+		$mount->method('getInternalPath')
 			->willReturn('files');

-		$storage->expects($this->once())
-			->method('getCache')
+		$storage->method('getCache')
 			->willReturn($cache);

-		$cache->expects($this->once())
-			->method('search')
-			->with('%qw%')
+		$cache->method('searchQuery')
 			->willReturn([
-				['fileid' => 3, 'path' => 'files/foo', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain'],
-				['fileid' => 3, 'path' => 'files_trashbin/foo2.d12345', 'name' => 'foo2.d12345', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain'],
+				new CacheEntry(['fileid' => 3, 'path' => 'files/foo', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']),
 			]);

-		$root->expects($this->once())
-			->method('getMountsIn')
+		$root->method('getMountsIn')
 			->with('')
 			->willReturn([]);

-		$root->expects($this->once())
-			->method('getMount')
+		$root->method('getMount')
 			->with('')
 			->willReturn($mount);

@ -389,43 +380,35 @@ class FolderTest extends NodeTest {
 		$root = $this->getMockBuilder(Root::class)
 			->setConstructorArgs([$manager, $view, $this->user, $this->userMountCache, $this->logger, $this->userManager])
 			->getMock();
-		$root->expects($this->any())
-			->method('getUser')
+		$root->method('getUser')
 			->willReturn($this->user);
 		$storage = $this->createMock(Storage::class);
 		$storage->method('getId')->willReturn('');
 		$cache = $this->getMockBuilder(Cache::class)->setConstructorArgs([$storage])->getMock();

 		$mount = $this->createMock(IMountPoint::class);
-		$mount->expects($this->once())
-			->method('getStorage')
+		$mount->method('getStorage')
 			->willReturn($storage);
-		$mount->expects($this->once())
-			->method('getInternalPath')
+		$mount->method('getInternalPath')
 			->willReturn('');

-		$storage->expects($this->once())
-			->method('getCache')
+		$storage->method('getCache')
 			->willReturn($cache);

-		$cache->expects($this->once())
-			->method('search')
-			->with('%qw%')
+		$cache->method('searchQuery')
 			->willReturn([
-				['fileid' => 3, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']
+				new CacheEntry(['fileid' => 3, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']),
 			]);

-		$root->expects($this->once())
-			->method('getMountsIn')
+		$root->method('getMountsIn')
 			->with('/bar')
 			->willReturn([]);

-		$root->expects($this->once())
-			->method('getMount')
+		$root->method('getMount')
 			->with('/bar')
 			->willReturn($mount);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar');
+		$node = new Folder($root, $view, '/bar');
 		$result = $node->search('qw');
 		$this->assertEquals(1, count($result));
 		$this->assertEquals('/bar/foo/qwerty', $result[0]->getPath());
@ -451,62 +434,50 @@ class FolderTest extends NodeTest {
 		$subMount = $this->getMockBuilder(MountPoint::class)->setConstructorArgs([null, ''])->getMock();

 		$mount = $this->createMock(IMountPoint::class);
-		$mount->expects($this->once())
-			->method('getStorage')
+		$mount->method('getStorage')
 			->willReturn($storage);
-		$mount->expects($this->once())
-			->method('getInternalPath')
+		$mount->method('getInternalPath')
 			->willReturn('foo');

-		$subMount->expects($this->once())
-			->method('getStorage')
+		$subMount->method('getStorage')
 			->willReturn($subStorage);

-		$subMount->expects($this->once())
-			->method('getMountPoint')
+		$subMount->method('getMountPoint')
 			->willReturn('/bar/foo/bar/');

-		$storage->expects($this->once())
-			->method('getCache')
+		$storage->method('getCache')
 			->willReturn($cache);

-		$subStorage->expects($this->once())
-			->method('getCache')
+		$subStorage->method('getCache')
 			->willReturn($subCache);

-		$cache->expects($this->once())
-			->method('search')
-			->with('%qw%')
+		$cache->method('searchQuery')
 			->willReturn([
-				['fileid' => 3, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']
+				new CacheEntry(['fileid' => 3, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']),
 			]);

-		$subCache->expects($this->once())
-			->method('search')
-			->with('%qw%')
+		$subCache->method('searchQuery')
 			->willReturn([
-				['fileid' => 4, 'path' => 'asd/qweasd', 'name' => 'qweasd', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']
+				new CacheEntry(['fileid' => 4, 'path' => 'asd/qweasd', 'name' => 'qweasd', 'size' => 200, 'mtime' => 55, 'mimetype' => 'text/plain']),
 			]);

-		$root->expects($this->once())
-			->method('getMountsIn')
+		$root->method('getMountsIn')
 			->with('/bar/foo')
 			->willReturn([$subMount]);

-		$root->expects($this->once())
-			->method('getMount')
+		$root->method('getMount')
 			->with('/bar/foo')
 			->willReturn($mount);


-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$result = $node->search('qw');
 		$this->assertEquals(2, count($result));
 	}

 	public function testIsSubNode() {
 		$file = new Node(null, null, '/foo/bar');
-		$folder = new \OC\Files\Node\Folder(null, null, '/foo');
+		$folder = new Folder(null, null, '/foo');
 		$this->assertTrue($folder->isSubNode($file));
 		$this->assertFalse($folder->isSubNode($folder));

@ -562,7 +533,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn($mount);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$result = $node->getById(1);
 		$this->assertEquals(1, count($result));
 		$this->assertEquals('/bar/foo/qwerty', $result[0]->getPath());
@ -611,7 +582,7 @@ class FolderTest extends NodeTest {
 			->with('/bar')
 			->willReturn($mount);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar');
+		$node = new Folder($root, $view, '/bar');
 		$result = $node->getById(1);
 		$this->assertEquals(1, count($result));
 		$this->assertEquals('/bar', $result[0]->getPath());
@ -665,7 +636,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn($mount);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$result = $node->getById(1);
 		$this->assertEquals(0, count($result));
 	}
@ -711,7 +682,7 @@ class FolderTest extends NodeTest {
 					'/bar/foo/asd/',
 					1,
 					''
-				)
+				),
 			]);

 		$storage->expects($this->any())
@ -733,7 +704,7 @@ class FolderTest extends NodeTest {
 			->with('/bar/foo')
 			->willReturn($mount1);

-		$node = new \OC\Files\Node\Folder($root, $view, '/bar/foo');
+		$node = new Folder($root, $view, '/bar/foo');
 		$result = $node->getById(1);
 		$this->assertEquals(2, count($result));
 		$this->assertEquals('/bar/foo/qwerty', $result[0]->getPath());
@ -745,7 +716,7 @@ class FolderTest extends NodeTest {
 			// input, existing, expected
 			['foo', [], 'foo'],
 			['foo', ['foo'], 'foo (2)'],
-			['foo', ['foo', 'foo (2)'], 'foo (3)']
+			['foo', ['foo', 'foo (2)'], 'foo (3)'],
 		];
 	}

@ -775,7 +746,7 @@ class FolderTest extends NodeTest {
 				return false;
 			});

-		$node = new \OC\Files\Node\Folder($root, $view, $folderPath);
+		$node = new Folder($root, $view, $folderPath);
 		$this->assertEquals($expected, $node->getNonExistingName($name));
 	}

@ -810,30 +781,30 @@ class FolderTest extends NodeTest {
 			'mtime' => $baseTime,
 			'mimetype' => 'text/plain',
 			'size' => 3,
-			'permissions' => \OCP\Constants::PERMISSION_ALL
+			'permissions' => \OCP\Constants::PERMISSION_ALL,
 		]);
 		$id2 = $cache->put('bar/foo/old.txt', [
 			'storage_mtime' => $baseTime - 100,
 			'mtime' => $baseTime - 100,
 			'mimetype' => 'text/plain',
 			'size' => 3,
-			'permissions' => \OCP\Constants::PERMISSION_READ
+			'permissions' => \OCP\Constants::PERMISSION_READ,
 		]);
 		$cache->put('bar/asd/outside.txt', [
 			'storage_mtime' => $baseTime,
 			'mtime' => $baseTime,
 			'mimetype' => 'text/plain',
-			'size' => 3
+			'size' => 3,
 		]);
 		$id3 = $cache->put('bar/foo/older.txt', [
 			'storage_mtime' => $baseTime - 600,
 			'mtime' => $baseTime - 600,
 			'mimetype' => 'text/plain',
 			'size' => 3,
-			'permissions' => \OCP\Constants::PERMISSION_ALL
+			'permissions' => \OCP\Constants::PERMISSION_ALL,
 		]);

-		$node = new \OC\Files\Node\Folder($root, $view, $folderPath, $folderInfo);
+		$node = new Folder($root, $view, $folderPath, $folderInfo);


 		$nodes = $node->getRecent(5);
@ -874,7 +845,7 @@ class FolderTest extends NodeTest {
 			'mtime' => $baseTime,
 			'mimetype' => \OCP\Files\FileInfo::MIMETYPE_FOLDER,
 			'size' => 3,
-			'permissions' => 0
+			'permissions' => 0,
 		]);
 		$id2 = $cache->put('bar/foo/folder/bar.txt', [
 			'storage_mtime' => $baseTime,
@ -882,7 +853,7 @@ class FolderTest extends NodeTest {
 			'mimetype' => 'text/plain',
 			'size' => 3,
 			'parent' => $id1,
-			'permissions' => \OCP\Constants::PERMISSION_ALL
+			'permissions' => \OCP\Constants::PERMISSION_ALL,
 		]);
 		$id3 = $cache->put('bar/foo/folder/asd.txt', [
 			'storage_mtime' => $baseTime - 100,
@ -890,10 +861,10 @@ class FolderTest extends NodeTest {
 			'mimetype' => 'text/plain',
 			'size' => 3,
 			'parent' => $id1,
-			'permissions' => \OCP\Constants::PERMISSION_ALL
+			'permissions' => \OCP\Constants::PERMISSION_ALL,
 		]);

-		$node = new \OC\Files\Node\Folder($root, $view, $folderPath, $folderInfo);
+		$node = new Folder($root, $view, $folderPath, $folderInfo);


 		$nodes = $node->getRecent(5);
@ -925,7 +896,7 @@ class FolderTest extends NodeTest {
 		$storage = new Temporary();
 		$jail = new Jail([
 			'storage' => $storage,
-			'root' => 'folder'
+			'root' => 'folder',
 		]);
 		$mount = new MountPoint($jail, '/bar/foo');

@ -940,16 +911,16 @@ class FolderTest extends NodeTest {
 			'mtime' => $baseTime,
 			'mimetype' => 'text/plain',
 			'size' => 3,
-			'permissions' => \OCP\Constants::PERMISSION_ALL
+			'permissions' => \OCP\Constants::PERMISSION_ALL,
 		]);
 		$cache->put('outside.txt', [
 			'storage_mtime' => $baseTime - 100,
 			'mtime' => $baseTime - 100,
 			'mimetype' => 'text/plain',
-			'size' => 3
+			'size' => 3,
 		]);

-		$node = new \OC\Files\Node\Folder($root, $view, $folderPath, $folderInfo);
+		$node = new Folder($root, $view, $folderPath, $folderInfo);

 		$nodes = $node->getRecent(5);
 		$ids = array_map(function (Node $node) {
@ -957,4 +928,127 @@ class FolderTest extends NodeTest {
 		}, $nodes);
 		$this->assertEquals([$id1], $ids);
 	}
+
+	public function offsetLimitProvider() {
+		return [
+			[0, 10, [10, 11, 12, 13, 14, 15, 16, 17], []],
+			[0, 5, [10, 11, 12, 13, 14], []],
+			[0, 2, [10, 11], []],
+			[3, 2, [13, 14], []],
+			[3, 5, [13, 14, 15, 16, 17], []],
+			[5, 2, [15, 16], []],
+			[6, 2, [16, 17], []],
+			[7, 2, [17], []],
+			[10, 2, [], []],
+			[0, 5, [16, 10, 14, 11, 12], [new SearchOrder(ISearchOrder::DIRECTION_ASCENDING, 'mtime')]],
+			[3, 2, [11, 12], [new SearchOrder(ISearchOrder::DIRECTION_ASCENDING, 'mtime')]],
+			[0, 5, [14, 15, 16, 10, 11], [
+				new SearchOrder(ISearchOrder::DIRECTION_DESCENDING, 'size'),
+				new SearchOrder(ISearchOrder::DIRECTION_ASCENDING, 'mtime')
+			]],
+		];
+	}
+
+	/**
+	 * @dataProvider offsetLimitProvider
+	 * @param int $offset
+	 * @param int $limit
+	 * @param int[] $expectedIds
+	 * @param ISearchOrder[] $ordering
+	 * @throws NotFoundException
+	 * @throws \OCP\Files\InvalidPathException
+	 */
+	public function testSearchSubStoragesLimitOffset(int $offset, int $limit, array $expectedIds, array $ordering) {
+		$manager = $this->createMock(Manager::class);
+		/**
+		 * @var \OC\Files\View | \PHPUnit\Framework\MockObject\MockObject $view
+		 */
+		$view = $this->createMock(View::class);
+		$root = $this->getMockBuilder(Root::class)
+			->setConstructorArgs([$manager, $view, $this->user, $this->userMountCache, $this->logger, $this->userManager])
+			->getMock();
+		$root->expects($this->any())
+			->method('getUser')
+			->willReturn($this->user);
+		$storage = $this->createMock(Storage::class);
+		$storage->method('getId')->willReturn('');
+		$cache = $this->getMockBuilder(Cache::class)->setConstructorArgs([$storage])->getMock();
+		$subCache1 = $this->getMockBuilder(Cache::class)->setConstructorArgs([$storage])->getMock();
+		$subStorage1 = $this->createMock(Storage::class);
+		$subMount1 = $this->getMockBuilder(MountPoint::class)->setConstructorArgs([null, ''])->getMock();
+		$subCache2 = $this->getMockBuilder(Cache::class)->setConstructorArgs([$storage])->getMock();
+		$subStorage2 = $this->createMock(Storage::class);
+		$subMount2 = $this->getMockBuilder(MountPoint::class)->setConstructorArgs([null, ''])->getMock();
+
+		$mount = $this->createMock(IMountPoint::class);
+		$mount->method('getStorage')
+			->willReturn($storage);
+		$mount->method('getInternalPath')
+			->willReturn('foo');
+
+		$subMount1->method('getStorage')
+			->willReturn($subStorage1);
+
+		$subMount1->method('getMountPoint')
+			->willReturn('/bar/foo/bar/');
+
+		$storage->method('getCache')
+			->willReturn($cache);
+
+		$subStorage1->method('getCache')
+			->willReturn($subCache1);
+
+		$subMount2->method('getStorage')
+			->willReturn($subStorage2);
+
+		$subMount2->method('getMountPoint')
+			->willReturn('/bar/foo/bar2/');
+
+		$subStorage2->method('getCache')
+			->willReturn($subCache2);
+
+		$cache->method('searchQuery')
+			->willReturnCallback(function (ISearchQuery $query) {
+				return array_slice([
+					new CacheEntry(['fileid' => 10, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 10, 'mimetype' => 'text/plain']),
+					new CacheEntry(['fileid' => 11, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 20, 'mimetype' => 'text/plain']),
+					new CacheEntry(['fileid' => 12, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 30, 'mimetype' => 'text/plain']),
+					new CacheEntry(['fileid' => 13, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 40, 'mimetype' => 'text/plain']),
+				], $query->getOffset(), $query->getOffset() + $query->getLimit());
+			});
+
+		$subCache1->method('searchQuery')
+			->willReturnCallback(function (ISearchQuery $query) {
+				return array_slice([
+					new CacheEntry(['fileid' => 14, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 300, 'mtime' => 15, 'mimetype' => 'text/plain']),
+					new CacheEntry(['fileid' => 15, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 300, 'mtime' => 50, 'mimetype' => 'text/plain']),
+				], $query->getOffset(), $query->getOffset() + $query->getLimit());
+			});
+
+		$subCache2->method('searchQuery')
+			->willReturnCallback(function (ISearchQuery $query) {
+				return array_slice([
+					new CacheEntry(['fileid' => 16, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 5, 'mimetype' => 'text/plain']),
+					new CacheEntry(['fileid' => 17, 'path' => 'foo/qwerty', 'name' => 'qwerty', 'size' => 200, 'mtime' => 60, 'mimetype' => 'text/plain']),
+				], $query->getOffset(), $query->getOffset() + $query->getLimit());
+			});
+
+		$root->method('getMountsIn')
+			->with('/bar/foo')
+			->willReturn([$subMount1, $subMount2]);
+
+		$root->method('getMount')
+			->with('/bar/foo')
+			->willReturn($mount);
+
+
+		$node = new Folder($root, $view, '/bar/foo');
+		$comparison = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%foo%');
+		$query = new SearchQuery($comparison, $limit, $offset, $ordering);
+		$result = $node->search($query);
+		$ids = array_map(function (Node $info) {
+			return $info->getId();
+		}, $result);
+		$this->assertEquals($expectedIds, $ids);
+	}
 }