IFilesMetadata

Signed-off-by: Maxence Lange <maxence@artificial-owl.com>

20 files changed, 2158 insertions, 95 deletions

diff --git a/lib/private/Files/Cache/CacheQueryBuilder.php b/lib/private/Files/Cache/CacheQueryBuilder.php
index 34d2177b84e..f799d6aa72e 100644
--- a/lib/private/Files/Cache/CacheQueryBuilder.php
+++ b/lib/private/Files/Cache/CacheQueryBuilder.php
@@ -5,6 +5,7 @@ declare(strict_types=1);
 /**
  * @copyright Copyright (c) 2019 Robin Appelman <robin@icewind.nl>
  *
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Robin Appelman <robin@icewind.nl>
  *
  * @license GNU AGPL version 3 or any later version
@@ -35,7 +36,7 @@ use Psr\Log\LoggerInterface;
  * Query builder with commonly used helpers for filecache queries
  */
 class CacheQueryBuilder extends QueryBuilder {
-	private $alias = null;
+	private ?string $alias = null;
 
 	public function __construct(IDBConnection $connection, SystemConfig $systemConfig, LoggerInterface $logger) {
 		parent::__construct($connection, $systemConfig, $logger);
diff --git a/lib/private/Files/Cache/QuerySearchHelper.php b/lib/private/Files/Cache/QuerySearchHelper.php
index 15c089a0f11..ca54133a243 100644
--- a/lib/private/Files/Cache/QuerySearchHelper.php
+++ b/lib/private/Files/Cache/QuerySearchHelper.php
@@ -3,6 +3,7 @@
  * @copyright Copyright (c) 2017 Robin Appelman <robin@icewind.nl>
  *
  * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Robin Appelman <robin@icewind.nl>
  * @author Roeland Jago Douma <roeland@famdouma.nl>
  * @author Tobias Kaminsky <tobias@kaminsky.me>
@@ -37,41 +38,24 @@ use OCP\Files\IRootFolder;
 use OCP\Files\Mount\IMountPoint;
 use OCP\Files\Search\ISearchBinaryOperator;
 use OCP\Files\Search\ISearchQuery;
+use OCP\FilesMetadata\IFilesMetadataManager;
+use OCP\FilesMetadata\Model\IMetadataQuery;
 use OCP\IDBConnection;
 use OCP\IGroupManager;
 use OCP\IUser;
 use Psr\Log\LoggerInterface;
 
 class QuerySearchHelper {
-	/** @var IMimeTypeLoader */
-	private $mimetypeLoader;
-	/** @var IDBConnection */
-	private $connection;
-	/** @var SystemConfig */
-	private $systemConfig;
-	private LoggerInterface $logger;
-	/** @var SearchBuilder */
-	private $searchBuilder;
-	/** @var QueryOptimizer */
-	private $queryOptimizer;
-	private IGroupManager $groupManager;
-
 	public function __construct(
-		IMimeTypeLoader $mimetypeLoader,
-		IDBConnection $connection,
-		SystemConfig $systemConfig,
-		LoggerInterface $logger,
-		SearchBuilder $searchBuilder,
-		QueryOptimizer $queryOptimizer,
-		IGroupManager $groupManager,
+		private IMimeTypeLoader $mimetypeLoader,
+		private IDBConnection $connection,
+		private SystemConfig $systemConfig,
+		private LoggerInterface $logger,
+		private SearchBuilder $searchBuilder,
+		private QueryOptimizer $queryOptimizer,
+		private IGroupManager $groupManager,
+		private IFilesMetadataManager $filesMetadataManager,
 	) {
-		$this->mimetypeLoader = $mimetypeLoader;
-		$this->connection = $connection;
-		$this->systemConfig = $systemConfig;
-		$this->logger = $logger;
-		$this->searchBuilder = $searchBuilder;
-		$this->queryOptimizer = $queryOptimizer;
-		$this->groupManager = $groupManager;
 	}
 
 	protected function getQueryBuilder() {
@@ -82,7 +66,12 @@ class QuerySearchHelper {
 		);
 	}
 
-	protected function applySearchConstraints(CacheQueryBuilder $query, ISearchQuery $searchQuery, array $caches): void {
+	protected function applySearchConstraints(
+		CacheQueryBuilder $query,
+		ISearchQuery $searchQuery,
+		array $caches,
+		?IMetadataQuery $metadataQuery = null
+	): void {
 		$storageFilters = array_values(array_map(function (ICache $cache) {
 			return $cache->getQueryFilterForStorage();
 		}, $caches));
@@ -90,12 +79,12 @@ class QuerySearchHelper {
 		$filter = new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND, [$searchQuery->getSearchOperation(), $storageFilter]);
 		$this->queryOptimizer->processOperator($filter);
 
-		$searchExpr = $this->searchBuilder->searchOperatorToDBExpr($query, $filter);
+		$searchExpr = $this->searchBuilder->searchOperatorToDBExpr($query, $filter, $metadataQuery);
 		if ($searchExpr) {
 			$query->andWhere($searchExpr);
 		}
 
-		$this->searchBuilder->addSearchOrdersToQuery($query, $searchQuery->getOrder());
+		$this->searchBuilder->addSearchOrdersToQuery($query, $searchQuery->getOrder(), $metadataQuery);
 
 		if ($searchQuery->getLimit()) {
 			$query->setMaxResults($searchQuery->getLimit());
@@ -144,6 +133,20 @@ class QuerySearchHelper {
 			));
 	}
 
+
+	/**
+	 * left join metadata and its indexes to the filecache table
+	 *
+	 * @param CacheQueryBuilder $query
+	 *
+	 * @return IMetadataQuery
+	 */
+	protected function equipQueryForMetadata(CacheQueryBuilder $query): IMetadataQuery {
+		$metadataQuery = $this->filesMetadataManager->getMetadataQuery($query, 'file', 'fileid');
+		$metadataQuery->retrieveMetadata();
+		return $metadataQuery;
+	}
+
 	/**
 	 * Perform a file system search in multiple caches
 	 *
@@ -175,6 +178,7 @@ class QuerySearchHelper {
 		$query = $builder->selectFileCache('file', false);
 
 		$requestedFields = $this->searchBuilder->extractRequestedFields($searchQuery->getSearchOperation());
+
 		if (in_array('systemtag', $requestedFields)) {
 			$this->equipQueryForSystemTags($query, $this->requireUser($searchQuery));
 		}
@@ -182,12 +186,14 @@ class QuerySearchHelper {
 			$this->equipQueryForDavTags($query, $this->requireUser($searchQuery));
 		}
 
-		$this->applySearchConstraints($query, $searchQuery, $caches);
+		$metadataQuery = $this->equipQueryForMetadata($query);
+		$this->applySearchConstraints($query, $searchQuery, $caches, $metadataQuery);
 
 		$result = $query->execute();
 		$files = $result->fetchAll();
 
-		$rawEntries = array_map(function (array $data) {
+		$rawEntries = array_map(function (array $data) use ($metadataQuery) {
+			$data['metadata'] = $metadataQuery->extractMetadata($data)->asArray();
 			return Cache::cacheEntryFromData($data, $this->mimetypeLoader);
 		}, $files);
 
diff --git a/lib/private/Files/Cache/SearchBuilder.php b/lib/private/Files/Cache/SearchBuilder.php
index b9a70bbd39b..ba4aabf2b4f 100644
--- a/lib/private/Files/Cache/SearchBuilder.php
+++ b/lib/private/Files/Cache/SearchBuilder.php
@@ -3,6 +3,7 @@
  * @copyright Copyright (c) 2017 Robin Appelman <robin@icewind.nl>
  *
  * @author Christoph Wurst <christoph@winzerhof-wurst.at>
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Robin Appelman <robin@icewind.nl>
  * @author Roeland Jago Douma <roeland@famdouma.nl>
  * @author Tobias Kaminsky <tobias@kaminsky.me>
@@ -32,6 +33,7 @@ use OCP\Files\Search\ISearchBinaryOperator;
 use OCP\Files\Search\ISearchComparison;
 use OCP\Files\Search\ISearchOperator;
 use OCP\Files\Search\ISearchOrder;
+use OCP\FilesMetadata\Model\IMetadataQuery;
 
 /**
  * Tools for transforming search queries into database queries
@@ -76,7 +78,7 @@ class SearchBuilder {
 			return array_reduce($operator->getArguments(), function (array $fields, ISearchOperator $operator) {
 				return array_unique(array_merge($fields, $this->extractRequestedFields($operator)));
 			}, []);
-		} elseif ($operator instanceof ISearchComparison) {
+		} elseif ($operator instanceof ISearchComparison && !$operator->isExtra()) {
 			return [$operator->getField()];
 		}
 		return [];
@@ -86,13 +88,21 @@ class SearchBuilder {
 	 * @param IQueryBuilder $builder
 	 * @param ISearchOperator[] $operators
 	 */
-	public function searchOperatorArrayToDBExprArray(IQueryBuilder $builder, array $operators) {
-		return array_filter(array_map(function ($operator) use ($builder) {
-			return $this->searchOperatorToDBExpr($builder, $operator);
+	public function searchOperatorArrayToDBExprArray(
+		IQueryBuilder $builder,
+		array $operators,
+		?IMetadataQuery $metadataQuery = null
+	) {
+		return array_filter(array_map(function ($operator) use ($builder, $metadataQuery) {
+			return $this->searchOperatorToDBExpr($builder, $operator, $metadataQuery);
 		}, $operators));
 	}
 
-	public function searchOperatorToDBExpr(IQueryBuilder $builder, ISearchOperator $operator) {
+	public function searchOperatorToDBExpr(
+		IQueryBuilder $builder,
+		ISearchOperator $operator,
+		?IMetadataQuery $metadataQuery = null
+	) {
 		$expr = $builder->expr();
 
 		if ($operator instanceof ISearchBinaryOperator) {
@@ -104,29 +114,37 @@ class SearchBuilder {
 				case ISearchBinaryOperator::OPERATOR_NOT:
 					$negativeOperator = $operator->getArguments()[0];
 					if ($negativeOperator instanceof ISearchComparison) {
-						return $this->searchComparisonToDBExpr($builder, $negativeOperator, self::$searchOperatorNegativeMap);
+						return $this->searchComparisonToDBExpr($builder, $negativeOperator, self::$searchOperatorNegativeMap, $metadataQuery);
 					} else {
 						throw new \InvalidArgumentException('Binary operators inside "not" is not supported');
 					}
 					// no break
 				case ISearchBinaryOperator::OPERATOR_AND:
-					return call_user_func_array([$expr, 'andX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments()));
+					return call_user_func_array([$expr, 'andX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments(), $metadataQuery));
 				case ISearchBinaryOperator::OPERATOR_OR:
-					return call_user_func_array([$expr, 'orX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments()));
+					return call_user_func_array([$expr, 'orX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments(), $metadataQuery));
 				default:
 					throw new \InvalidArgumentException('Invalid operator type: ' . $operator->getType());
 			}
 		} elseif ($operator instanceof ISearchComparison) {
-			return $this->searchComparisonToDBExpr($builder, $operator, self::$searchOperatorMap);
+			return $this->searchComparisonToDBExpr($builder, $operator, self::$searchOperatorMap, $metadataQuery);
 		} else {
 			throw new \InvalidArgumentException('Invalid operator type: ' . get_class($operator));
 		}
 	}
 
-	private function searchComparisonToDBExpr(IQueryBuilder $builder, ISearchComparison $comparison, array $operatorMap) {
-		$this->validateComparison($comparison);
+	private function searchComparisonToDBExpr(
+		IQueryBuilder $builder,
+		ISearchComparison $comparison,
+		array $operatorMap,
+		?IMetadataQuery $metadataQuery = null
+	) {
+		if ($comparison->getExtra()) {
+			[$field, $value, $type] = $this->getExtraOperatorField($comparison, $metadataQuery);
+		} else {
+			[$field, $value, $type] = $this->getOperatorFieldAndValue($comparison);
+		}
 
-		[$field, $value, $type] = $this->getOperatorFieldAndValue($comparison);
 		if (isset($operatorMap[$type])) {
 			$queryOperator = $operatorMap[$type];
 			return $builder->expr()->$queryOperator($field, $this->getParameterForValue($builder, $value));
@@ -136,9 +154,12 @@ class SearchBuilder {
 	}
 
 	private function getOperatorFieldAndValue(ISearchComparison $operator) {
+		$this->validateComparison($operator);
+
 		$field = $operator->getField();
 		$value = $operator->getValue();
 		$type = $operator->getType();
+
 		if ($field === 'mimetype') {
 			$value = (string)$value;
 			if ($operator->getType() === ISearchComparison::COMPARE_EQUAL) {
@@ -213,6 +234,24 @@ class SearchBuilder {
 		}
 	}
 
+
+	private function getExtraOperatorField(ISearchComparison $operator, IMetadataQuery $metadataQuery): array {
+		$field = $operator->getField();
+		$value = $operator->getValue();
+		$type = $operator->getType();
+
+		switch($operator->getExtra()) {
+			case IMetadataQuery::EXTRA:
+				$metadataQuery->joinIndex($field); // join index table if not joined yet
+				$field = $metadataQuery->getMetadataValueField($field);
+				break;
+			default:
+				throw new \InvalidArgumentException('Invalid extra type: ' . $operator->getExtra());
+		}
+
+		return [$field, $value, $type];
+	}
+
 	private function getParameterForValue(IQueryBuilder $builder, $value) {
 		if ($value instanceof \DateTime) {
 			$value = $value->getTimestamp();
@@ -228,24 +267,32 @@ class SearchBuilder {
 	/**
 	 * @param IQueryBuilder $query
 	 * @param ISearchOrder[] $orders
+	 * @param IMetadataQuery|null $metadataQuery
 	 */
-	public function addSearchOrdersToQuery(IQueryBuilder $query, array $orders) {
+	public function addSearchOrdersToQuery(IQueryBuilder $query, array $orders, ?IMetadataQuery $metadataQuery = null): void {
 		foreach ($orders as $order) {
 			$field = $order->getField();
-			if ($field === 'fileid') {
-				$field = 'file.fileid';
-			}
+			switch ($order->getExtra()) {
+				case IMetadataQuery::EXTRA:
+					$metadataQuery->joinIndex($field); // join index table if not joined yet
+					$field = $metadataQuery->getMetadataValueField($order->getField());
+					break;
 
-			// Mysql really likes to pick an index for sorting if it can't fully satisfy the where
-			// filter with an index, since search queries pretty much never are fully filtered by index
-			// mysql often picks an index for sorting instead of the much more useful index for filtering.
-			//
-			// By changing the order by to an expression, mysql isn't smart enough to see that it could still
-			// use the index, so it instead picks an index for the filtering
-			if ($field === 'mtime') {
-				$field = $query->func()->add($field, $query->createNamedParameter(0));
-			}
+				default:
+					if ($field === 'fileid') {
+						$field = 'file.fileid';
+					}
 
+					// Mysql really likes to pick an index for sorting if it can't fully satisfy the where
+					// filter with an index, since search queries pretty much never are fully filtered by index
+					// mysql often picks an index for sorting instead of the much more useful index for filtering.
+					//
+					// By changing the order by to an expression, mysql isn't smart enough to see that it could still
+					// use the index, so it instead picks an index for the filtering
+					if ($field === 'mtime') {
+						$field = $query->func()->add($field, $query->createNamedParameter(0));
+					}
+			}
 			$query->addOrderBy($field, $order->getDirection());
 		}
 	}
diff --git a/lib/private/Files/FileInfo.php b/lib/private/Files/FileInfo.php
index 7800074460b..da0ae7e8d89 100644
--- a/lib/private/Files/FileInfo.php
+++ b/lib/private/Files/FileInfo.php
@@ -6,6 +6,7 @@
  * @author Joas Schilling <coding@schilljs.com>
  * @author Julius Härtl <jus@bitgrid.net>
  * @author Lukas Reschke <lukas@statuscode.ch>
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Morris Jobke <hey@morrisjobke.de>
  * @author Piotr M <mrow4a@yahoo.com>
  * @author Robin Appelman <robin@icewind.nl>
@@ -416,4 +417,12 @@ class FileInfo implements \OCP\Files\FileInfo, \ArrayAccess {
 	public function getParentId(): int {
 		return $this->data['parent'] ?? -1;
 	}
+
+	/**
+	 * @inheritDoc
+	 * @return array<string, int|string|bool|float|string[]|int[]>
+	 */
+	public function getMetadata(): array {
+		return $this->data['metadata'] ?? [];
+	}
 }
diff --git a/lib/private/Files/Node/Folder.php b/lib/private/Files/Node/Folder.php
index c7462572fed..eba7ce1d77e 100644
--- a/lib/private/Files/Node/Folder.php
+++ b/lib/private/Files/Node/Folder.php
@@ -252,6 +252,8 @@ class Folder extends Node implements \OCP\Files\Folder {
 		if ($order) {
 			usort($files, function (FileInfo $a, FileInfo $b) use ($order) {
 				foreach ($order as $orderField) {
+					// needed !?
+					// if ($orderField->isExtra()) { continue; }
 					$cmp = $orderField->sortFileInfo($a, $b);
 					if ($cmp !== 0) {
 						return $cmp;
diff --git a/lib/private/Files/Node/LazyFolder.php b/lib/private/Files/Node/LazyFolder.php
index f13cdc0c4f9..393b3bbeb06 100644
--- a/lib/private/Files/Node/LazyFolder.php
+++ b/lib/private/Files/Node/LazyFolder.php
@@ -5,6 +5,7 @@ declare(strict_types=1);
 /**
  * @copyright Copyright (c) 2020 Robin Appelman <robin@icewind.nl>
  *
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Robin Appelman <robin@icewind.nl>
  *
  * @license GNU AGPL version 3 or any later version
@@ -574,4 +575,12 @@ class LazyFolder implements Folder {
 		}
 		return $this->__call(__FUNCTION__, func_get_args());
 	}
+
+	/**
+	 * @inheritDoc
+	 * @return array<string, int|string|bool|float|string[]|int[]>
+	 */
+	public function getMetadata(): array {
+		return $this->data['metadata'] ?? $this->__call(__FUNCTION__, func_get_args());
+	}
 }
diff --git a/lib/private/Files/Node/Node.php b/lib/private/Files/Node/Node.php
index 385d45f1e3e..1fdedd844ae 100644
--- a/lib/private/Files/Node/Node.php
+++ b/lib/private/Files/Node/Node.php
@@ -7,6 +7,7 @@
  * @author Christoph Wurst <christoph@winzerhof-wurst.at>
  * @author Joas Schilling <coding@schilljs.com>
  * @author Julius Härtl <jus@bitgrid.net>
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Morris Jobke <hey@morrisjobke.de>
  * @author Robin Appelman <robin@icewind.nl>
  * @author Roeland Jago Douma <roeland@famdouma.nl>
@@ -43,7 +44,7 @@ use OCP\Files\NotPermittedException;
 use OCP\Lock\LockedException;
 use OCP\PreConditionNotMetException;
 
-// FIXME: this class really should be abstract
+// FIXME: this class really should be abstract (+1)
 class Node implements INode {
 	/**
 	 * @var \OC\Files\View $view
@@ -490,4 +491,12 @@ class Node implements INode {
 	public function getParentId(): int {
 		return $this->fileInfo->getParentId();
 	}
+
+	/**
+	 * @inheritDoc
+	 * @return array<string, int|string|bool|float|string[]|int[]>
+	 */
+	public function getMetadata(): array {
+		return $this->fileInfo->getMetadata();
+	}
 }
diff --git a/lib/private/Files/Search/QueryOptimizer/PathPrefixOptimizer.php b/lib/private/Files/Search/QueryOptimizer/PathPrefixOptimizer.php
index 0caa9b12a02..cf9e6ad5b91 100644
--- a/lib/private/Files/Search/QueryOptimizer/PathPrefixOptimizer.php
+++ b/lib/private/Files/Search/QueryOptimizer/PathPrefixOptimizer.php
@@ -4,6 +4,9 @@ declare(strict_types=1);
 /**
  * @copyright Copyright (c) 2021 Robin Appelman <robin@icewind.nl>
  *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ * @author Robin Appelman <robin@icewind.nl>
+ *
  * @license GNU AGPL version 3 or any later version
  *
  * This program is free software: you can redistribute it and/or modify
@@ -48,7 +51,7 @@ class PathPrefixOptimizer extends QueryOptimizerStep {
 	}
 
 	public function processOperator(ISearchOperator &$operator) {
-		if (!$this->useHashEq && $operator instanceof ISearchComparison && $operator->getField() === 'path' && $operator->getType() === ISearchComparison::COMPARE_EQUAL) {
+		if (!$this->useHashEq && $operator instanceof ISearchComparison && !$operator->isExtra() && $operator->getField() === 'path' && $operator->getType() === ISearchComparison::COMPARE_EQUAL) {
 			$operator->setQueryHint(ISearchComparison::HINT_PATH_EQ_HASH, false);
 		}
 
@@ -69,7 +72,7 @@ class PathPrefixOptimizer extends QueryOptimizerStep {
 	private function operatorPairIsPathPrefix(ISearchOperator $like, ISearchOperator $equal): bool {
 		return (
 			$like instanceof ISearchComparison && $equal instanceof ISearchComparison &&
-			$like->getField() === 'path' && $equal->getField() === 'path' &&
+			!$like->isExtra() && !$equal->isExtra() && $like->getField() === 'path' && $equal->getField() === 'path' &&
 			$like->getType() === ISearchComparison::COMPARE_LIKE_CASE_SENSITIVE && $equal->getType() === ISearchComparison::COMPARE_EQUAL
 			&& $like->getValue() === SearchComparison::escapeLikeParameter($equal->getValue()) . '/%'
 		);
diff --git a/lib/private/Files/Search/SearchComparison.php b/lib/private/Files/Search/SearchComparison.php
index 122a1f730b4..5caa632f618 100644
--- a/lib/private/Files/Search/SearchComparison.php
+++ b/lib/private/Files/Search/SearchComparison.php
@@ -2,6 +2,7 @@
 /**
  * @copyright Copyright (c) 2017 Robin Appelman <robin@icewind.nl>
  *
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Robin Appelman <robin@icewind.nl>
  *
  * @license GNU AGPL version 3 or any later version
@@ -25,25 +26,14 @@ namespace OC\Files\Search;
 use OCP\Files\Search\ISearchComparison;
 
 class SearchComparison implements ISearchComparison {
-	/** @var string */
-	private $type;
-	/** @var string */
-	private $field;
-	/** @var string|integer|\DateTime */
-	private $value;
-	private $hints = [];
+	private array $hints = [];
 
-	/**
-	 * SearchComparison constructor.
-	 *
-	 * @param string $type
-	 * @param string $field
-	 * @param \DateTime|int|string $value
-	 */
-	public function __construct($type, $field, $value) {
-		$this->type = $type;
-		$this->field = $field;
-		$this->value = $value;
+	public function __construct(
+		private string $type,
+		private string $field,
+		private \DateTime|int|string $value,
+		private string $extra = ''
+	) {
 	}
 
 	/**
@@ -67,6 +57,14 @@ class SearchComparison implements ISearchComparison {
 		return $this->value;
 	}
 
+	public function getExtra(): string {
+		return $this->extra;
+	}
+
+	public function isExtra(): bool {
+		return ($this->extra !== '');
+	}
+
 	public function getQueryHint(string $name, $default) {
 		return $this->hints[$name] ?? $default;
 	}
diff --git a/lib/private/Files/Search/SearchOrder.php b/lib/private/Files/Search/SearchOrder.php
index 1395a87ac72..ca974ca9c03 100644
--- a/lib/private/Files/Search/SearchOrder.php
+++ b/lib/private/Files/Search/SearchOrder.php
@@ -2,6 +2,7 @@
 /**
  * @copyright Copyright (c) 2017 Robin Appelman <robin@icewind.nl>
  *
+ * @author Maxence Lange <maxence@artificial-owl.com>
  * @author Robin Appelman <robin@icewind.nl>
  *
  * @license GNU AGPL version 3 or any later version
@@ -26,36 +27,35 @@ use OCP\Files\FileInfo;
 use OCP\Files\Search\ISearchOrder;
 
 class SearchOrder implements ISearchOrder {
-	/** @var  string */
-	private $direction;
-	/** @var  string */
-	private $field;
-
-	/**
-	 * SearchOrder constructor.
-	 *
-	 * @param string $direction
-	 * @param string $field
-	 */
-	public function __construct($direction, $field) {
-		$this->direction = $direction;
-		$this->field = $field;
+	public function __construct(
+		private string $direction,
+		private string $field,
+		private string $extra = ''
+	) {
 	}
 
 	/**
 	 * @return string
 	 */
-	public function getDirection() {
+	public function getDirection(): string {
 		return $this->direction;
 	}
 
 	/**
 	 * @return string
 	 */
-	public function getField() {
+	public function getField(): string {
 		return $this->field;
 	}
 
+	public function getExtra(): string {
+		return $this->extra;
+	}
+
+	public function isExtra(): bool {
+		return ($this->extra !== '');
+	}
+
 	public function sortFileInfo(FileInfo $a, FileInfo $b): int {
 		$cmp = $this->sortFileInfoNoDirection($a, $b);
 		return $cmp * ($this->direction === ISearchOrder::DIRECTION_ASCENDING ? 1 : -1);
diff --git a/lib/private/FilesMetadata/FilesMetadataManager.php b/lib/private/FilesMetadata/FilesMetadataManager.php
new file mode 100644
index 00000000000..7e941234ce3
--- /dev/null
+++ b/lib/private/FilesMetadata/FilesMetadataManager.php
@@ -0,0 +1,280 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata;
+
+use JsonException;
+use OC\FilesMetadata\Job\UpdateSingleMetadata;
+use OC\FilesMetadata\Listener\MetadataDelete;
+use OC\FilesMetadata\Listener\MetadataUpdate;
+use OC\FilesMetadata\Model\FilesMetadata;
+use OC\FilesMetadata\Model\MetadataQuery;
+use OC\FilesMetadata\Service\IndexRequestService;
+use OC\FilesMetadata\Service\MetadataRequestService;
+use OCP\BackgroundJob\IJobList;
+use OCP\DB\Exception;
+use OCP\DB\Exception as DBException;
+use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\EventDispatcher\IEventDispatcher;
+use OCP\Files\Events\Node\NodeCreatedEvent;
+use OCP\Files\Events\Node\NodeDeletedEvent;
+use OCP\Files\Events\Node\NodeWrittenEvent;
+use OCP\Files\InvalidPathException;
+use OCP\Files\Node;
+use OCP\Files\NotFoundException;
+use OCP\FilesMetadata\Event\MetadataBackgroundEvent;
+use OCP\FilesMetadata\Event\MetadataLiveEvent;
+use OCP\FilesMetadata\Exceptions\FilesMetadataException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataNotFoundException;
+use OCP\FilesMetadata\IFilesMetadataManager;
+use OCP\FilesMetadata\Model\IFilesMetadata;
+use OCP\FilesMetadata\Model\IMetadataQuery;
+use OCP\FilesMetadata\Model\IMetadataValueWrapper;
+use OCP\IConfig;
+use Psr\Log\LoggerInterface;
+
+/**
+ * @inheritDoc
+ * @since 28.0.0
+ */
+class FilesMetadataManager implements IFilesMetadataManager {
+	public const CONFIG_KEY = 'files_metadata';
+	private const JSON_MAXSIZE = 100000;
+
+	private ?IFilesMetadata $all = null;
+
+	public function __construct(
+		private IEventDispatcher $eventDispatcher,
+		private IJobList $jobList,
+		private IConfig $config,
+		private LoggerInterface $logger,
+		private MetadataRequestService $metadataRequestService,
+		private IndexRequestService $indexRequestService,
+	) {
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param Node $node related node
+	 * @param int $process type of process
+	 *
+	 * @return IFilesMetadata
+	 * @throws FilesMetadataException if metadata are invalid
+	 * @throws InvalidPathException if path to file is not valid
+	 * @throws NotFoundException if file cannot be found
+	 * @see self::PROCESS_BACKGROUND
+	 * @see self::PROCESS_LIVE
+	 * @since 28.0.0
+	 */
+	public function refreshMetadata(
+		Node $node,
+		int $process = self::PROCESS_LIVE
+	): IFilesMetadata {
+		try {
+			$metadata = $this->metadataRequestService->getMetadataFromFileId($node->getId());
+		} catch (FilesMetadataNotFoundException) {
+			$metadata = new FilesMetadata($node->getId());
+		}
+
+		// if $process is LIVE, we enforce LIVE
+		if ((self::PROCESS_LIVE & $process) !== 0) {
+			$event = new MetadataLiveEvent($node, $metadata);
+		} else {
+			$event = new MetadataBackgroundEvent($node, $metadata);
+		}
+
+		$this->eventDispatcher->dispatchTyped($event);
+		$this->saveMetadata($event->getMetadata());
+
+		// if requested, we add a new job for next cron to refresh metadata out of main thread
+		// if $process was set to LIVE+BACKGROUND, we run background process directly
+		if ($event instanceof MetadataLiveEvent && $event->isRunAsBackgroundJobRequested()) {
+			if ((self::PROCESS_BACKGROUND & $process) !== 0) {
+				return $this->refreshMetadata($node, self::PROCESS_BACKGROUND);
+			}
+
+			$this->jobList->add(UpdateSingleMetadata::class, [$node->getOwner()->getUID(), $node->getId()]);
+		}
+
+		return $metadata;
+	}
+
+	/**
+	 * @param int $fileId file id
+	 *
+	 * @inheritDoc
+	 * @return IFilesMetadata
+	 * @throws FilesMetadataNotFoundException if not found
+	 * @since 28.0.0
+	 */
+	public function getMetadata(int $fileId): IFilesMetadata {
+		return $this->metadataRequestService->getMetadataFromFileId($fileId);
+	}
+
+	/**
+	 * @param IFilesMetadata $filesMetadata metadata
+	 *
+	 * @inheritDoc
+	 * @throws FilesMetadataException if metadata seems malformed
+	 * @since 28.0.0
+	 */
+	public function saveMetadata(IFilesMetadata $filesMetadata): void {
+		if ($filesMetadata->getFileId() === 0 || !$filesMetadata->updated()) {
+			return;
+		}
+
+		$json = json_encode($filesMetadata->jsonSerialize());
+		if (strlen($json) > self::JSON_MAXSIZE) {
+			throw new FilesMetadataException('json cannot exceed ' . self::JSON_MAXSIZE . ' characters long');
+		}
+
+		try {
+			if ($filesMetadata->getSyncToken() === '') {
+				$this->metadataRequestService->store($filesMetadata);
+			} else {
+				$this->metadataRequestService->updateMetadata($filesMetadata);
+			}
+		} catch (DBException $e) {
+			// most of the logged exception are the result of race condition
+			// between 2 simultaneous process trying to create/update metadata
+			$this->logger->warning('issue while saveMetadata', ['exception' => $e, 'metadata' => $filesMetadata]);
+
+			return;
+		}
+
+		// update indexes
+		foreach ($filesMetadata->getIndexes() as $index) {
+			try {
+				$this->indexRequestService->updateIndex($filesMetadata, $index);
+			} catch (DBException $e) {
+				$this->logger->warning('issue while updateIndex', ['exception' => $e]);
+			}
+		}
+
+		// update metadata types list
+		$current = $this->getKnownMetadata();
+		$current->import($filesMetadata->jsonSerialize(true));
+		$this->config->setAppValue('core', self::CONFIG_KEY, json_encode($current));
+	}
+
+	/**
+	 * @param int $fileId file id
+	 *
+	 * @inheritDoc
+	 * @since 28.0.0
+	 */
+	public function deleteMetadata(int $fileId): void {
+		try {
+			$this->metadataRequestService->dropMetadata($fileId);
+		} catch (Exception $e) {
+			$this->logger->warning('issue while deleteMetadata', ['exception' => $e, 'fileId' => $fileId]);
+		}
+
+		try {
+			$this->indexRequestService->dropIndex($fileId);
+		} catch (Exception $e) {
+			$this->logger->warning('issue while deleteMetadata', ['exception' => $e, 'fileId' => $fileId]);
+		}
+	}
+
+	/**
+	 * @param IQueryBuilder $qb
+	 * @param string $fileTableAlias alias of the table that contains data about files
+	 * @param string $fileIdField alias of the field that contains file ids
+	 *
+	 * @inheritDoc
+	 * @return IMetadataQuery
+	 * @see IMetadataQuery
+	 * @since 28.0.0
+	 */
+	public function getMetadataQuery(
+		IQueryBuilder $qb,
+		string $fileTableAlias,
+		string $fileIdField
+	): IMetadataQuery {
+		return new MetadataQuery($qb, $this->getKnownMetadata(), $fileTableAlias, $fileIdField);
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return IFilesMetadata
+	 * @since 28.0.0
+	 */
+	public function getKnownMetadata(): IFilesMetadata {
+		if (null !== $this->all) {
+			return $this->all;
+		}
+		$this->all = new FilesMetadata();
+
+		try {
+			$data = json_decode($this->config->getAppValue('core', self::CONFIG_KEY, '[]'), true, 127, JSON_THROW_ON_ERROR);
+			$this->all->import($data);
+		} catch (JsonException) {
+			$this->logger->warning('issue while reading stored list of metadata. Advised to run ./occ files:scan --all --generate-metadata');
+		}
+
+		return $this->all;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 * @param string $type metadata type
+	 *
+	 * @inheritDoc
+	 * @since 28.0.0
+	 * @see IMetadataValueWrapper::TYPE_INT
+	 * @see IMetadataValueWrapper::TYPE_FLOAT
+	 * @see IMetadataValueWrapper::TYPE_BOOL
+	 * @see IMetadataValueWrapper::TYPE_ARRAY
+	 * @see IMetadataValueWrapper::TYPE_STRING_LIST
+	 * @see IMetadataValueWrapper::TYPE_INT_LIST
+	 * @see IMetadataValueWrapper::TYPE_STRING
+	 */
+	public function initMetadataIndex(string $key, string $type): void {
+		$current = $this->getKnownMetadata();
+		try {
+			if ($current->getType($key) === $type && $current->isIndex($key)) {
+				return; // if key exists, with same type and is already indexed, we do nothing.
+			}
+		} catch (FilesMetadataNotFoundException) {
+			// if value does not exist, we keep on the writing of course
+		}
+
+		$current->import([$key => ['type' => $type, 'indexed' => true]]);
+		$this->config->setAppValue('core', self::CONFIG_KEY, json_encode($current));
+	}
+
+	/**
+	 * load listeners
+	 *
+	 * @param IEventDispatcher $eventDispatcher
+	 */
+	public static function loadListeners(IEventDispatcher $eventDispatcher): void {
+		$eventDispatcher->addServiceListener(NodeCreatedEvent::class, MetadataUpdate::class);
+		$eventDispatcher->addServiceListener(NodeWrittenEvent::class, MetadataUpdate::class);
+		$eventDispatcher->addServiceListener(NodeDeletedEvent::class, MetadataDelete::class);
+	}
+}
diff --git a/lib/private/FilesMetadata/Job/UpdateSingleMetadata.php b/lib/private/FilesMetadata/Job/UpdateSingleMetadata.php
new file mode 100644
index 00000000000..d628e468cdd
--- /dev/null
+++ b/lib/private/FilesMetadata/Job/UpdateSingleMetadata.php
@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Job;
+
+use OC\FilesMetadata\FilesMetadataManager;
+use OC\User\NoUserException;
+use OCP\AppFramework\Utility\ITimeFactory;
+use OCP\BackgroundJob\QueuedJob;
+use OCP\Files\IRootFolder;
+use OCP\Files\NotPermittedException;
+use OCP\FilesMetadata\Event\MetadataLiveEvent;
+use OCP\FilesMetadata\IFilesMetadataManager;
+
+/**
+ * Simple background job, created when requested by an app during the
+ * dispatch of MetadataLiveEvent.
+ * This background job will re-run the event to refresh metadata on a non-live thread.
+ *
+ * @see MetadataLiveEvent::requestBackgroundJob()
+ * @since 28.0.0
+ */
+class UpdateSingleMetadata extends QueuedJob {
+	public function __construct(
+		ITimeFactory $time,
+		private IRootFolder $rootFolder,
+		private FilesMetadataManager $filesMetadataManager,
+	) {
+		parent::__construct($time);
+	}
+
+	protected function run($argument) {
+		[$userId, $fileId] = $argument;
+
+		try {
+			$node = $this->rootFolder->getUserFolder($userId)->getById($fileId);
+			if (count($node) > 0) {
+				$file = array_shift($node);
+				$this->filesMetadataManager->refreshMetadata($file, IFilesMetadataManager::PROCESS_BACKGROUND);
+			}
+		} catch (NotPermittedException|NoUserException $e) {
+		}
+	}
+}
diff --git a/lib/private/FilesMetadata/Listener/MetadataDelete.php b/lib/private/FilesMetadata/Listener/MetadataDelete.php
new file mode 100644
index 00000000000..7f8fd035735
--- /dev/null
+++ b/lib/private/FilesMetadata/Listener/MetadataDelete.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Listener;
+
+use Exception;
+use OCP\EventDispatcher\Event;
+use OCP\EventDispatcher\IEventListener;
+use OCP\Files\Events\Node\NodeDeletedEvent;
+use OCP\FilesMetadata\IFilesMetadataManager;
+
+/**
+ * Handle file deletion event and remove stored metadata related to the deleted file
+ *
+ * @template-implements IEventListener<NodeDeletedEvent>
+ */
+class MetadataDelete implements IEventListener {
+	public function __construct(
+		private IFilesMetadataManager $filesMetadataManager,
+	) {
+	}
+
+	/**
+	 * @param Event $event
+	 */
+	public function handle(Event $event): void {
+		if (!($event instanceof NodeDeletedEvent)) {
+			return;
+		}
+
+		try {
+			$nodeId = (int)$event->getNode()->getId();
+			if ($nodeId > 0) {
+				$this->filesMetadataManager->deleteMetadata($nodeId);
+			}
+		} catch (Exception $e) {
+		}
+	}
+}
diff --git a/lib/private/FilesMetadata/Listener/MetadataUpdate.php b/lib/private/FilesMetadata/Listener/MetadataUpdate.php
new file mode 100644
index 00000000000..64c8bb474b1
--- /dev/null
+++ b/lib/private/FilesMetadata/Listener/MetadataUpdate.php
@@ -0,0 +1,61 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Listener;
+
+use Exception;
+use OCP\EventDispatcher\Event;
+use OCP\EventDispatcher\IEventListener;
+use OCP\Files\Events\Node\NodeCreatedEvent;
+use OCP\Files\Events\Node\NodeWrittenEvent;
+use OCP\FilesMetadata\IFilesMetadataManager;
+
+/**
+ * Handle file creation/modification events and initiate a new event related to the created/edited file.
+ * The generated new event is broadcast in order to obtain file related metadata from other apps.
+ * metadata will be stored in database.
+ *
+ * @template-implements IEventListener<NodeCreatedEvent|NodeWrittenEvent>
+ */
+class MetadataUpdate implements IEventListener {
+	public function __construct(
+		private IFilesMetadataManager $filesMetadataManager,
+	) {
+	}
+
+	/**
+	 * @param Event $event
+	 */
+	public function handle(Event $event): void {
+		if (!($event instanceof NodeCreatedEvent) && !($event instanceof NodeWrittenEvent)) {
+			return;
+		}
+
+		try {
+			$this->filesMetadataManager->refreshMetadata($event->getNode());
+		} catch (Exception $e) {
+		}
+	}
+}
diff --git a/lib/private/FilesMetadata/Model/FilesMetadata.php b/lib/private/FilesMetadata/Model/FilesMetadata.php
new file mode 100644
index 00000000000..a94c7a9b6ff
--- /dev/null
+++ b/lib/private/FilesMetadata/Model/FilesMetadata.php
@@ -0,0 +1,589 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Model;
+
+use JsonException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataKeyFormatException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataNotFoundException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataTypeException;
+use OCP\FilesMetadata\Model\IFilesMetadata;
+use OCP\FilesMetadata\Model\IMetadataValueWrapper;
+
+/**
+ * Model that represent metadata linked to a specific file.
+ *
+ * @inheritDoc
+ * @since 28.0.0
+ */
+class FilesMetadata implements IFilesMetadata {
+	/** @var array<string, MetadataValueWrapper> */
+	private array $metadata = [];
+	private bool $updated = false;
+	private int $lastUpdate = 0;
+	private string $syncToken = '';
+
+	public function __construct(
+		private int $fileId = 0
+	) {
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return int related file id
+	 * @since 28.0.0
+	 */
+	public function getFileId(): int {
+		return $this->fileId;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return int timestamp
+	 * @since 28.0.0
+	 */
+	public function lastUpdateTimestamp(): int {
+		return $this->lastUpdate;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return string token
+	 * @since 28.0.0
+	 */
+	public function getSyncToken(): string {
+		return $this->syncToken;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return string[] list of keys
+	 * @since 28.0.0
+	 */
+	public function getKeys(): array {
+		return array_keys($this->metadata);
+	}
+
+	/**
+	 * @param string $needle metadata key to search
+	 *
+	 * @inheritDoc
+	 * @return bool TRUE if key exist
+	 * @since 28.0.0
+	 */
+	public function hasKey(string $needle): bool {
+		return (in_array($needle, $this->getKeys()));
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return string[] list of indexes
+	 * @since 28.0.0
+	 */
+	public function getIndexes(): array {
+		$indexes = [];
+		foreach ($this->getKeys() as $key) {
+			if ($this->metadata[$key]->isIndexed()) {
+				$indexes[] = $key;
+			}
+		}
+
+		return $indexes;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return bool TRUE if key exists and is set as indexed
+	 * @since 28.0.0
+	 */
+	public function isIndex(string $key): bool {
+		return $this->metadata[$key]?->isIndexed() ?? false;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return string metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function get(string $key): string {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueString();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return int metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function getInt(string $key): int {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueInt();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return float metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function getFloat(string $key): float {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueFloat();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return bool metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function getBool(string $key): bool {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueBool();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return array metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function getArray(string $key): array {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueArray();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return string[] metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function getStringList(string $key): array {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueStringList();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return int[] metadata value
+	 * @throws FilesMetadataNotFoundException
+	 * @throws FilesMetadataTypeException
+	 * @since 28.0.0
+	 */
+	public function getIntList(string $key): array {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getValueIntList();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return string value type
+	 * @throws FilesMetadataNotFoundException
+	 * @see IMetadataValueWrapper::TYPE_STRING
+	 * @see IMetadataValueWrapper::TYPE_INT
+	 * @see IMetadataValueWrapper::TYPE_FLOAT
+	 * @see IMetadataValueWrapper::TYPE_BOOL
+	 * @see IMetadataValueWrapper::TYPE_ARRAY
+	 * @see IMetadataValueWrapper::TYPE_STRING_LIST
+	 * @see IMetadataValueWrapper::TYPE_INT_LIST
+	 * @since 28.0.0
+	 */
+	public function getType(string $key): string {
+		if (!array_key_exists($key, $this->metadata)) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		return $this->metadata[$key]->getType();
+	}
+
+	/**
+	 * @param string $key metadata key
+	 * @param string $value metadata value
+	 * @param bool $index set TRUE if value must be indexed
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function set(string $key, string $value, bool $index = false): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->get($key) === $value && $index === $this->isIndex($key)) {
+				return $this; // we ignore if value and index have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$meta = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_STRING);
+		$this->updated = true;
+		$this->metadata[$key] = $meta->setValueString($value)->setIndexed($index);
+
+		return $this;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 * @param int $value metadata value
+	 * @param bool $index set TRUE if value must be indexed
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function setInt(string $key, int $value, bool $index = false): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->getInt($key) === $value && $index === $this->isIndex($key)) {
+				return $this; // we ignore if value have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$meta = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_INT);
+		$this->metadata[$key] = $meta->setValueInt($value)->setIndexed($index);
+		$this->updated = true;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 * @param float $value metadata value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function setFloat(string $key, float $value, bool $index = false): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->getFloat($key) === $value && $index === $this->isIndex($key)) {
+				return $this; // we ignore if value have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$meta = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_FLOAT);
+		$this->metadata[$key] = $meta->setValueFloat($value)->setIndexed($index);
+		$this->updated = true;
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $key metadata key
+	 * @param bool $value metadata value
+	 * @param bool $index set TRUE if value must be indexed
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function setBool(string $key, bool $value, bool $index = false): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->getBool($key) === $value && $index === $this->isIndex($key)) {
+				return $this; // we ignore if value have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$meta = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_BOOL);
+		$this->metadata[$key] = $meta->setValueBool($value)->setIndexed($index);
+		$this->updated = true;
+
+		return $this;
+	}
+
+
+	/**
+	 * @param string $key metadata key
+	 * @param array $value metadata value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function setArray(string $key, array $value): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->getArray($key) === $value) {
+				return $this; // we ignore if value have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$meta = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_ARRAY);
+		$this->metadata[$key] = $meta->setValueArray($value);
+		$this->updated = true;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 * @param string[] $value metadata value
+	 * @param bool $index set TRUE if each values from the list must be indexed
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function setStringList(string $key, array $value, bool $index = false): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->getStringList($key) === $value) {
+				return $this; // we ignore if value have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$meta = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_STRING_LIST);
+		$this->metadata[$key] = $meta->setValueStringList($value)->setIndexed($index);
+		$this->updated = true;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 * @param int[] $value metadata value
+	 * @param bool $index set TRUE if each values from the list must be indexed
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataKeyFormatException
+	 * @since 28.0.0
+	 */
+	public function setIntList(string $key, array $value, bool $index = false): IFilesMetadata {
+		$this->confirmKeyFormat($key);
+		try {
+			if ($this->getIntList($key) === $value) {
+				return $this; // we ignore if value have not changed
+			}
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException $e) {
+			// if value does not exist, or type has changed, we keep on the writing
+		}
+
+		$valueWrapper = new MetadataValueWrapper(IMetadataValueWrapper::TYPE_STRING_LIST);
+		$this->metadata[$key] = $valueWrapper->setValueIntList($value)->setIndexed($index);
+		$this->updated = true;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $key metadata key
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @since 28.0.0
+	 */
+	public function unset(string $key): IFilesMetadata {
+		if (!array_key_exists($key, $this->metadata)) {
+			return $this;
+		}
+
+		unset($this->metadata[$key]);
+		$this->updated = true;
+
+		return $this;
+	}
+
+	/**
+	 * @param string $keyPrefix metadata key prefix
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @since 28.0.0
+	 */
+	public function removeStartsWith(string $keyPrefix): IFilesMetadata {
+		if ($keyPrefix === '') {
+			return $this;
+		}
+
+		foreach ($this->getKeys() as $key) {
+			if (str_starts_with($key, $keyPrefix)) {
+				$this->unset($key);
+			}
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string $key
+	 *
+	 * @return void
+	 * @throws FilesMetadataKeyFormatException
+	 */
+	private function confirmKeyFormat(string $key): void {
+		$acceptedChars = ['-', '_'];
+		if (ctype_alnum(str_replace($acceptedChars, '', $key))) {
+			return;
+		}
+
+		throw new FilesMetadataKeyFormatException('key can only contains alphanumerical characters, and dash (-)');
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return bool TRUE if metadata have been modified
+	 * @since 28.0.0
+	 */
+	public function updated(): bool {
+		return $this->updated;
+	}
+
+	public function jsonSerialize(bool $emptyValues = false): array {
+		$data = [];
+		foreach ($this->metadata as $metaKey => $metaValueWrapper) {
+			$data[$metaKey] = $metaValueWrapper->jsonSerialize($emptyValues);
+		}
+
+		return $data;
+	}
+
+	/**
+	 * @return array<string, string|int|bool|float|string[]|int[]>
+	 */
+	public function asArray(): array {
+		$data = [];
+		foreach ($this->metadata as $metaKey => $metaValueWrapper) {
+			try {
+				$data[$metaKey] = $metaValueWrapper->getValueAny();
+			} catch (FilesMetadataNotFoundException $e) {
+				// ignore exception
+			}
+		}
+
+		return $data;
+	}
+
+	/**
+	 * @param array $data
+	 *
+	 * @inheritDoc
+	 * @return IFilesMetadata
+	 * @since 28.0.0
+	 */
+	public function import(array $data): IFilesMetadata {
+		foreach ($data as $k => $v) {
+			$valueWrapper = new MetadataValueWrapper();
+			$this->metadata[$k] = $valueWrapper->import($v);
+		}
+		$this->updated = false;
+
+		return $this;
+	}
+
+	/**
+	 * import data from database to configure this model
+	 *
+	 * @param array $data
+	 * @param string $prefix
+	 *
+	 * @return IFilesMetadata
+	 * @throws FilesMetadataNotFoundException
+	 * @since 28.0.0
+	 */
+	public function importFromDatabase(array $data, string $prefix = ''): IFilesMetadata {
+		try {
+			$this->syncToken = $data[$prefix . 'sync_token'] ?? '';
+
+			return $this->import(
+				json_decode(
+					$data[$prefix . 'json'] ?? '[]',
+					true,
+					512,
+					JSON_THROW_ON_ERROR
+				)
+			);
+		} catch (JsonException $e) {
+			throw new FilesMetadataNotFoundException();
+		}
+	}
+}
diff --git a/lib/private/FilesMetadata/Model/MetadataQuery.php b/lib/private/FilesMetadata/Model/MetadataQuery.php
new file mode 100644
index 00000000000..9ff69e9516e
--- /dev/null
+++ b/lib/private/FilesMetadata/Model/MetadataQuery.php
@@ -0,0 +1,165 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Model;
+
+use OC\FilesMetadata\Service\IndexRequestService;
+use OC\FilesMetadata\Service\MetadataRequestService;
+use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\FilesMetadata\Exceptions\FilesMetadataNotFoundException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataTypeException;
+use OCP\FilesMetadata\Model\IFilesMetadata;
+use OCP\FilesMetadata\Model\IMetadataQuery;
+use OCP\FilesMetadata\Model\IMetadataValueWrapper;
+
+/**
+ * @inheritDoc
+ * @since 28.0.0
+ */
+class MetadataQuery implements IMetadataQuery {
+	private array $knownJoinedIndex = [];
+	public function __construct(
+		private IQueryBuilder $queryBuilder,
+		private IFilesMetadata $knownMetadata,
+		private string $fileTableAlias = 'fc',
+		private string $fileIdField = 'fileid',
+		private string $alias = 'meta',
+		private string $aliasIndexPrefix = 'meta_index'
+	) {
+	}
+
+	/**
+	 * @inheritDoc
+	 * @see self::extractMetadata()
+	 * @since 28.0.0
+	 */
+	public function retrieveMetadata(): void {
+		$this->queryBuilder->selectAlias($this->alias . '.json', 'meta_json');
+		$this->queryBuilder->leftJoin(
+			$this->fileTableAlias, MetadataRequestService::TABLE_METADATA, $this->alias,
+			$this->queryBuilder->expr()->eq($this->fileTableAlias . '.' . $this->fileIdField, $this->alias . '.file_id')
+		);
+	}
+
+	/**
+	 * @param array $row result row
+	 *
+	 * @inheritDoc
+	 * @return IFilesMetadata metadata
+	 * @see self::retrieveMetadata()
+	 * @since 28.0.0
+	 */
+	public function extractMetadata(array $row): IFilesMetadata {
+		$fileId = (array_key_exists($this->fileIdField, $row)) ? $row[$this->fileIdField] : 0;
+		$metadata = new FilesMetadata((int)$fileId);
+		try {
+			$metadata->importFromDatabase($row, $this->alias . '_');
+		} catch (FilesMetadataNotFoundException) {
+			// can be ignored as files' metadata are optional and might not exist in database
+		}
+
+		return $metadata;
+	}
+
+	/**
+	 * @param string $metadataKey metadata key
+	 * @param bool $enforce limit the request only to existing metadata
+	 *
+	 * @inheritDoc
+	 * @since 28.0.0
+	 */
+	public function joinIndex(string $metadataKey, bool $enforce = false): string {
+		if (array_key_exists($metadataKey, $this->knownJoinedIndex)) {
+			return $this->knownJoinedIndex[$metadataKey];
+		}
+
+		$aliasIndex = $this->aliasIndexPrefix . '_' . count($this->knownJoinedIndex);
+		$this->knownJoinedIndex[$metadataKey] = $aliasIndex;
+
+		$expr = $this->queryBuilder->expr();
+		$andX = $expr->andX($expr->eq($aliasIndex . '.file_id', $this->fileTableAlias . '.' . $this->fileIdField));
+		$andX->add($expr->eq($this->getMetadataKeyField($metadataKey), $this->queryBuilder->createNamedParameter($metadataKey)));
+
+		if ($enforce) {
+			$this->queryBuilder->rightJoin(
+				$this->fileTableAlias,
+				IndexRequestService::TABLE_METADATA_INDEX,
+				$aliasIndex,
+				$andX
+			);
+		} else {
+			$this->queryBuilder->leftJoin(
+				$this->fileTableAlias,
+				IndexRequestService::TABLE_METADATA_INDEX,
+				$aliasIndex,
+				$andX
+			);
+		}
+
+		return $aliasIndex;
+	}
+
+	/**
+	 * @throws FilesMetadataNotFoundException
+	 */
+	public function joinedTableAlias(string $metadataKey): string {
+		if (!array_key_exists($metadataKey, $this->knownJoinedIndex)) {
+			throw new FilesMetadataNotFoundException('table related to ' . $metadataKey . ' not initiated, you need to use leftJoin() first.');
+		}
+
+		return $this->knownJoinedIndex[$metadataKey];
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $metadataKey metadata key
+	 *
+	 * @return string table field
+	 * @throws FilesMetadataNotFoundException
+	 * @since 28.0.0
+	 */
+	public function getMetadataKeyField(string $metadataKey): string {
+		return $this->joinedTableAlias($metadataKey) . '.meta_key';
+	}
+
+	/**
+	 * @inheritDoc
+	 *
+	 * @param string $metadataKey metadata key
+	 *
+	 * @return string table field
+	 * @throws FilesMetadataNotFoundException if metadataKey is not known
+	 * @throws FilesMetadataTypeException is metadataKey is not set as indexed
+	 * @since 28.0.0
+	 */
+	public function getMetadataValueField(string $metadataKey): string {
+		return match ($this->knownMetadata->getType($metadataKey)) {
+			IMetadataValueWrapper::TYPE_STRING => $this->joinedTableAlias($metadataKey) . '.meta_value_string',
+			IMetadataValueWrapper::TYPE_INT, IMetadataValueWrapper::TYPE_BOOL => $this->joinedTableAlias($metadataKey) . '.meta_value_int',
+			default => throw new FilesMetadataTypeException('metadata is not set as indexed'),
+		};
+	}
+}
diff --git a/lib/private/FilesMetadata/Model/MetadataValueWrapper.php b/lib/private/FilesMetadata/Model/MetadataValueWrapper.php
new file mode 100644
index 00000000000..159cd1e6fd1
--- /dev/null
+++ b/lib/private/FilesMetadata/Model/MetadataValueWrapper.php
@@ -0,0 +1,397 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Model;
+
+use OCP\FilesMetadata\Exceptions\FilesMetadataNotFoundException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataTypeException;
+use OCP\FilesMetadata\Model\IMetadataValueWrapper;
+
+/**
+ * @inheritDoc
+ * @see IFilesMetadata
+ * @since 28.0.0
+ */
+class MetadataValueWrapper implements IMetadataValueWrapper {
+	private string $type;
+	/** @var string|int|float|bool|array|string[]|int[] */
+	private mixed $value = null;
+	private bool $indexed = false;
+
+	/**
+	 * @param string $type value type
+	 *
+	 * @inheritDoc
+	 * @see self::TYPE_INT
+	 * @see self::TYPE_FLOAT
+	 * @see self::TYPE_BOOL
+	 * @see self::TYPE_ARRAY
+	 * @see self::TYPE_STRING_LIST
+	 * @see self::TYPE_INT_LIST
+	 * @see self::TYPE_STRING
+	 * @since 28.0.0
+	 */
+	public function __construct(string $type = '') {
+		$this->type = $type;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return string value type
+	 * @see self::TYPE_INT
+	 * @see self::TYPE_FLOAT
+	 * @see self::TYPE_BOOL
+	 * @see self::TYPE_ARRAY
+	 * @see self::TYPE_STRING_LIST
+	 * @see self::TYPE_INT_LIST
+	 * @see self::TYPE_STRING
+	 * @since 28.0.0
+	 */
+	public function getType(): string {
+		return $this->type;
+	}
+
+	/**
+	 * @param string $type value type
+	 *
+	 * @inheritDoc
+	 * @return bool
+	 * @see self::TYPE_INT
+	 * @see self::TYPE_FLOAT
+	 * @see self::TYPE_BOOL
+	 * @see self::TYPE_ARRAY
+	 * @see self::TYPE_STRING_LIST
+	 * @see self::TYPE_INT_LIST
+	 * @see self::TYPE_STRING
+	 * @since 28.0.0
+	 */
+	public function isType(string $type): bool {
+		return (strtolower($type) === strtolower($this->type));
+	}
+
+	/**
+	 * @param string $type value type
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if type cannot be confirmed
+	 * @see self::TYPE_INT
+	 * @see self::TYPE_BOOL
+	 * @see self::TYPE_ARRAY
+	 * @see self::TYPE_STRING_LIST
+	 * @see self::TYPE_INT_LIST
+	 * @see self::TYPE_STRING
+	 * @see self::TYPE_FLOAT
+	 * @since 28.0.0
+	 */
+	public function assertType(string $type): self {
+		if (!$this->isType($type)) {
+			throw new FilesMetadataTypeException('type is \'' . $this->getType() . '\', expecting \'' . $type . '\'');
+		}
+
+		return $this;
+	}
+
+	/**
+	 * @param string $value string to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a string
+	 * @since 28.0.0
+	 */
+	public function setValueString(string $value): self {
+		$this->assertType(self::TYPE_STRING);
+		$this->value = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @param int $value int to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store an int
+	 * @since 28.0.0
+	 */
+	public function setValueInt(int $value): self {
+		$this->assertType(self::TYPE_INT);
+		$this->value = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @param float $value float to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a float
+	 * @since 28.0.0
+	 */
+	public function setValueFloat(float $value): self {
+		$this->assertType(self::TYPE_FLOAT);
+		$this->value = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @param bool $value bool to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a bool
+	 * @since 28.0.0
+	 */
+	public function setValueBool(bool $value): self {
+		$this->assertType(self::TYPE_BOOL);
+		$this->value = $value;
+
+
+		return $this;
+	}
+
+	/**
+	 * @param array $value array to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store an array
+	 * @since 28.0.0
+	 */
+	public function setValueArray(array $value): self {
+		$this->assertType(self::TYPE_ARRAY);
+		$this->value = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @param string[] $value string list to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a string list
+	 * @since 28.0.0
+	 */
+	public function setValueStringList(array $value): self {
+		$this->assertType(self::TYPE_STRING_LIST);
+		// TODO confirm value is an array or string ?
+		$this->value = $value;
+
+		return $this;
+	}
+
+	/**
+	 * @param int[] $value int list to be set as value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @throws FilesMetadataTypeException if wrapper was not set to store an int list
+	 * @since 28.0.0
+	 */
+	public function setValueIntList(array $value): self {
+		$this->assertType(self::TYPE_INT_LIST);
+		// TODO confirm value is an array of int ?
+		$this->value = $value;
+
+		return $this;
+	}
+
+
+	/**
+	 * @inheritDoc
+	 * @return string set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a string
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueString(): string {
+		$this->assertType(self::TYPE_STRING);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (string)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return int set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store an int
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueInt(): int {
+		$this->assertType(self::TYPE_INT);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (int)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return float set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a float
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueFloat(): float {
+		$this->assertType(self::TYPE_FLOAT);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (float)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return bool set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a bool
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueBool(): bool {
+		$this->assertType(self::TYPE_BOOL);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (bool)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return array set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store an array
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueArray(): array {
+		$this->assertType(self::TYPE_ARRAY);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (array)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return string[] set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store a string list
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueStringList(): array {
+		$this->assertType(self::TYPE_STRING_LIST);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (array)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return int[] set value
+	 * @throws FilesMetadataTypeException if wrapper was not set to store an int list
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueIntList(): array {
+		$this->assertType(self::TYPE_INT_LIST);
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return (array)$this->value;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return string|int|float|bool|array|string[]|int[] set value
+	 * @throws FilesMetadataNotFoundException if value is not set
+	 * @since 28.0.0
+	 */
+	public function getValueAny(): mixed {
+		if (null === $this->value) {
+			throw new FilesMetadataNotFoundException('value is not set');
+		}
+
+		return $this->value;
+	}
+
+	/**
+	 * @param bool $indexed TRUE to set the stored value as an indexed value
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @since 28.0.0
+	 */
+	public function setIndexed(bool $indexed): self {
+		$this->indexed = $indexed;
+
+		return $this;
+	}
+
+	/**
+	 * @inheritDoc
+	 * @return bool TRUE if value is an indexed value
+	 * @since 28.0.0
+	 */
+	public function isIndexed(): bool {
+		return $this->indexed;
+	}
+
+	/**
+	 * @param array $data serialized version of the object
+	 *
+	 * @inheritDoc
+	 * @return self
+	 * @see jsonSerialize
+	 * @since 28.0.0
+	 */
+	public function import(array $data): self {
+		$this->value = $data['value'] ?? null;
+		$this->type = $data['type'] ?? '';
+		$this->setIndexed($data['indexed'] ?? false);
+
+		return $this;
+	}
+
+	public function jsonSerialize(bool $emptyValues = false): array {
+		return [
+			'value' => ($emptyValues) ? null : $this->value,
+			'type' => $this->getType(),
+			'indexed' => $this->isIndexed()
+		];
+	}
+}
diff --git a/lib/private/FilesMetadata/Service/IndexRequestService.php b/lib/private/FilesMetadata/Service/IndexRequestService.php
new file mode 100644
index 00000000000..6530dabd1c3
--- /dev/null
+++ b/lib/private/FilesMetadata/Service/IndexRequestService.php
@@ -0,0 +1,195 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Service;
+
+use OCP\DB\Exception as DbException;
+use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\FilesMetadata\Exceptions\FilesMetadataNotFoundException;
+use OCP\FilesMetadata\Exceptions\FilesMetadataTypeException;
+use OCP\FilesMetadata\Model\IFilesMetadata;
+use OCP\FilesMetadata\Model\IMetadataValueWrapper;
+use OCP\IDBConnection;
+use Psr\Log\LoggerInterface;
+
+/**
+ * manage sql request to the metadata_index table
+ */
+class IndexRequestService {
+	public const TABLE_METADATA_INDEX = 'files_metadata_index';
+
+	public function __construct(
+		private IDBConnection $dbConnection,
+		private LoggerInterface $logger
+	) {
+	}
+
+	/**
+	 * update the index for a specific metadata key
+	 *
+	 * @param IFilesMetadata $filesMetadata metadata
+	 * @param string $key metadata key to update
+	 *
+	 * @throws DbException
+	 */
+	public function updateIndex(IFilesMetadata $filesMetadata, string $key): void {
+		$fileId = $filesMetadata->getFileId();
+		try {
+			$metadataType = $filesMetadata->getType($key);
+		} catch (FilesMetadataNotFoundException $e) {
+			return;
+		}
+
+		/**
+		 * might look harsh, but a lot simpler than comparing current indexed data, as we can expect
+		 * conflict with a change of types.
+		 * We assume that each time one random metadata were modified we can drop all index for this
+		 * key and recreate them.
+		 * To make it slightly cleaner, we'll use transaction
+		 */
+		$this->dbConnection->beginTransaction();
+		try {
+			$this->dropIndex($fileId, $key);
+			match ($metadataType) {
+				IMetadataValueWrapper::TYPE_STRING => $this->insertIndexString($fileId, $key, $filesMetadata->get($key)),
+				IMetadataValueWrapper::TYPE_INT => $this->insertIndexInt($fileId, $key, $filesMetadata->getInt($key)),
+				IMetadataValueWrapper::TYPE_BOOL => $this->insertIndexBool($fileId, $key, $filesMetadata->getBool($key)),
+				IMetadataValueWrapper::TYPE_STRING_LIST => $this->insertIndexStringList($fileId, $key, $filesMetadata->getStringList($key)),
+				IMetadataValueWrapper::TYPE_INT_LIST => $this->insertIndexIntList($fileId, $key, $filesMetadata->getIntList($key))
+			};
+		} catch (FilesMetadataNotFoundException|FilesMetadataTypeException|DbException $e) {
+			$this->dbConnection->rollBack();
+			$this->logger->warning('issue while updateIndex', ['exception' => $e, 'fileId' => $fileId, 'key' => $key]);
+		}
+
+		$this->dbConnection->commit();
+	}
+
+	/**
+	 * insert a new entry in the metadata_index table for a string value
+	 *
+	 * @param int $fileId file id
+	 * @param string $key metadata key
+	 * @param string $value metadata value
+	 *
+	 * @throws DbException
+	 */
+	private function insertIndexString(int $fileId, string $key, string $value): void {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$qb->insert(self::TABLE_METADATA_INDEX)
+		   ->setValue('meta_key', $qb->createNamedParameter($key))
+		   ->setValue('meta_value_string', $qb->createNamedParameter($value))
+		   ->setValue('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT));
+		$qb->executeStatement();
+	}
+
+	/**
+	 * insert a new entry in the metadata_index table for an int value
+	 *
+	 * @param int $fileId file id
+	 * @param string $key metadata key
+	 * @param int $value metadata value
+	 *
+	 * @throws DbException
+	 */
+	public function insertIndexInt(int $fileId, string $key, int $value): void {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$qb->insert(self::TABLE_METADATA_INDEX)
+		   ->setValue('meta_key', $qb->createNamedParameter($key))
+		   ->setValue('meta_value_int', $qb->createNamedParameter($value, IQueryBuilder::PARAM_INT))
+		   ->setValue('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT));
+		$qb->executeStatement();
+	}
+
+	/**
+	 * insert a new entry in the metadata_index table for a bool value
+	 *
+	 * @param int $fileId file id
+	 * @param string $key metadata key
+	 * @param bool $value metadata value
+	 *
+	 * @throws DbException
+	 */
+	public function insertIndexBool(int $fileId, string $key, bool $value): void {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$qb->insert(self::TABLE_METADATA_INDEX)
+		   ->setValue('meta_key', $qb->createNamedParameter($key))
+		   ->setValue('meta_value_int', $qb->createNamedParameter(($value) ? '1' : '0', IQueryBuilder::PARAM_INT))
+		   ->setValue('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT));
+		$qb->executeStatement();
+	}
+
+	/**
+	 * insert entries in the metadata_index table for list of string
+	 *
+	 * @param int $fileId file id
+	 * @param string $key metadata key
+	 * @param string[] $values metadata values
+	 *
+	 * @throws DbException
+	 */
+	public function insertIndexStringList(int $fileId, string $key, array $values): void {
+		foreach ($values as $value) {
+			$this->insertIndexString($fileId, $key, $value);
+		}
+	}
+
+	/**
+	 * insert entries in the metadata_index table for list of int
+	 *
+	 * @param int $fileId file id
+	 * @param string $key metadata key
+	 * @param int[] $values metadata values
+	 *
+	 * @throws DbException
+	 */
+	public function insertIndexIntList(int $fileId, string $key, array $values): void {
+		foreach ($values as $value) {
+			$this->insertIndexInt($fileId, $key, $value);
+		}
+	}
+
+	/**
+	 * drop indexes related to a file id
+	 * if a key is specified, only drop entries related to it
+	 *
+	 * @param int $fileId file id
+	 * @param string $key metadata key
+	 *
+	 * @throws DbException
+	 */
+	public function dropIndex(int $fileId, string $key = ''): void {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$expr = $qb->expr();
+		$qb->delete(self::TABLE_METADATA_INDEX)
+		   ->where($expr->eq('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
+
+		if ($key !== '') {
+			$qb->andWhere($expr->eq('meta_key', $qb->createNamedParameter($key)));
+		}
+
+		$qb->executeStatement();
+	}
+}
diff --git a/lib/private/FilesMetadata/Service/MetadataRequestService.php b/lib/private/FilesMetadata/Service/MetadataRequestService.php
new file mode 100644
index 00000000000..85874e92d4a
--- /dev/null
+++ b/lib/private/FilesMetadata/Service/MetadataRequestService.php
@@ -0,0 +1,160 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * @copyright 2023 Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @author Maxence Lange <maxence@artificial-owl.com>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace OC\FilesMetadata\Service;
+
+use OC\FilesMetadata\Model\FilesMetadata;
+use OCP\DB\Exception;
+use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\FilesMetadata\Exceptions\FilesMetadataNotFoundException;
+use OCP\FilesMetadata\Model\IFilesMetadata;
+use OCP\IDBConnection;
+use Psr\Log\LoggerInterface;
+
+/**
+ * manage sql request to the metadata table
+ */
+class MetadataRequestService {
+	public const TABLE_METADATA = 'files_metadata';
+
+	public function __construct(
+		private IDBConnection $dbConnection,
+		private LoggerInterface $logger
+	) {
+	}
+
+	/**
+	 * store metadata into database
+	 *
+	 * @param IFilesMetadata $filesMetadata
+	 *
+	 * @throws Exception
+	 */
+	public function store(IFilesMetadata $filesMetadata): void {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$qb->insert(self::TABLE_METADATA)
+		   ->setValue('file_id', $qb->createNamedParameter($filesMetadata->getFileId(), IQueryBuilder::PARAM_INT))
+		   ->setValue('json', $qb->createNamedParameter(json_encode($filesMetadata->jsonSerialize())))
+		   ->setValue('sync_token', $qb->createNamedParameter($this->generateSyncToken()))
+		   ->setValue('last_update', (string) $qb->createFunction('NOW()'));
+		$qb->executeStatement();
+	}
+
+	/**
+	 * returns metadata for a file id
+	 *
+	 * @param int $fileId file id
+	 *
+	 * @return IFilesMetadata
+	 * @throws FilesMetadataNotFoundException if no metadata are found in database
+	 */
+	public function getMetadataFromFileId(int $fileId): IFilesMetadata {
+		try {
+			$qb = $this->dbConnection->getQueryBuilder();
+			$qb->select('json', 'sync_token')->from(self::TABLE_METADATA);
+			$qb->where(
+				$qb->expr()->eq('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT))
+			);
+			$result = $qb->executeQuery();
+			$data = $result->fetch();
+			$result->closeCursor();
+		} catch (Exception $e) {
+			$this->logger->warning(
+				'exception while getMetadataFromDatabase()', ['exception' => $e, 'fileId' => $fileId]
+			);
+			throw new FilesMetadataNotFoundException();
+		}
+
+		if ($data === false) {
+			throw new FilesMetadataNotFoundException();
+		}
+
+		$metadata = new FilesMetadata($fileId);
+		$metadata->importFromDatabase($data);
+
+		return $metadata;
+	}
+
+	/**
+	 * drop metadata related to a file id
+	 *
+	 * @param int $fileId file id
+	 *
+	 * @return void
+	 * @throws Exception
+	 */
+	public function dropMetadata(int $fileId): void {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$qb->delete(self::TABLE_METADATA)
+		   ->where($qb->expr()->eq('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
+		$qb->executeStatement();
+	}
+
+	/**
+	 * update metadata in the database
+	 *
+	 * @param IFilesMetadata $filesMetadata metadata
+	 *
+	 * @return int number of affected rows
+	 * @throws Exception
+	 */
+	public function updateMetadata(IFilesMetadata $filesMetadata): int {
+		$qb = $this->dbConnection->getQueryBuilder();
+		$expr = $qb->expr();
+
+		$qb->update(self::TABLE_METADATA)
+		   ->set('json', $qb->createNamedParameter(json_encode($filesMetadata->jsonSerialize())))
+		   ->set('sync_token', $qb->createNamedParameter($this->generateSyncToken()))
+		   ->set('last_update', $qb->createFunction('NOW()'))
+		   ->where(
+		   	$expr->andX(
+		   		$expr->eq('file_id', $qb->createNamedParameter($filesMetadata->getFileId(), IQueryBuilder::PARAM_INT)),
+		   		$expr->eq('sync_token', $qb->createNamedParameter($filesMetadata->getSyncToken()))
+		   	)
+		   );
+
+		return $qb->executeStatement();
+	}
+
+	/**
+	 * generate a random token
+	 * @return string
+	 */
+	private function generateSyncToken(): string {
+		$chars = 'qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890';
+
+		$str = '';
+		$max = strlen($chars);
+		for ($i = 0; $i < 7; $i++) {
+			try {
+				$str .= $chars[random_int(0, $max - 2)];
+			} catch (\Exception $e) {
+				$this->logger->warning('exception during generateSyncToken', ['exception' => $e]);
+			}
+		}
+
+		return $str;
+	}
+}
diff --git a/lib/private/Server.php b/lib/private/Server.php
index 77791c49e8b..31e4a9f79e2 100644
--- a/lib/private/Server.php
+++ b/lib/private/Server.php
@@ -102,6 +102,7 @@ use OC\Files\Storage\StorageFactory;
 use OC\Files\Template\TemplateManager;
 use OC\Files\Type\Loader;
 use OC\Files\View;
+use OC\FilesMetadata\FilesMetadataManager;
 use OC\FullTextSearch\FullTextSearchManager;
 use OC\Http\Client\ClientService;
 use OC\Http\Client\NegativeDnsCache;
@@ -196,6 +197,7 @@ use OCP\Files\Lock\ILockManager;
 use OCP\Files\Mount\IMountManager;
 use OCP\Files\Storage\IStorageFactory;
 use OCP\Files\Template\ITemplateManager;
+use OCP\FilesMetadata\IFilesMetadataManager;
 use OCP\FullTextSearch\IFullTextSearchManager;
 use OCP\GlobalScale\IConfig;
 use OCP\Group\ISubAdmin;
@@ -1401,6 +1403,7 @@ class Server extends ServerContainer implements IServerContainer {
 		$this->registerAlias(\OCP\Dashboard\IManager::class, \OC\Dashboard\Manager::class);
 
 		$this->registerAlias(IFullTextSearchManager::class, FullTextSearchManager::class);
+		$this->registerAlias(IFilesMetadataManager::class, FilesMetadataManager::class);
 
 		$this->registerAlias(ISubAdmin::class, SubAdmin::class);
 
@@ -1480,6 +1483,8 @@ class Server extends ServerContainer implements IServerContainer {
 		$eventDispatcher->addServiceListener(PostLoginEvent::class, UserLoggedInListener::class);
 		$eventDispatcher->addServiceListener(UserChangedEvent::class, UserChangedListener::class);
 		$eventDispatcher->addServiceListener(BeforeUserDeletedEvent::class, BeforeUserDeletedListener::class);
+
+		FilesMetadataManager::loadListeners($eventDispatcher);
 	}
 
 	/**