nextcloud / server

lib/private/Files/Cache/SearchBuilder.php

Indentation +195 added lines, -195 removed lines

@@ -37,199 +37,199 @@
  * Tools for transforming search queries into database queries
  */
 class SearchBuilder {
-	protected static $searchOperatorMap = [
-		ISearchComparison::COMPARE_LIKE => 'iLike',
-		ISearchComparison::COMPARE_EQUAL => 'eq',
-		ISearchComparison::COMPARE_GREATER_THAN => 'gt',
-		ISearchComparison::COMPARE_GREATER_THAN_EQUAL => 'gte',
-		ISearchComparison::COMPARE_LESS_THAN => 'lt',
-		ISearchComparison::COMPARE_LESS_THAN_EQUAL => 'lte',
-	];
-
-	protected static $searchOperatorNegativeMap = [
-		ISearchComparison::COMPARE_LIKE => 'notLike',
-		ISearchComparison::COMPARE_EQUAL => 'neq',
-		ISearchComparison::COMPARE_GREATER_THAN => 'lte',
-		ISearchComparison::COMPARE_GREATER_THAN_EQUAL => 'lt',
-		ISearchComparison::COMPARE_LESS_THAN => 'gte',
-		ISearchComparison::COMPARE_LESS_THAN_EQUAL => 'lt',
-	];
-
-	public const TAG_FAVORITE = '_$!<Favorite>!$_';
-
-	/** @var IMimeTypeLoader */
-	private $mimetypeLoader;
-
-	public function __construct(
-		IMimeTypeLoader $mimetypeLoader
-	) {
-		$this->mimetypeLoader = $mimetypeLoader;
-	}
-
-	/**
-	 * Whether or not the tag tables should be joined to complete the search
-	 *
-	 * @param ISearchOperator $operator
-	 * @return boolean
-	 */
-	public function shouldJoinTags(ISearchOperator $operator) {
-		if ($operator instanceof ISearchBinaryOperator) {
-			return array_reduce($operator->getArguments(), function ($shouldJoin, ISearchOperator $operator) {
-				return $shouldJoin || $this->shouldJoinTags($operator);
-			}, false);
-		} elseif ($operator instanceof ISearchComparison) {
-			return $operator->getField() === 'tagname' || $operator->getField() === 'favorite';
-		}
-		return false;
-	}
-
-	/**
-	 * @param IQueryBuilder $builder
-	 * @param ISearchOperator $operator
-	 */
-	public function searchOperatorArrayToDBExprArray(IQueryBuilder $builder, array $operators) {
-		return array_filter(array_map(function ($operator) use ($builder) {
-			return $this->searchOperatorToDBExpr($builder, $operator);
-		}, $operators));
-	}
-
-	public function searchOperatorToDBExpr(IQueryBuilder $builder, ISearchOperator $operator) {
-		$expr = $builder->expr();
-		if ($operator instanceof ISearchBinaryOperator) {
-			if (count($operator->getArguments()) === 0) {
-				return null;
-			}
-
-			switch ($operator->getType()) {
-				case ISearchBinaryOperator::OPERATOR_NOT:
-					$negativeOperator = $operator->getArguments()[0];
-					if ($negativeOperator instanceof ISearchComparison) {
-						return $this->searchComparisonToDBExpr($builder, $negativeOperator, self::$searchOperatorNegativeMap);
-					} 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()));
-				case ISearchBinaryOperator::OPERATOR_OR:
-					return call_user_func_array([$expr, 'orX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments()));
-				default:
-					throw new \InvalidArgumentException('Invalid operator type: ' . $operator->getType());
-			}
-		} elseif ($operator instanceof ISearchComparison) {
-			return $this->searchComparisonToDBExpr($builder, $operator, self::$searchOperatorMap);
-		} else {
-			throw new \InvalidArgumentException('Invalid operator type: ' . get_class($operator));
-		}
-	}
-
-	private function searchComparisonToDBExpr(IQueryBuilder $builder, ISearchComparison $comparison, array $operatorMap) {
-		$this->validateComparison($comparison);
-
-		[$field, $value, $type] = $this->getOperatorFieldAndValue($comparison);
-		if (isset($operatorMap[$type])) {
-			$queryOperator = $operatorMap[$type];
-			return $builder->expr()->$queryOperator($field, $this->getParameterForValue($builder, $value));
-		} else {
-			throw new \InvalidArgumentException('Invalid operator type: ' . $comparison->getType());
-		}
-	}
-
-	private function getOperatorFieldAndValue(ISearchComparison $operator) {
-		$field = $operator->getField();
-		$value = $operator->getValue();
-		$type = $operator->getType();
-		if ($field === 'mimetype') {
-			$value = (string)$value;
-			if ($operator->getType() === ISearchComparison::COMPARE_EQUAL) {
-				$value = (int)$this->mimetypeLoader->getId($value);
-			} elseif ($operator->getType() === ISearchComparison::COMPARE_LIKE) {
-				// transform "mimetype='foo/%'" to "mimepart='foo'"
-				if (preg_match('|(.+)/%|', $value, $matches)) {
-					$field = 'mimepart';
-					$value = (int)$this->mimetypeLoader->getId($matches[1]);
-					$type = ISearchComparison::COMPARE_EQUAL;
-				} elseif (strpos($value, '%') !== false) {
-					throw new \InvalidArgumentException('Unsupported query value for mimetype: ' . $value . ', only values in the format "mime/type" or "mime/%" are supported');
-				} else {
-					$field = 'mimetype';
-					$value = (int)$this->mimetypeLoader->getId($value);
-					$type = ISearchComparison::COMPARE_EQUAL;
-				}
-			}
-		} elseif ($field === 'favorite') {
-			$field = 'tag.category';
-			$value = self::TAG_FAVORITE;
-		} elseif ($field === 'tagname') {
-			$field = 'tag.category';
-		} elseif ($field === 'fileid') {
-			$field = 'file.fileid';
-		} elseif ($field === 'path' && $type === ISearchComparison::COMPARE_EQUAL) {
-			$field = 'path_hash';
-			$value = md5((string)$value);
-		}
-		return [$field, $value, $type];
-	}
-
-	private function validateComparison(ISearchComparison $operator) {
-		$types = [
-			'mimetype' => 'string',
-			'mtime' => 'integer',
-			'name' => 'string',
-			'path' => 'string',
-			'size' => 'integer',
-			'tagname' => 'string',
-			'favorite' => 'boolean',
-			'fileid' => 'integer',
-			'storage' => 'integer',
-		];
-		$comparisons = [
-			'mimetype' => ['eq', 'like'],
-			'mtime' => ['eq', 'gt', 'lt', 'gte', 'lte'],
-			'name' => ['eq', 'like'],
-			'path' => ['eq', 'like'],
-			'size' => ['eq', 'gt', 'lt', 'gte', 'lte'],
-			'tagname' => ['eq', 'like'],
-			'favorite' => ['eq'],
-			'fileid' => ['eq'],
-			'storage' => ['eq'],
-		];
-
-		if (!isset($types[$operator->getField()])) {
-			throw new \InvalidArgumentException('Unsupported comparison field ' . $operator->getField());
-		}
-		$type = $types[$operator->getField()];
-		if (gettype($operator->getValue()) !== $type) {
-			throw new \InvalidArgumentException('Invalid type for field ' . $operator->getField());
-		}
-		if (!in_array($operator->getType(), $comparisons[$operator->getField()])) {
-			throw new \InvalidArgumentException('Unsupported comparison for field  ' . $operator->getField() . ': ' . $operator->getType());
-		}
-	}
-
-	private function getParameterForValue(IQueryBuilder $builder, $value) {
-		if ($value instanceof \DateTime) {
-			$value = $value->getTimestamp();
-		}
-		if (is_numeric($value)) {
-			$type = IQueryBuilder::PARAM_INT;
-		} else {
-			$type = IQueryBuilder::PARAM_STR;
-		}
-		return $builder->createNamedParameter($value, $type);
-	}
-
-	/**
-	 * @param IQueryBuilder $query
-	 * @param ISearchOrder[] $orders
-	 */
-	public function addSearchOrdersToQuery(IQueryBuilder $query, array $orders) {
-		foreach ($orders as $order) {
-			$field = $order->getField();
-			if ($field === 'fileid') {
-				$field = 'file.fileid';
-			}
-			$query->addOrderBy($field, $order->getDirection());
-		}
-	}
+    protected static $searchOperatorMap = [
+        ISearchComparison::COMPARE_LIKE => 'iLike',
+        ISearchComparison::COMPARE_EQUAL => 'eq',
+        ISearchComparison::COMPARE_GREATER_THAN => 'gt',
+        ISearchComparison::COMPARE_GREATER_THAN_EQUAL => 'gte',
+        ISearchComparison::COMPARE_LESS_THAN => 'lt',
+        ISearchComparison::COMPARE_LESS_THAN_EQUAL => 'lte',
+    ];
+
+    protected static $searchOperatorNegativeMap = [
+        ISearchComparison::COMPARE_LIKE => 'notLike',
+        ISearchComparison::COMPARE_EQUAL => 'neq',
+        ISearchComparison::COMPARE_GREATER_THAN => 'lte',
+        ISearchComparison::COMPARE_GREATER_THAN_EQUAL => 'lt',
+        ISearchComparison::COMPARE_LESS_THAN => 'gte',
+        ISearchComparison::COMPARE_LESS_THAN_EQUAL => 'lt',
+    ];
+
+    public const TAG_FAVORITE = '_$!<Favorite>!$_';
+
+    /** @var IMimeTypeLoader */
+    private $mimetypeLoader;
+
+    public function __construct(
+        IMimeTypeLoader $mimetypeLoader
+    ) {
+        $this->mimetypeLoader = $mimetypeLoader;
+    }
+
+    /**
+     * Whether or not the tag tables should be joined to complete the search
+     *
+     * @param ISearchOperator $operator
+     * @return boolean
+     */
+    public function shouldJoinTags(ISearchOperator $operator) {
+        if ($operator instanceof ISearchBinaryOperator) {
+            return array_reduce($operator->getArguments(), function ($shouldJoin, ISearchOperator $operator) {
+                return $shouldJoin || $this->shouldJoinTags($operator);
+            }, false);
+        } elseif ($operator instanceof ISearchComparison) {
+            return $operator->getField() === 'tagname' || $operator->getField() === 'favorite';
+        }
+        return false;
+    }
+
+    /**
+     * @param IQueryBuilder $builder
+     * @param ISearchOperator $operator
+     */
+    public function searchOperatorArrayToDBExprArray(IQueryBuilder $builder, array $operators) {
+        return array_filter(array_map(function ($operator) use ($builder) {
+            return $this->searchOperatorToDBExpr($builder, $operator);
+        }, $operators));
+    }
+
+    public function searchOperatorToDBExpr(IQueryBuilder $builder, ISearchOperator $operator) {
+        $expr = $builder->expr();
+        if ($operator instanceof ISearchBinaryOperator) {
+            if (count($operator->getArguments()) === 0) {
+                return null;
+            }
+
+            switch ($operator->getType()) {
+                case ISearchBinaryOperator::OPERATOR_NOT:
+                    $negativeOperator = $operator->getArguments()[0];
+                    if ($negativeOperator instanceof ISearchComparison) {
+                        return $this->searchComparisonToDBExpr($builder, $negativeOperator, self::$searchOperatorNegativeMap);
+                    } 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()));
+                case ISearchBinaryOperator::OPERATOR_OR:
+                    return call_user_func_array([$expr, 'orX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments()));
+                default:
+                    throw new \InvalidArgumentException('Invalid operator type: ' . $operator->getType());
+            }
+        } elseif ($operator instanceof ISearchComparison) {
+            return $this->searchComparisonToDBExpr($builder, $operator, self::$searchOperatorMap);
+        } else {
+            throw new \InvalidArgumentException('Invalid operator type: ' . get_class($operator));
+        }
+    }
+
+    private function searchComparisonToDBExpr(IQueryBuilder $builder, ISearchComparison $comparison, array $operatorMap) {
+        $this->validateComparison($comparison);
+
+        [$field, $value, $type] = $this->getOperatorFieldAndValue($comparison);
+        if (isset($operatorMap[$type])) {
+            $queryOperator = $operatorMap[$type];
+            return $builder->expr()->$queryOperator($field, $this->getParameterForValue($builder, $value));
+        } else {
+            throw new \InvalidArgumentException('Invalid operator type: ' . $comparison->getType());
+        }
+    }
+
+    private function getOperatorFieldAndValue(ISearchComparison $operator) {
+        $field = $operator->getField();
+        $value = $operator->getValue();
+        $type = $operator->getType();
+        if ($field === 'mimetype') {
+            $value = (string)$value;
+            if ($operator->getType() === ISearchComparison::COMPARE_EQUAL) {
+                $value = (int)$this->mimetypeLoader->getId($value);
+            } elseif ($operator->getType() === ISearchComparison::COMPARE_LIKE) {
+                // transform "mimetype='foo/%'" to "mimepart='foo'"
+                if (preg_match('|(.+)/%|', $value, $matches)) {
+                    $field = 'mimepart';
+                    $value = (int)$this->mimetypeLoader->getId($matches[1]);
+                    $type = ISearchComparison::COMPARE_EQUAL;
+                } elseif (strpos($value, '%') !== false) {
+                    throw new \InvalidArgumentException('Unsupported query value for mimetype: ' . $value . ', only values in the format "mime/type" or "mime/%" are supported');
+                } else {
+                    $field = 'mimetype';
+                    $value = (int)$this->mimetypeLoader->getId($value);
+                    $type = ISearchComparison::COMPARE_EQUAL;
+                }
+            }
+        } elseif ($field === 'favorite') {
+            $field = 'tag.category';
+            $value = self::TAG_FAVORITE;
+        } elseif ($field === 'tagname') {
+            $field = 'tag.category';
+        } elseif ($field === 'fileid') {
+            $field = 'file.fileid';
+        } elseif ($field === 'path' && $type === ISearchComparison::COMPARE_EQUAL) {
+            $field = 'path_hash';
+            $value = md5((string)$value);
+        }
+        return [$field, $value, $type];
+    }
+
+    private function validateComparison(ISearchComparison $operator) {
+        $types = [
+            'mimetype' => 'string',
+            'mtime' => 'integer',
+            'name' => 'string',
+            'path' => 'string',
+            'size' => 'integer',
+            'tagname' => 'string',
+            'favorite' => 'boolean',
+            'fileid' => 'integer',
+            'storage' => 'integer',
+        ];
+        $comparisons = [
+            'mimetype' => ['eq', 'like'],
+            'mtime' => ['eq', 'gt', 'lt', 'gte', 'lte'],
+            'name' => ['eq', 'like'],
+            'path' => ['eq', 'like'],
+            'size' => ['eq', 'gt', 'lt', 'gte', 'lte'],
+            'tagname' => ['eq', 'like'],
+            'favorite' => ['eq'],
+            'fileid' => ['eq'],
+            'storage' => ['eq'],
+        ];
+
+        if (!isset($types[$operator->getField()])) {
+            throw new \InvalidArgumentException('Unsupported comparison field ' . $operator->getField());
+        }
+        $type = $types[$operator->getField()];
+        if (gettype($operator->getValue()) !== $type) {
+            throw new \InvalidArgumentException('Invalid type for field ' . $operator->getField());
+        }
+        if (!in_array($operator->getType(), $comparisons[$operator->getField()])) {
+            throw new \InvalidArgumentException('Unsupported comparison for field  ' . $operator->getField() . ': ' . $operator->getType());
+        }
+    }
+
+    private function getParameterForValue(IQueryBuilder $builder, $value) {
+        if ($value instanceof \DateTime) {
+            $value = $value->getTimestamp();
+        }
+        if (is_numeric($value)) {
+            $type = IQueryBuilder::PARAM_INT;
+        } else {
+            $type = IQueryBuilder::PARAM_STR;
+        }
+        return $builder->createNamedParameter($value, $type);
+    }
+
+    /**
+     * @param IQueryBuilder $query
+     * @param ISearchOrder[] $orders
+     */
+    public function addSearchOrdersToQuery(IQueryBuilder $query, array $orders) {
+        foreach ($orders as $order) {
+            $field = $order->getField();
+            if ($field === 'fileid') {
+                $field = 'file.fileid';
+            }
+            $query->addOrderBy($field, $order->getDirection());
+        }
+    }
 }

Spacing +14 added lines, -14 removed lines

@@ -74,7 +74,7 @@ 
 	 */
 	public function shouldJoinTags(ISearchOperator $operator) {
 		if ($operator instanceof ISearchBinaryOperator) {
-			return array_reduce($operator->getArguments(), function ($shouldJoin, ISearchOperator $operator) {
+			return array_reduce($operator->getArguments(), function($shouldJoin, ISearchOperator $operator) {
 				return $shouldJoin || $this->shouldJoinTags($operator);
 			}, false);
 		} elseif ($operator instanceof ISearchComparison) {
@@ -88,7 +88,7 @@ 
 	 * @param ISearchOperator $operator
 	 */
 	public function searchOperatorArrayToDBExprArray(IQueryBuilder $builder, array $operators) {
-		return array_filter(array_map(function ($operator) use ($builder) {
+		return array_filter(array_map(function($operator) use ($builder) {
 			return $this->searchOperatorToDBExpr($builder, $operator);
 		}, $operators));
 	}
@@ -114,12 +114,12 @@ 
 				case ISearchBinaryOperator::OPERATOR_OR:
 					return call_user_func_array([$expr, 'orX'], $this->searchOperatorArrayToDBExprArray($builder, $operator->getArguments()));
 				default:
-					throw new \InvalidArgumentException('Invalid operator type: ' . $operator->getType());
+					throw new \InvalidArgumentException('Invalid operator type: '.$operator->getType());
 			}
 		} elseif ($operator instanceof ISearchComparison) {
 			return $this->searchComparisonToDBExpr($builder, $operator, self::$searchOperatorMap);
 		} else {
-			throw new \InvalidArgumentException('Invalid operator type: ' . get_class($operator));
+			throw new \InvalidArgumentException('Invalid operator type: '.get_class($operator));
 		}
 	}
 
@@ -131,7 +131,7 @@ 
 			$queryOperator = $operatorMap[$type];
 			return $builder->expr()->$queryOperator($field, $this->getParameterForValue($builder, $value));
 		} else {
-			throw new \InvalidArgumentException('Invalid operator type: ' . $comparison->getType());
+			throw new \InvalidArgumentException('Invalid operator type: '.$comparison->getType());
 		}
 	}
 
@@ -140,20 +140,20 @@ 
 		$value = $operator->getValue();
 		$type = $operator->getType();
 		if ($field === 'mimetype') {
-			$value = (string)$value;
+			$value = (string) $value;
 			if ($operator->getType() === ISearchComparison::COMPARE_EQUAL) {
-				$value = (int)$this->mimetypeLoader->getId($value);
+				$value = (int) $this->mimetypeLoader->getId($value);
 			} elseif ($operator->getType() === ISearchComparison::COMPARE_LIKE) {
 				// transform "mimetype='foo/%'" to "mimepart='foo'"
 				if (preg_match('|(.+)/%|', $value, $matches)) {
 					$field = 'mimepart';
-					$value = (int)$this->mimetypeLoader->getId($matches[1]);
+					$value = (int) $this->mimetypeLoader->getId($matches[1]);
 					$type = ISearchComparison::COMPARE_EQUAL;
 				} elseif (strpos($value, '%') !== false) {
-					throw new \InvalidArgumentException('Unsupported query value for mimetype: ' . $value . ', only values in the format "mime/type" or "mime/%" are supported');
+					throw new \InvalidArgumentException('Unsupported query value for mimetype: '.$value.', only values in the format "mime/type" or "mime/%" are supported');
 				} else {
 					$field = 'mimetype';
-					$value = (int)$this->mimetypeLoader->getId($value);
+					$value = (int) $this->mimetypeLoader->getId($value);
 					$type = ISearchComparison::COMPARE_EQUAL;
 				}
 			}
@@ -166,7 +166,7 @@ 
 			$field = 'file.fileid';
 		} elseif ($field === 'path' && $type === ISearchComparison::COMPARE_EQUAL) {
 			$field = 'path_hash';
-			$value = md5((string)$value);
+			$value = md5((string) $value);
 		}
 		return [$field, $value, $type];
 	}
@@ -196,14 +196,14 @@ 
 		];
 
 		if (!isset($types[$operator->getField()])) {
-			throw new \InvalidArgumentException('Unsupported comparison field ' . $operator->getField());
+			throw new \InvalidArgumentException('Unsupported comparison field '.$operator->getField());
 		}
 		$type = $types[$operator->getField()];
 		if (gettype($operator->getValue()) !== $type) {
-			throw new \InvalidArgumentException('Invalid type for field ' . $operator->getField());
+			throw new \InvalidArgumentException('Invalid type for field '.$operator->getField());
 		}
 		if (!in_array($operator->getType(), $comparisons[$operator->getField()])) {
-			throw new \InvalidArgumentException('Unsupported comparison for field  ' . $operator->getField() . ': ' . $operator->getType());
+			throw new \InvalidArgumentException('Unsupported comparison for field  '.$operator->getField().': '.$operator->getType());
 		}
 	}
 

lib/private/Files/Cache/Cache.php

Indentation +987 added lines, -987 removed lines

@@ -70,991 +70,991 @@
  * - ChangePropagator: updates the mtime and etags of parent folders whenever a change to the cache is made to the cache by the updater
  */
 class Cache implements ICache {
-	use MoveFromCacheTrait {
-		MoveFromCacheTrait::moveFromCache as moveFromCacheFallback;
-	}
-
-	/**
-	 * @var array partial data for the cache
-	 */
-	protected $partial = [];
-
-	/**
-	 * @var string
-	 */
-	protected $storageId;
-
-	private $storage;
-
-	/**
-	 * @var Storage $storageCache
-	 */
-	protected $storageCache;
-
-	/** @var IMimeTypeLoader */
-	protected $mimetypeLoader;
-
-	/**
-	 * @var IDBConnection
-	 */
-	protected $connection;
-
-	/**
-	 * @var IEventDispatcher
-	 */
-	protected $eventDispatcher;
-
-	/** @var QuerySearchHelper */
-	protected $querySearchHelper;
-
-	/**
-	 * @param IStorage $storage
-	 */
-	public function __construct(IStorage $storage) {
-		$this->storageId = $storage->getId();
-		$this->storage = $storage;
-		if (strlen($this->storageId) > 64) {
-			$this->storageId = md5($this->storageId);
-		}
-
-		$this->storageCache = new Storage($storage);
-		$this->mimetypeLoader = \OC::$server->getMimeTypeLoader();
-		$this->connection = \OC::$server->getDatabaseConnection();
-		$this->eventDispatcher = \OC::$server->get(IEventDispatcher::class);
-		$this->querySearchHelper = \OC::$server->query(QuerySearchHelper::class);
-	}
-
-	protected function getQueryBuilder() {
-		return new CacheQueryBuilder(
-			$this->connection,
-			\OC::$server->getSystemConfig(),
-			\OC::$server->getLogger()
-		);
-	}
-
-	/**
-	 * Get the numeric storage id for this cache's storage
-	 *
-	 * @return int
-	 */
-	public function getNumericStorageId() {
-		return $this->storageCache->getNumericId();
-	}
-
-	/**
-	 * get the stored metadata of a file or folder
-	 *
-	 * @param string | int $file either the path of a file or folder or the file id for a file or folder
-	 * @return ICacheEntry|false the cache entry as array of false if the file is not found in the cache
-	 */
-	public function get($file) {
-		$query = $this->getQueryBuilder();
-		$query->selectFileCache();
-
-		if (is_string($file) or $file == '') {
-			// normalize file
-			$file = $this->normalize($file);
-
-			$query->whereStorageId($this->getNumericStorageId())
-				->wherePath($file);
-		} else { //file id
-			$query->whereFileId($file);
-		}
-
-		$result = $query->execute();
-		$data = $result->fetch();
-		$result->closeCursor();
-
-		//merge partial data
-		if (!$data and is_string($file) and isset($this->partial[$file])) {
-			return $this->partial[$file];
-		} elseif (!$data) {
-			return $data;
-		} else {
-			return self::cacheEntryFromData($data, $this->mimetypeLoader);
-		}
-	}
-
-	/**
-	 * Create a CacheEntry from database row
-	 *
-	 * @param array $data
-	 * @param IMimeTypeLoader $mimetypeLoader
-	 * @return CacheEntry
-	 */
-	public static function cacheEntryFromData($data, IMimeTypeLoader $mimetypeLoader) {
-		//fix types
-		$data['fileid'] = (int)$data['fileid'];
-		$data['parent'] = (int)$data['parent'];
-		$data['size'] = 0 + $data['size'];
-		$data['mtime'] = (int)$data['mtime'];
-		$data['storage_mtime'] = (int)$data['storage_mtime'];
-		$data['encryptedVersion'] = (int)$data['encrypted'];
-		$data['encrypted'] = (bool)$data['encrypted'];
-		$data['storage_id'] = $data['storage'];
-		$data['storage'] = (int)$data['storage'];
-		$data['mimetype'] = $mimetypeLoader->getMimetypeById($data['mimetype']);
-		$data['mimepart'] = $mimetypeLoader->getMimetypeById($data['mimepart']);
-		if ($data['storage_mtime'] == 0) {
-			$data['storage_mtime'] = $data['mtime'];
-		}
-		$data['permissions'] = (int)$data['permissions'];
-		if (isset($data['creation_time'])) {
-			$data['creation_time'] = (int)$data['creation_time'];
-		}
-		if (isset($data['upload_time'])) {
-			$data['upload_time'] = (int)$data['upload_time'];
-		}
-		return new CacheEntry($data);
-	}
-
-	/**
-	 * get the metadata of all files stored in $folder
-	 *
-	 * @param string $folder
-	 * @return ICacheEntry[]
-	 */
-	public function getFolderContents($folder) {
-		$fileId = $this->getId($folder);
-		return $this->getFolderContentsById($fileId);
-	}
-
-	/**
-	 * get the metadata of all files stored in $folder
-	 *
-	 * @param int $fileId the file id of the folder
-	 * @return ICacheEntry[]
-	 */
-	public function getFolderContentsById($fileId) {
-		if ($fileId > -1) {
-			$query = $this->getQueryBuilder();
-			$query->selectFileCache()
-				->whereParent($fileId)
-				->orderBy('name', 'ASC');
-
-			$result = $query->execute();
-			$files = $result->fetchAll();
-			$result->closeCursor();
-
-			return array_map(function (array $data) {
-				return self::cacheEntryFromData($data, $this->mimetypeLoader);
-			}, $files);
-		}
-		return [];
-	}
-
-	/**
-	 * insert or update meta data for a file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function put($file, array $data) {
-		if (($id = $this->getId($file)) > -1) {
-			$this->update($id, $data);
-			return $id;
-		} else {
-			return $this->insert($file, $data);
-		}
-	}
-
-	/**
-	 * insert meta data for a new file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function insert($file, array $data) {
-		// normalize file
-		$file = $this->normalize($file);
-
-		if (isset($this->partial[$file])) { //add any saved partial data
-			$data = array_merge($this->partial[$file], $data);
-			unset($this->partial[$file]);
-		}
-
-		$requiredFields = ['size', 'mtime', 'mimetype'];
-		foreach ($requiredFields as $field) {
-			if (!isset($data[$field])) { //data not complete save as partial and return
-				$this->partial[$file] = $data;
-				return -1;
-			}
-		}
-
-		$data['path'] = $file;
-		if (!isset($data['parent'])) {
-			$data['parent'] = $this->getParentId($file);
-		}
-		$data['name'] = basename($file);
-
-		[$values, $extensionValues] = $this->normalizeData($data);
-		$storageId = $this->getNumericStorageId();
-		$values['storage'] = $storageId;
-
-		try {
-			$builder = $this->connection->getQueryBuilder();
-			$builder->insert('filecache');
-
-			foreach ($values as $column => $value) {
-				$builder->setValue($column, $builder->createNamedParameter($value));
-			}
-
-			if ($builder->execute()) {
-				$fileId = $builder->getLastInsertId();
-
-				if (count($extensionValues)) {
-					$query = $this->getQueryBuilder();
-					$query->insert('filecache_extended');
-
-					$query->setValue('fileid', $query->createNamedParameter($fileId, IQueryBuilder::PARAM_INT));
-					foreach ($extensionValues as $column => $value) {
-						$query->setValue($column, $query->createNamedParameter($value));
-					}
-					$query->execute();
-				}
-
-				$event = new CacheEntryInsertedEvent($this->storage, $file, $fileId, $storageId);
-				$this->eventDispatcher->dispatch(CacheInsertEvent::class, $event);
-				$this->eventDispatcher->dispatchTyped($event);
-				return $fileId;
-			}
-		} catch (UniqueConstraintViolationException $e) {
-			// entry exists already
-			if ($this->connection->inTransaction()) {
-				$this->connection->commit();
-				$this->connection->beginTransaction();
-			}
-		}
-
-		// The file was created in the mean time
-		if (($id = $this->getId($file)) > -1) {
-			$this->update($id, $data);
-			return $id;
-		} else {
-			throw new \RuntimeException('File entry could not be inserted but could also not be selected with getId() in order to perform an update. Please try again.');
-		}
-	}
-
-	/**
-	 * update the metadata of an existing file or folder in the cache
-	 *
-	 * @param int $id the fileid of the existing file or folder
-	 * @param array $data [$key => $value] the metadata to update, only the fields provided in the array will be updated, non-provided values will remain unchanged
-	 */
-	public function update($id, array $data) {
-		if (isset($data['path'])) {
-			// normalize path
-			$data['path'] = $this->normalize($data['path']);
-		}
-
-		if (isset($data['name'])) {
-			// normalize path
-			$data['name'] = $this->normalize($data['name']);
-		}
-
-		[$values, $extensionValues] = $this->normalizeData($data);
-
-		if (count($values)) {
-			$query = $this->getQueryBuilder();
-
-			$query->update('filecache')
-				->whereFileId($id)
-				->andWhere($query->expr()->orX(...array_map(function ($key, $value) use ($query) {
-					return $query->expr()->orX(
-						$query->expr()->neq($key, $query->createNamedParameter($value)),
-						$query->expr()->isNull($key)
-					);
-				}, array_keys($values), array_values($values))));
-
-			foreach ($values as $key => $value) {
-				$query->set($key, $query->createNamedParameter($value));
-			}
-
-			$query->execute();
-		}
-
-		if (count($extensionValues)) {
-			try {
-				$query = $this->getQueryBuilder();
-				$query->insert('filecache_extended');
-
-				$query->setValue('fileid', $query->createNamedParameter($id, IQueryBuilder::PARAM_INT));
-				foreach ($extensionValues as $column => $value) {
-					$query->setValue($column, $query->createNamedParameter($value));
-				}
-
-				$query->execute();
-			} catch (UniqueConstraintViolationException $e) {
-				$query = $this->getQueryBuilder();
-				$query->update('filecache_extended')
-					->whereFileId($id)
-					->andWhere($query->expr()->orX(...array_map(function ($key, $value) use ($query) {
-						return $query->expr()->orX(
-							$query->expr()->neq($key, $query->createNamedParameter($value)),
-							$query->expr()->isNull($key)
-						);
-					}, array_keys($extensionValues), array_values($extensionValues))));
-
-				foreach ($extensionValues as $key => $value) {
-					$query->set($key, $query->createNamedParameter($value));
-				}
-
-				$query->execute();
-			}
-		}
-
-		$path = $this->getPathById($id);
-		// path can still be null if the file doesn't exist
-		if ($path !== null) {
-			$event = new CacheEntryUpdatedEvent($this->storage, $path, $id, $this->getNumericStorageId());
-			$this->eventDispatcher->dispatch(CacheUpdateEvent::class, $event);
-			$this->eventDispatcher->dispatchTyped($event);
-		}
-	}
-
-	/**
-	 * extract query parts and params array from data array
-	 *
-	 * @param array $data
-	 * @return array
-	 */
-	protected function normalizeData(array $data): array {
-		$fields = [
-			'path', 'parent', 'name', 'mimetype', 'size', 'mtime', 'storage_mtime', 'encrypted',
-			'etag', 'permissions', 'checksum', 'storage'];
-		$extensionFields = ['metadata_etag', 'creation_time', 'upload_time'];
-
-		$doNotCopyStorageMTime = false;
-		if (array_key_exists('mtime', $data) && $data['mtime'] === null) {
-			// this horrific magic tells it to not copy storage_mtime to mtime
-			unset($data['mtime']);
-			$doNotCopyStorageMTime = true;
-		}
-
-		$params = [];
-		$extensionParams = [];
-		foreach ($data as $name => $value) {
-			if (array_search($name, $fields) !== false) {
-				if ($name === 'path') {
-					$params['path_hash'] = md5($value);
-				} elseif ($name === 'mimetype') {
-					$params['mimepart'] = $this->mimetypeLoader->getId(substr($value, 0, strpos($value, '/')));
-					$value = $this->mimetypeLoader->getId($value);
-				} elseif ($name === 'storage_mtime') {
-					if (!$doNotCopyStorageMTime && !isset($data['mtime'])) {
-						$params['mtime'] = $value;
-					}
-				} elseif ($name === 'encrypted') {
-					if (isset($data['encryptedVersion'])) {
-						$value = $data['encryptedVersion'];
-					} else {
-						// Boolean to integer conversion
-						$value = $value ? 1 : 0;
-					}
-				}
-				$params[$name] = $value;
-			}
-			if (array_search($name, $extensionFields) !== false) {
-				$extensionParams[$name] = $value;
-			}
-		}
-		return [$params, array_filter($extensionParams)];
-	}
-
-	/**
-	 * get the file id for a file
-	 *
-	 * A file id is a numeric id for a file or folder that's unique within an owncloud instance which stays the same for the lifetime of a file
-	 *
-	 * File ids are easiest way for apps to store references to a file since unlike paths they are not affected by renames or sharing
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getId($file) {
-		// normalize file
-		$file = $this->normalize($file);
-
-		$query = $this->getQueryBuilder();
-		$query->select('fileid')
-			->from('filecache')
-			->whereStorageId($this->getNumericStorageId())
-			->wherePath($file);
-
-		$result = $query->execute();
-		$id = $result->fetchOne();
-		$result->closeCursor();
-
-		return $id === false ? -1 : (int)$id;
-	}
-
-	/**
-	 * get the id of the parent folder of a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getParentId($file) {
-		if ($file === '') {
-			return -1;
-		} else {
-			$parent = $this->getParentPath($file);
-			return (int)$this->getId($parent);
-		}
-	}
-
-	private function getParentPath($path) {
-		$parent = dirname($path);
-		if ($parent === '.') {
-			$parent = '';
-		}
-		return $parent;
-	}
-
-	/**
-	 * check if a file is available in the cache
-	 *
-	 * @param string $file
-	 * @return bool
-	 */
-	public function inCache($file) {
-		return $this->getId($file) != -1;
-	}
-
-	/**
-	 * remove a file or folder from the cache
-	 *
-	 * when removing a folder from the cache all files and folders inside the folder will be removed as well
-	 *
-	 * @param string $file
-	 */
-	public function remove($file) {
-		$entry = $this->get($file);
-
-		if ($entry) {
-			$query = $this->getQueryBuilder();
-			$query->delete('filecache')
-				->whereFileId($entry->getId());
-			$query->execute();
-
-			$query = $this->getQueryBuilder();
-			$query->delete('filecache_extended')
-				->whereFileId($entry->getId());
-			$query->execute();
-
-			if ($entry->getMimeType() == FileInfo::MIMETYPE_FOLDER) {
-				$this->removeChildren($entry);
-			}
-
-			$this->eventDispatcher->dispatchTyped(new CacheEntryRemovedEvent($this->storage, $entry->getPath(), $entry->getId(), $this->getNumericStorageId()));
-		}
-	}
-
-	/**
-	 * Get all sub folders of a folder
-	 *
-	 * @param ICacheEntry $entry the cache entry of the folder to get the subfolders for
-	 * @return ICacheEntry[] the cache entries for the subfolders
-	 */
-	private function getSubFolders(ICacheEntry $entry) {
-		$children = $this->getFolderContentsById($entry->getId());
-		return array_filter($children, function ($child) {
-			return $child->getMimeType() == FileInfo::MIMETYPE_FOLDER;
-		});
-	}
-
-	/**
-	 * Recursively remove all children of a folder
-	 *
-	 * @param ICacheEntry $entry the cache entry of the folder to remove the children of
-	 * @throws \OC\DatabaseException
-	 */
-	private function removeChildren(ICacheEntry $entry) {
-		$parentIds = [$entry->getId()];
-		$queue = [$entry->getId()];
-
-		// we walk depth first trough the file tree, removing all filecache_extended attributes while we walk
-		// and collecting all folder ids to later use to delete the filecache entries
-		while ($entryId = array_pop($queue)) {
-			$children = $this->getFolderContentsById($entryId);
-			$childIds = array_map(function (ICacheEntry $cacheEntry) {
-				return $cacheEntry->getId();
-			}, $children);
-
-			$query = $this->getQueryBuilder();
-			$query->delete('filecache_extended')
-				->where($query->expr()->in('fileid', $query->createNamedParameter($childIds, IQueryBuilder::PARAM_INT_ARRAY)));
-			$query->execute();
-
-			/** @var ICacheEntry[] $childFolders */
-			$childFolders = array_filter($children, function ($child) {
-				return $child->getMimeType() == FileInfo::MIMETYPE_FOLDER;
-			});
-			foreach ($childFolders as $folder) {
-				$parentIds[] = $folder->getId();
-				$queue[] = $folder->getId();
-			}
-		}
-
-		$query = $this->getQueryBuilder();
-		$query->delete('filecache')
-			->whereParentIn($parentIds);
-		$query->execute();
-	}
-
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function move($source, $target) {
-		$this->moveFromCache($this, $source, $target);
-	}
-
-	/**
-	 * Get the storage id and path needed for a move
-	 *
-	 * @param string $path
-	 * @return array [$storageId, $internalPath]
-	 */
-	protected function getMoveInfo($path) {
-		return [$this->getNumericStorageId(), $path];
-	}
-
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param ICache $sourceCache
-	 * @param string $sourcePath
-	 * @param string $targetPath
-	 * @throws \OC\DatabaseException
-	 * @throws \Exception if the given storages have an invalid id
-	 */
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-		if ($sourceCache instanceof Cache) {
-			// normalize source and target
-			$sourcePath = $this->normalize($sourcePath);
-			$targetPath = $this->normalize($targetPath);
-
-			$sourceData = $sourceCache->get($sourcePath);
-			if ($sourceData === false) {
-				throw new \Exception('Invalid source storage path: ' . $sourcePath);
-			}
-
-			$sourceId = $sourceData['fileid'];
-			$newParentId = $this->getParentId($targetPath);
-
-			[$sourceStorageId, $sourcePath] = $sourceCache->getMoveInfo($sourcePath);
-			[$targetStorageId, $targetPath] = $this->getMoveInfo($targetPath);
-
-			if (is_null($sourceStorageId) || $sourceStorageId === false) {
-				throw new \Exception('Invalid source storage id: ' . $sourceStorageId);
-			}
-			if (is_null($targetStorageId) || $targetStorageId === false) {
-				throw new \Exception('Invalid target storage id: ' . $targetStorageId);
-			}
-
-			$this->connection->beginTransaction();
-			if ($sourceData['mimetype'] === 'httpd/unix-directory') {
-				//update all child entries
-				$sourceLength = mb_strlen($sourcePath);
-				$query = $this->connection->getQueryBuilder();
-
-				$fun = $query->func();
-				$newPathFunction = $fun->concat(
-					$query->createNamedParameter($targetPath),
-					$fun->substring('path', $query->createNamedParameter($sourceLength + 1, IQueryBuilder::PARAM_INT))// +1 for the leading slash
-				);
-				$query->update('filecache')
-					->set('storage', $query->createNamedParameter($targetStorageId, IQueryBuilder::PARAM_INT))
-					->set('path_hash', $fun->md5($newPathFunction))
-					->set('path', $newPathFunction)
-					->where($query->expr()->eq('storage', $query->createNamedParameter($sourceStorageId, IQueryBuilder::PARAM_INT)))
-					->andWhere($query->expr()->like('path', $query->createNamedParameter($this->connection->escapeLikeParameter($sourcePath) . '/%')));
-
-				try {
-					$query->execute();
-				} catch (\OC\DatabaseException $e) {
-					$this->connection->rollBack();
-					throw $e;
-				}
-			}
-
-			$query = $this->getQueryBuilder();
-			$query->update('filecache')
-				->set('storage', $query->createNamedParameter($targetStorageId))
-				->set('path', $query->createNamedParameter($targetPath))
-				->set('path_hash', $query->createNamedParameter(md5($targetPath)))
-				->set('name', $query->createNamedParameter(basename($targetPath)))
-				->set('parent', $query->createNamedParameter($newParentId, IQueryBuilder::PARAM_INT))
-				->whereFileId($sourceId);
-			$query->execute();
-
-			$this->connection->commit();
-
-			if ($sourceCache->getNumericStorageId() !== $this->getNumericStorageId()) {
-				$this->eventDispatcher->dispatchTyped(new CacheEntryRemovedEvent($this->storage, $sourcePath, $sourceId, $sourceCache->getNumericStorageId()));
-				$event = new CacheEntryInsertedEvent($this->storage, $targetPath, $sourceId, $this->getNumericStorageId());
-				$this->eventDispatcher->dispatch(CacheInsertEvent::class, $event);
-				$this->eventDispatcher->dispatchTyped($event);
-			} else {
-				$event = new CacheEntryUpdatedEvent($this->storage, $targetPath, $sourceId, $this->getNumericStorageId());
-				$this->eventDispatcher->dispatch(CacheUpdateEvent::class, $event);
-				$this->eventDispatcher->dispatchTyped($event);
-			}
-		} else {
-			$this->moveFromCacheFallback($sourceCache, $sourcePath, $targetPath);
-		}
-	}
-
-	/**
-	 * remove all entries for files that are stored on the storage from the cache
-	 */
-	public function clear() {
-		$query = $this->getQueryBuilder();
-		$query->delete('filecache')
-			->whereStorageId($this->getNumericStorageId());
-		$query->execute();
-
-		$query = $this->connection->getQueryBuilder();
-		$query->delete('storages')
-			->where($query->expr()->eq('id', $query->createNamedParameter($this->storageId)));
-		$query->execute();
-	}
-
-	/**
-	 * Get the scan status of a file
-	 *
-	 * - Cache::NOT_FOUND: File is not in the cache
-	 * - Cache::PARTIAL: File is not stored in the cache but some incomplete data is known
-	 * - Cache::SHALLOW: The folder and it's direct children are in the cache but not all sub folders are fully scanned
-	 * - Cache::COMPLETE: The file or folder, with all it's children) are fully scanned
-	 *
-	 * @param string $file
-	 *
-	 * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
-	 */
-	public function getStatus($file) {
-		// normalize file
-		$file = $this->normalize($file);
-
-		$query = $this->getQueryBuilder();
-		$query->select('size')
-			->from('filecache')
-			->whereStorageId($this->getNumericStorageId())
-			->wherePath($file);
-
-		$result = $query->execute();
-		$size = $result->fetchOne();
-		$result->closeCursor();
-
-		if ($size !== false) {
-			if ((int)$size === -1) {
-				return self::SHALLOW;
-			} else {
-				return self::COMPLETE;
-			}
-		} else {
-			if (isset($this->partial[$file])) {
-				return self::PARTIAL;
-			} else {
-				return self::NOT_FOUND;
-			}
-		}
-	}
-
-	/**
-	 * search for files matching $pattern
-	 *
-	 * @param string $pattern the search pattern using SQL search syntax (e.g. '%searchstring%')
-	 * @return ICacheEntry[] an array of cache entries where the name matches the search pattern
-	 */
-	public function search($pattern) {
-		$operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', $pattern);
-		return $this->searchQuery(new SearchQuery($operator, 0, 0, [], null));
-	}
-
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype either a full mimetype to search ('text/plain') or only the first part of a mimetype ('image')
-	 *        where it will search for all mimetypes in the group ('image/*')
-	 * @return ICacheEntry[] an array of cache entries where the mimetype matches the search
-	 */
-	public function searchByMime($mimetype) {
-		if (strpos($mimetype, '/') === false) {
-			$operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%');
-		} else {
-			$operator = new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype);
-		}
-		return $this->searchQuery(new SearchQuery($operator, 0, 0, [], null));
-	}
-
-	public function searchQuery(ISearchQuery $searchQuery) {
-		return current($this->querySearchHelper->searchInCaches($searchQuery, [$this]));
-	}
-
-	/**
-	 * Re-calculate the folder size and the size of all parent folders
-	 *
-	 * @param string|boolean $path
-	 * @param array $data (optional) meta data of the folder
-	 */
-	public function correctFolderSize($path, $data = null, $isBackgroundScan = false) {
-		$this->calculateFolderSize($path, $data);
-		if ($path !== '') {
-			$parent = dirname($path);
-			if ($parent === '.' or $parent === '/') {
-				$parent = '';
-			}
-			if ($isBackgroundScan) {
-				$parentData = $this->get($parent);
-				if ($parentData['size'] !== -1 && $this->getIncompleteChildrenCount($parentData['fileid']) === 0) {
-					$this->correctFolderSize($parent, $parentData, $isBackgroundScan);
-				}
-			} else {
-				$this->correctFolderSize($parent);
-			}
-		}
-	}
-
-	/**
-	 * get the incomplete count that shares parent $folder
-	 *
-	 * @param int $fileId the file id of the folder
-	 * @return int
-	 */
-	public function getIncompleteChildrenCount($fileId) {
-		if ($fileId > -1) {
-			$query = $this->getQueryBuilder();
-			$query->select($query->func()->count())
-				->from('filecache')
-				->whereParent($fileId)
-				->andWhere($query->expr()->lt('size', $query->createNamedParameter(0, IQueryBuilder::PARAM_INT)));
-
-			$result = $query->execute();
-			$size = (int)$result->fetchOne();
-			$result->closeCursor();
-
-			return $size;
-		}
-		return -1;
-	}
-
-	/**
-	 * calculate the size of a folder and set it in the cache
-	 *
-	 * @param string $path
-	 * @param array $entry (optional) meta data of the folder
-	 * @return int
-	 */
-	public function calculateFolderSize($path, $entry = null) {
-		$totalSize = 0;
-		if (is_null($entry) or !isset($entry['fileid'])) {
-			$entry = $this->get($path);
-		}
-		if (isset($entry['mimetype']) && $entry['mimetype'] === FileInfo::MIMETYPE_FOLDER) {
-			$id = $entry['fileid'];
-
-			$query = $this->getQueryBuilder();
-			$query->selectAlias($query->func()->sum('size'), 'f1')
-				->selectAlias($query->func()->min('size'), 'f2')
-				->from('filecache')
-				->whereStorageId($this->getNumericStorageId())
-				->whereParent($id);
-
-			$result = $query->execute();
-			$row = $result->fetch();
-			$result->closeCursor();
-
-			if ($row) {
-				[$sum, $min] = array_values($row);
-				$sum = 0 + $sum;
-				$min = 0 + $min;
-				if ($min === -1) {
-					$totalSize = $min;
-				} else {
-					$totalSize = $sum;
-				}
-				if ($entry['size'] !== $totalSize) {
-					$this->update($id, ['size' => $totalSize]);
-				}
-			}
-		}
-		return $totalSize;
-	}
-
-	/**
-	 * get all file ids on the files on the storage
-	 *
-	 * @return int[]
-	 */
-	public function getAll() {
-		$query = $this->getQueryBuilder();
-		$query->select('fileid')
-			->from('filecache')
-			->whereStorageId($this->getNumericStorageId());
-
-		$result = $query->execute();
-		$files = $result->fetchAll(\PDO::FETCH_COLUMN);
-		$result->closeCursor();
-
-		return array_map(function ($id) {
-			return (int)$id;
-		}, $files);
-	}
-
-	/**
-	 * find a folder in the cache which has not been fully scanned
-	 *
-	 * If multiple incomplete folders are in the cache, the one with the highest id will be returned,
-	 * use the one with the highest id gives the best result with the background scanner, since that is most
-	 * likely the folder where we stopped scanning previously
-	 *
-	 * @return string|bool the path of the folder or false when no folder matched
-	 */
-	public function getIncomplete() {
-		$query = $this->getQueryBuilder();
-		$query->select('path')
-			->from('filecache')
-			->whereStorageId($this->getNumericStorageId())
-			->andWhere($query->expr()->lt('size', $query->createNamedParameter(0, IQueryBuilder::PARAM_INT)))
-			->orderBy('fileid', 'DESC')
-			->setMaxResults(1);
-
-		$result = $query->execute();
-		$path = $result->fetchOne();
-		$result->closeCursor();
-
-		return $path;
-	}
-
-	/**
-	 * get the path of a file on this storage by it's file id
-	 *
-	 * @param int $id the file id of the file or folder to search
-	 * @return string|null the path of the file (relative to the storage) or null if a file with the given id does not exists within this cache
-	 */
-	public function getPathById($id) {
-		$query = $this->getQueryBuilder();
-		$query->select('path')
-			->from('filecache')
-			->whereStorageId($this->getNumericStorageId())
-			->whereFileId($id);
-
-		$result = $query->execute();
-		$path = $result->fetchOne();
-		$result->closeCursor();
-
-		if ($path === false) {
-			return null;
-		}
-
-		return (string)$path;
-	}
-
-	/**
-	 * get the storage id of the storage for a file and the internal path of the file
-	 * unlike getPathById this does not limit the search to files on this storage and
-	 * instead does a global search in the cache table
-	 *
-	 * @param int $id
-	 * @return array first element holding the storage id, second the path
-	 * @deprecated use getPathById() instead
-	 */
-	public static function getById($id) {
-		$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
-		$query->select('path', 'storage')
-			->from('filecache')
-			->where($query->expr()->eq('fileid', $query->createNamedParameter($id, IQueryBuilder::PARAM_INT)));
-
-		$result = $query->execute();
-		$row = $result->fetch();
-		$result->closeCursor();
-
-		if ($row) {
-			$numericId = $row['storage'];
-			$path = $row['path'];
-		} else {
-			return null;
-		}
-
-		if ($id = Storage::getStorageId($numericId)) {
-			return [$id, $path];
-		} else {
-			return null;
-		}
-	}
-
-	/**
-	 * normalize the given path
-	 *
-	 * @param string $path
-	 * @return string
-	 */
-	public function normalize($path) {
-		return trim(\OC_Util::normalizeUnicode($path), '/');
-	}
-
-	/**
-	 * Copy a file or folder in the cache
-	 *
-	 * @param ICache $sourceCache
-	 * @param ICacheEntry $sourceEntry
-	 * @param string $targetPath
-	 * @return int fileid of copied entry
-	 */
-	public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, string $targetPath): int {
-		if ($sourceEntry->getId() < 0) {
-			throw new \RuntimeException("Invalid source cache entry on copyFromCache");
-		}
-		$data = $this->cacheEntryToArray($sourceEntry);
-		$fileId = $this->put($targetPath, $data);
-		if ($fileId <= 0) {
-			throw new \RuntimeException("Failed to copy to " . $targetPath . " from cache with source data " . json_encode($data) . " ");
-		}
-		if ($sourceEntry->getMimeType() === ICacheEntry::DIRECTORY_MIMETYPE) {
-			$folderContent = $sourceCache->getFolderContentsById($sourceEntry->getId());
-			foreach ($folderContent as $subEntry) {
-				$subTargetPath = $targetPath . '/' . $subEntry->getName();
-				$this->copyFromCache($sourceCache, $subEntry, $subTargetPath);
-			}
-		}
-		return $fileId;
-	}
-
-	private function cacheEntryToArray(ICacheEntry $entry): array {
-		return [
-			'size' => $entry->getSize(),
-			'mtime' => $entry->getMTime(),
-			'storage_mtime' => $entry->getStorageMTime(),
-			'mimetype' => $entry->getMimeType(),
-			'mimepart' => $entry->getMimePart(),
-			'etag' => $entry->getEtag(),
-			'permissions' => $entry->getPermissions(),
-			'encrypted' => $entry->isEncrypted(),
-			'creation_time' => $entry->getCreationTime(),
-			'upload_time' => $entry->getUploadTime(),
-			'metadata_etag' => $entry->getMetadataEtag(),
-		];
-	}
-
-	public function getQueryFilterForStorage(): ISearchOperator {
-		return new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'storage', $this->getNumericStorageId());
-	}
-
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		if ($rawEntry->getStorageId() === $this->getNumericStorageId()) {
-			return $rawEntry;
-		} else {
-			return null;
-		}
-	}
+    use MoveFromCacheTrait {
+        MoveFromCacheTrait::moveFromCache as moveFromCacheFallback;
+    }
+
+    /**
+     * @var array partial data for the cache
+     */
+    protected $partial = [];
+
+    /**
+     * @var string
+     */
+    protected $storageId;
+
+    private $storage;
+
+    /**
+     * @var Storage $storageCache
+     */
+    protected $storageCache;
+
+    /** @var IMimeTypeLoader */
+    protected $mimetypeLoader;
+
+    /**
+     * @var IDBConnection
+     */
+    protected $connection;
+
+    /**
+     * @var IEventDispatcher
+     */
+    protected $eventDispatcher;
+
+    /** @var QuerySearchHelper */
+    protected $querySearchHelper;
+
+    /**
+     * @param IStorage $storage
+     */
+    public function __construct(IStorage $storage) {
+        $this->storageId = $storage->getId();
+        $this->storage = $storage;
+        if (strlen($this->storageId) > 64) {
+            $this->storageId = md5($this->storageId);
+        }
+
+        $this->storageCache = new Storage($storage);
+        $this->mimetypeLoader = \OC::$server->getMimeTypeLoader();
+        $this->connection = \OC::$server->getDatabaseConnection();
+        $this->eventDispatcher = \OC::$server->get(IEventDispatcher::class);
+        $this->querySearchHelper = \OC::$server->query(QuerySearchHelper::class);
+    }
+
+    protected function getQueryBuilder() {
+        return new CacheQueryBuilder(
+            $this->connection,
+            \OC::$server->getSystemConfig(),
+            \OC::$server->getLogger()
+        );
+    }
+
+    /**
+     * Get the numeric storage id for this cache's storage
+     *
+     * @return int
+     */
+    public function getNumericStorageId() {
+        return $this->storageCache->getNumericId();
+    }
+
+    /**
+     * get the stored metadata of a file or folder
+     *
+     * @param string | int $file either the path of a file or folder or the file id for a file or folder
+     * @return ICacheEntry|false the cache entry as array of false if the file is not found in the cache
+     */
+    public function get($file) {
+        $query = $this->getQueryBuilder();
+        $query->selectFileCache();
+
+        if (is_string($file) or $file == '') {
+            // normalize file
+            $file = $this->normalize($file);
+
+            $query->whereStorageId($this->getNumericStorageId())
+                ->wherePath($file);
+        } else { //file id
+            $query->whereFileId($file);
+        }
+
+        $result = $query->execute();
+        $data = $result->fetch();
+        $result->closeCursor();
+
+        //merge partial data
+        if (!$data and is_string($file) and isset($this->partial[$file])) {
+            return $this->partial[$file];
+        } elseif (!$data) {
+            return $data;
+        } else {
+            return self::cacheEntryFromData($data, $this->mimetypeLoader);
+        }
+    }
+
+    /**
+     * Create a CacheEntry from database row
+     *
+     * @param array $data
+     * @param IMimeTypeLoader $mimetypeLoader
+     * @return CacheEntry
+     */
+    public static function cacheEntryFromData($data, IMimeTypeLoader $mimetypeLoader) {
+        //fix types
+        $data['fileid'] = (int)$data['fileid'];
+        $data['parent'] = (int)$data['parent'];
+        $data['size'] = 0 + $data['size'];
+        $data['mtime'] = (int)$data['mtime'];
+        $data['storage_mtime'] = (int)$data['storage_mtime'];
+        $data['encryptedVersion'] = (int)$data['encrypted'];
+        $data['encrypted'] = (bool)$data['encrypted'];
+        $data['storage_id'] = $data['storage'];
+        $data['storage'] = (int)$data['storage'];
+        $data['mimetype'] = $mimetypeLoader->getMimetypeById($data['mimetype']);
+        $data['mimepart'] = $mimetypeLoader->getMimetypeById($data['mimepart']);
+        if ($data['storage_mtime'] == 0) {
+            $data['storage_mtime'] = $data['mtime'];
+        }
+        $data['permissions'] = (int)$data['permissions'];
+        if (isset($data['creation_time'])) {
+            $data['creation_time'] = (int)$data['creation_time'];
+        }
+        if (isset($data['upload_time'])) {
+            $data['upload_time'] = (int)$data['upload_time'];
+        }
+        return new CacheEntry($data);
+    }
+
+    /**
+     * get the metadata of all files stored in $folder
+     *
+     * @param string $folder
+     * @return ICacheEntry[]
+     */
+    public function getFolderContents($folder) {
+        $fileId = $this->getId($folder);
+        return $this->getFolderContentsById($fileId);
+    }
+
+    /**
+     * get the metadata of all files stored in $folder
+     *
+     * @param int $fileId the file id of the folder
+     * @return ICacheEntry[]
+     */
+    public function getFolderContentsById($fileId) {
+        if ($fileId > -1) {
+            $query = $this->getQueryBuilder();
+            $query->selectFileCache()
+                ->whereParent($fileId)
+                ->orderBy('name', 'ASC');
+
+            $result = $query->execute();
+            $files = $result->fetchAll();
+            $result->closeCursor();
+
+            return array_map(function (array $data) {
+                return self::cacheEntryFromData($data, $this->mimetypeLoader);
+            }, $files);
+        }
+        return [];
+    }
+
+    /**
+     * insert or update meta data for a file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function put($file, array $data) {
+        if (($id = $this->getId($file)) > -1) {
+            $this->update($id, $data);
+            return $id;
+        } else {
+            return $this->insert($file, $data);
+        }
+    }
+
+    /**
+     * insert meta data for a new file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function insert($file, array $data) {
+        // normalize file
+        $file = $this->normalize($file);
+
+        if (isset($this->partial[$file])) { //add any saved partial data
+            $data = array_merge($this->partial[$file], $data);
+            unset($this->partial[$file]);
+        }
+
+        $requiredFields = ['size', 'mtime', 'mimetype'];
+        foreach ($requiredFields as $field) {
+            if (!isset($data[$field])) { //data not complete save as partial and return
+                $this->partial[$file] = $data;
+                return -1;
+            }
+        }
+
+        $data['path'] = $file;
+        if (!isset($data['parent'])) {
+            $data['parent'] = $this->getParentId($file);
+        }
+        $data['name'] = basename($file);
+
+        [$values, $extensionValues] = $this->normalizeData($data);
+        $storageId = $this->getNumericStorageId();
+        $values['storage'] = $storageId;
+
+        try {
+            $builder = $this->connection->getQueryBuilder();
+            $builder->insert('filecache');
+
+            foreach ($values as $column => $value) {
+                $builder->setValue($column, $builder->createNamedParameter($value));
+            }
+
+            if ($builder->execute()) {
+                $fileId = $builder->getLastInsertId();
+
+                if (count($extensionValues)) {
+                    $query = $this->getQueryBuilder();
+                    $query->insert('filecache_extended');
+
+                    $query->setValue('fileid', $query->createNamedParameter($fileId, IQueryBuilder::PARAM_INT));
+                    foreach ($extensionValues as $column => $value) {
+                        $query->setValue($column, $query->createNamedParameter($value));
+                    }
+                    $query->execute();
+                }
+
+                $event = new CacheEntryInsertedEvent($this->storage, $file, $fileId, $storageId);
+                $this->eventDispatcher->dispatch(CacheInsertEvent::class, $event);
+                $this->eventDispatcher->dispatchTyped($event);
+                return $fileId;
+            }
+        } catch (UniqueConstraintViolationException $e) {
+            // entry exists already
+            if ($this->connection->inTransaction()) {
+                $this->connection->commit();
+                $this->connection->beginTransaction();
+            }
+        }
+
+        // The file was created in the mean time
+        if (($id = $this->getId($file)) > -1) {
+            $this->update($id, $data);
+            return $id;
+        } else {
+            throw new \RuntimeException('File entry could not be inserted but could also not be selected with getId() in order to perform an update. Please try again.');
+        }
+    }
+
+    /**
+     * update the metadata of an existing file or folder in the cache
+     *
+     * @param int $id the fileid of the existing file or folder
+     * @param array $data [$key => $value] the metadata to update, only the fields provided in the array will be updated, non-provided values will remain unchanged
+     */
+    public function update($id, array $data) {
+        if (isset($data['path'])) {
+            // normalize path
+            $data['path'] = $this->normalize($data['path']);
+        }
+
+        if (isset($data['name'])) {
+            // normalize path
+            $data['name'] = $this->normalize($data['name']);
+        }
+
+        [$values, $extensionValues] = $this->normalizeData($data);
+
+        if (count($values)) {
+            $query = $this->getQueryBuilder();
+
+            $query->update('filecache')
+                ->whereFileId($id)
+                ->andWhere($query->expr()->orX(...array_map(function ($key, $value) use ($query) {
+                    return $query->expr()->orX(
+                        $query->expr()->neq($key, $query->createNamedParameter($value)),
+                        $query->expr()->isNull($key)
+                    );
+                }, array_keys($values), array_values($values))));
+
+            foreach ($values as $key => $value) {
+                $query->set($key, $query->createNamedParameter($value));
+            }
+
+            $query->execute();
+        }
+
+        if (count($extensionValues)) {
+            try {
+                $query = $this->getQueryBuilder();
+                $query->insert('filecache_extended');
+
+                $query->setValue('fileid', $query->createNamedParameter($id, IQueryBuilder::PARAM_INT));
+                foreach ($extensionValues as $column => $value) {
+                    $query->setValue($column, $query->createNamedParameter($value));
+                }
+
+                $query->execute();
+            } catch (UniqueConstraintViolationException $e) {
+                $query = $this->getQueryBuilder();
+                $query->update('filecache_extended')
+                    ->whereFileId($id)
+                    ->andWhere($query->expr()->orX(...array_map(function ($key, $value) use ($query) {
+                        return $query->expr()->orX(
+                            $query->expr()->neq($key, $query->createNamedParameter($value)),
+                            $query->expr()->isNull($key)
+                        );
+                    }, array_keys($extensionValues), array_values($extensionValues))));
+
+                foreach ($extensionValues as $key => $value) {
+                    $query->set($key, $query->createNamedParameter($value));
+                }
+
+                $query->execute();
+            }
+        }
+
+        $path = $this->getPathById($id);
+        // path can still be null if the file doesn't exist
+        if ($path !== null) {
+            $event = new CacheEntryUpdatedEvent($this->storage, $path, $id, $this->getNumericStorageId());
+            $this->eventDispatcher->dispatch(CacheUpdateEvent::class, $event);
+            $this->eventDispatcher->dispatchTyped($event);
+        }
+    }
+
+    /**
+     * extract query parts and params array from data array
+     *
+     * @param array $data
+     * @return array
+     */
+    protected function normalizeData(array $data): array {
+        $fields = [
+            'path', 'parent', 'name', 'mimetype', 'size', 'mtime', 'storage_mtime', 'encrypted',
+            'etag', 'permissions', 'checksum', 'storage'];
+        $extensionFields = ['metadata_etag', 'creation_time', 'upload_time'];
+
+        $doNotCopyStorageMTime = false;
+        if (array_key_exists('mtime', $data) && $data['mtime'] === null) {
+            // this horrific magic tells it to not copy storage_mtime to mtime
+            unset($data['mtime']);
+            $doNotCopyStorageMTime = true;
+        }
+
+        $params = [];
+        $extensionParams = [];
+        foreach ($data as $name => $value) {
+            if (array_search($name, $fields) !== false) {
+                if ($name === 'path') {
+                    $params['path_hash'] = md5($value);
+                } elseif ($name === 'mimetype') {
+                    $params['mimepart'] = $this->mimetypeLoader->getId(substr($value, 0, strpos($value, '/')));
+                    $value = $this->mimetypeLoader->getId($value);
+                } elseif ($name === 'storage_mtime') {
+                    if (!$doNotCopyStorageMTime && !isset($data['mtime'])) {
+                        $params['mtime'] = $value;
+                    }
+                } elseif ($name === 'encrypted') {
+                    if (isset($data['encryptedVersion'])) {
+                        $value = $data['encryptedVersion'];
+                    } else {
+                        // Boolean to integer conversion
+                        $value = $value ? 1 : 0;
+                    }
+                }
+                $params[$name] = $value;
+            }
+            if (array_search($name, $extensionFields) !== false) {
+                $extensionParams[$name] = $value;
+            }
+        }
+        return [$params, array_filter($extensionParams)];
+    }
+
+    /**
+     * get the file id for a file
+     *
+     * A file id is a numeric id for a file or folder that's unique within an owncloud instance which stays the same for the lifetime of a file
+     *
+     * File ids are easiest way for apps to store references to a file since unlike paths they are not affected by renames or sharing
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getId($file) {
+        // normalize file
+        $file = $this->normalize($file);
+
+        $query = $this->getQueryBuilder();
+        $query->select('fileid')
+            ->from('filecache')
+            ->whereStorageId($this->getNumericStorageId())
+            ->wherePath($file);
+
+        $result = $query->execute();
+        $id = $result->fetchOne();
+        $result->closeCursor();
+
+        return $id === false ? -1 : (int)$id;
+    }
+
+    /**
+     * get the id of the parent folder of a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getParentId($file) {
+        if ($file === '') {
+            return -1;
+        } else {
+            $parent = $this->getParentPath($file);
+            return (int)$this->getId($parent);
+        }
+    }
+
+    private function getParentPath($path) {
+        $parent = dirname($path);
+        if ($parent === '.') {
+            $parent = '';
+        }
+        return $parent;
+    }
+
+    /**
+     * check if a file is available in the cache
+     *
+     * @param string $file
+     * @return bool
+     */
+    public function inCache($file) {
+        return $this->getId($file) != -1;
+    }
+
+    /**
+     * remove a file or folder from the cache
+     *
+     * when removing a folder from the cache all files and folders inside the folder will be removed as well
+     *
+     * @param string $file
+     */
+    public function remove($file) {
+        $entry = $this->get($file);
+
+        if ($entry) {
+            $query = $this->getQueryBuilder();
+            $query->delete('filecache')
+                ->whereFileId($entry->getId());
+            $query->execute();
+
+            $query = $this->getQueryBuilder();
+            $query->delete('filecache_extended')
+                ->whereFileId($entry->getId());
+            $query->execute();
+
+            if ($entry->getMimeType() == FileInfo::MIMETYPE_FOLDER) {
+                $this->removeChildren($entry);
+            }
+
+            $this->eventDispatcher->dispatchTyped(new CacheEntryRemovedEvent($this->storage, $entry->getPath(), $entry->getId(), $this->getNumericStorageId()));
+        }
+    }
+
+    /**
+     * Get all sub folders of a folder
+     *
+     * @param ICacheEntry $entry the cache entry of the folder to get the subfolders for
+     * @return ICacheEntry[] the cache entries for the subfolders
+     */
+    private function getSubFolders(ICacheEntry $entry) {
+        $children = $this->getFolderContentsById($entry->getId());
+        return array_filter($children, function ($child) {
+            return $child->getMimeType() == FileInfo::MIMETYPE_FOLDER;
+        });
+    }
+
+    /**
+     * Recursively remove all children of a folder
+     *
+     * @param ICacheEntry $entry the cache entry of the folder to remove the children of
+     * @throws \OC\DatabaseException
+     */
+    private function removeChildren(ICacheEntry $entry) {
+        $parentIds = [$entry->getId()];
+        $queue = [$entry->getId()];
+
+        // we walk depth first trough the file tree, removing all filecache_extended attributes while we walk
+        // and collecting all folder ids to later use to delete the filecache entries
+        while ($entryId = array_pop($queue)) {
+            $children = $this->getFolderContentsById($entryId);
+            $childIds = array_map(function (ICacheEntry $cacheEntry) {
+                return $cacheEntry->getId();
+            }, $children);
+
+            $query = $this->getQueryBuilder();
+            $query->delete('filecache_extended')
+                ->where($query->expr()->in('fileid', $query->createNamedParameter($childIds, IQueryBuilder::PARAM_INT_ARRAY)));
+            $query->execute();
+
+            /** @var ICacheEntry[] $childFolders */
+            $childFolders = array_filter($children, function ($child) {
+                return $child->getMimeType() == FileInfo::MIMETYPE_FOLDER;
+            });
+            foreach ($childFolders as $folder) {
+                $parentIds[] = $folder->getId();
+                $queue[] = $folder->getId();
+            }
+        }
+
+        $query = $this->getQueryBuilder();
+        $query->delete('filecache')
+            ->whereParentIn($parentIds);
+        $query->execute();
+    }
+
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param string $source
+     * @param string $target
+     */
+    public function move($source, $target) {
+        $this->moveFromCache($this, $source, $target);
+    }
+
+    /**
+     * Get the storage id and path needed for a move
+     *
+     * @param string $path
+     * @return array [$storageId, $internalPath]
+     */
+    protected function getMoveInfo($path) {
+        return [$this->getNumericStorageId(), $path];
+    }
+
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param ICache $sourceCache
+     * @param string $sourcePath
+     * @param string $targetPath
+     * @throws \OC\DatabaseException
+     * @throws \Exception if the given storages have an invalid id
+     */
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+        if ($sourceCache instanceof Cache) {
+            // normalize source and target
+            $sourcePath = $this->normalize($sourcePath);
+            $targetPath = $this->normalize($targetPath);
+
+            $sourceData = $sourceCache->get($sourcePath);
+            if ($sourceData === false) {
+                throw new \Exception('Invalid source storage path: ' . $sourcePath);
+            }
+
+            $sourceId = $sourceData['fileid'];
+            $newParentId = $this->getParentId($targetPath);
+
+            [$sourceStorageId, $sourcePath] = $sourceCache->getMoveInfo($sourcePath);
+            [$targetStorageId, $targetPath] = $this->getMoveInfo($targetPath);
+
+            if (is_null($sourceStorageId) || $sourceStorageId === false) {
+                throw new \Exception('Invalid source storage id: ' . $sourceStorageId);
+            }
+            if (is_null($targetStorageId) || $targetStorageId === false) {
+                throw new \Exception('Invalid target storage id: ' . $targetStorageId);
+            }
+
+            $this->connection->beginTransaction();
+            if ($sourceData['mimetype'] === 'httpd/unix-directory') {
+                //update all child entries
+                $sourceLength = mb_strlen($sourcePath);
+                $query = $this->connection->getQueryBuilder();
+
+                $fun = $query->func();
+                $newPathFunction = $fun->concat(
+                    $query->createNamedParameter($targetPath),
+                    $fun->substring('path', $query->createNamedParameter($sourceLength + 1, IQueryBuilder::PARAM_INT))// +1 for the leading slash
+                );
+                $query->update('filecache')
+                    ->set('storage', $query->createNamedParameter($targetStorageId, IQueryBuilder::PARAM_INT))
+                    ->set('path_hash', $fun->md5($newPathFunction))
+                    ->set('path', $newPathFunction)
+                    ->where($query->expr()->eq('storage', $query->createNamedParameter($sourceStorageId, IQueryBuilder::PARAM_INT)))
+                    ->andWhere($query->expr()->like('path', $query->createNamedParameter($this->connection->escapeLikeParameter($sourcePath) . '/%')));
+
+                try {
+                    $query->execute();
+                } catch (\OC\DatabaseException $e) {
+                    $this->connection->rollBack();
+                    throw $e;
+                }
+            }
+
+            $query = $this->getQueryBuilder();
+            $query->update('filecache')
+                ->set('storage', $query->createNamedParameter($targetStorageId))
+                ->set('path', $query->createNamedParameter($targetPath))
+                ->set('path_hash', $query->createNamedParameter(md5($targetPath)))
+                ->set('name', $query->createNamedParameter(basename($targetPath)))
+                ->set('parent', $query->createNamedParameter($newParentId, IQueryBuilder::PARAM_INT))
+                ->whereFileId($sourceId);
+            $query->execute();
+
+            $this->connection->commit();
+
+            if ($sourceCache->getNumericStorageId() !== $this->getNumericStorageId()) {
+                $this->eventDispatcher->dispatchTyped(new CacheEntryRemovedEvent($this->storage, $sourcePath, $sourceId, $sourceCache->getNumericStorageId()));
+                $event = new CacheEntryInsertedEvent($this->storage, $targetPath, $sourceId, $this->getNumericStorageId());
+                $this->eventDispatcher->dispatch(CacheInsertEvent::class, $event);
+                $this->eventDispatcher->dispatchTyped($event);
+            } else {
+                $event = new CacheEntryUpdatedEvent($this->storage, $targetPath, $sourceId, $this->getNumericStorageId());
+                $this->eventDispatcher->dispatch(CacheUpdateEvent::class, $event);
+                $this->eventDispatcher->dispatchTyped($event);
+            }
+        } else {
+            $this->moveFromCacheFallback($sourceCache, $sourcePath, $targetPath);
+        }
+    }
+
+    /**
+     * remove all entries for files that are stored on the storage from the cache
+     */
+    public function clear() {
+        $query = $this->getQueryBuilder();
+        $query->delete('filecache')
+            ->whereStorageId($this->getNumericStorageId());
+        $query->execute();
+
+        $query = $this->connection->getQueryBuilder();
+        $query->delete('storages')
+            ->where($query->expr()->eq('id', $query->createNamedParameter($this->storageId)));
+        $query->execute();
+    }
+
+    /**
+     * Get the scan status of a file
+     *
+     * - Cache::NOT_FOUND: File is not in the cache
+     * - Cache::PARTIAL: File is not stored in the cache but some incomplete data is known
+     * - Cache::SHALLOW: The folder and it's direct children are in the cache but not all sub folders are fully scanned
+     * - Cache::COMPLETE: The file or folder, with all it's children) are fully scanned
+     *
+     * @param string $file
+     *
+     * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
+     */
+    public function getStatus($file) {
+        // normalize file
+        $file = $this->normalize($file);
+
+        $query = $this->getQueryBuilder();
+        $query->select('size')
+            ->from('filecache')
+            ->whereStorageId($this->getNumericStorageId())
+            ->wherePath($file);
+
+        $result = $query->execute();
+        $size = $result->fetchOne();
+        $result->closeCursor();
+
+        if ($size !== false) {
+            if ((int)$size === -1) {
+                return self::SHALLOW;
+            } else {
+                return self::COMPLETE;
+            }
+        } else {
+            if (isset($this->partial[$file])) {
+                return self::PARTIAL;
+            } else {
+                return self::NOT_FOUND;
+            }
+        }
+    }
+
+    /**
+     * search for files matching $pattern
+     *
+     * @param string $pattern the search pattern using SQL search syntax (e.g. '%searchstring%')
+     * @return ICacheEntry[] an array of cache entries where the name matches the search pattern
+     */
+    public function search($pattern) {
+        $operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', $pattern);
+        return $this->searchQuery(new SearchQuery($operator, 0, 0, [], null));
+    }
+
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype either a full mimetype to search ('text/plain') or only the first part of a mimetype ('image')
+     *        where it will search for all mimetypes in the group ('image/*')
+     * @return ICacheEntry[] an array of cache entries where the mimetype matches the search
+     */
+    public function searchByMime($mimetype) {
+        if (strpos($mimetype, '/') === false) {
+            $operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%');
+        } else {
+            $operator = new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype);
+        }
+        return $this->searchQuery(new SearchQuery($operator, 0, 0, [], null));
+    }
+
+    public function searchQuery(ISearchQuery $searchQuery) {
+        return current($this->querySearchHelper->searchInCaches($searchQuery, [$this]));
+    }
+
+    /**
+     * Re-calculate the folder size and the size of all parent folders
+     *
+     * @param string|boolean $path
+     * @param array $data (optional) meta data of the folder
+     */
+    public function correctFolderSize($path, $data = null, $isBackgroundScan = false) {
+        $this->calculateFolderSize($path, $data);
+        if ($path !== '') {
+            $parent = dirname($path);
+            if ($parent === '.' or $parent === '/') {
+                $parent = '';
+            }
+            if ($isBackgroundScan) {
+                $parentData = $this->get($parent);
+                if ($parentData['size'] !== -1 && $this->getIncompleteChildrenCount($parentData['fileid']) === 0) {
+                    $this->correctFolderSize($parent, $parentData, $isBackgroundScan);
+                }
+            } else {
+                $this->correctFolderSize($parent);
+            }
+        }
+    }
+
+    /**
+     * get the incomplete count that shares parent $folder
+     *
+     * @param int $fileId the file id of the folder
+     * @return int
+     */
+    public function getIncompleteChildrenCount($fileId) {
+        if ($fileId > -1) {
+            $query = $this->getQueryBuilder();
+            $query->select($query->func()->count())
+                ->from('filecache')
+                ->whereParent($fileId)
+                ->andWhere($query->expr()->lt('size', $query->createNamedParameter(0, IQueryBuilder::PARAM_INT)));
+
+            $result = $query->execute();
+            $size = (int)$result->fetchOne();
+            $result->closeCursor();
+
+            return $size;
+        }
+        return -1;
+    }
+
+    /**
+     * calculate the size of a folder and set it in the cache
+     *
+     * @param string $path
+     * @param array $entry (optional) meta data of the folder
+     * @return int
+     */
+    public function calculateFolderSize($path, $entry = null) {
+        $totalSize = 0;
+        if (is_null($entry) or !isset($entry['fileid'])) {
+            $entry = $this->get($path);
+        }
+        if (isset($entry['mimetype']) && $entry['mimetype'] === FileInfo::MIMETYPE_FOLDER) {
+            $id = $entry['fileid'];
+
+            $query = $this->getQueryBuilder();
+            $query->selectAlias($query->func()->sum('size'), 'f1')
+                ->selectAlias($query->func()->min('size'), 'f2')
+                ->from('filecache')
+                ->whereStorageId($this->getNumericStorageId())
+                ->whereParent($id);
+
+            $result = $query->execute();
+            $row = $result->fetch();
+            $result->closeCursor();
+
+            if ($row) {
+                [$sum, $min] = array_values($row);
+                $sum = 0 + $sum;
+                $min = 0 + $min;
+                if ($min === -1) {
+                    $totalSize = $min;
+                } else {
+                    $totalSize = $sum;
+                }
+                if ($entry['size'] !== $totalSize) {
+                    $this->update($id, ['size' => $totalSize]);
+                }
+            }
+        }
+        return $totalSize;
+    }
+
+    /**
+     * get all file ids on the files on the storage
+     *
+     * @return int[]
+     */
+    public function getAll() {
+        $query = $this->getQueryBuilder();
+        $query->select('fileid')
+            ->from('filecache')
+            ->whereStorageId($this->getNumericStorageId());
+
+        $result = $query->execute();
+        $files = $result->fetchAll(\PDO::FETCH_COLUMN);
+        $result->closeCursor();
+
+        return array_map(function ($id) {
+            return (int)$id;
+        }, $files);
+    }
+
+    /**
+     * find a folder in the cache which has not been fully scanned
+     *
+     * If multiple incomplete folders are in the cache, the one with the highest id will be returned,
+     * use the one with the highest id gives the best result with the background scanner, since that is most
+     * likely the folder where we stopped scanning previously
+     *
+     * @return string|bool the path of the folder or false when no folder matched
+     */
+    public function getIncomplete() {
+        $query = $this->getQueryBuilder();
+        $query->select('path')
+            ->from('filecache')
+            ->whereStorageId($this->getNumericStorageId())
+            ->andWhere($query->expr()->lt('size', $query->createNamedParameter(0, IQueryBuilder::PARAM_INT)))
+            ->orderBy('fileid', 'DESC')
+            ->setMaxResults(1);
+
+        $result = $query->execute();
+        $path = $result->fetchOne();
+        $result->closeCursor();
+
+        return $path;
+    }
+
+    /**
+     * get the path of a file on this storage by it's file id
+     *
+     * @param int $id the file id of the file or folder to search
+     * @return string|null the path of the file (relative to the storage) or null if a file with the given id does not exists within this cache
+     */
+    public function getPathById($id) {
+        $query = $this->getQueryBuilder();
+        $query->select('path')
+            ->from('filecache')
+            ->whereStorageId($this->getNumericStorageId())
+            ->whereFileId($id);
+
+        $result = $query->execute();
+        $path = $result->fetchOne();
+        $result->closeCursor();
+
+        if ($path === false) {
+            return null;
+        }
+
+        return (string)$path;
+    }
+
+    /**
+     * get the storage id of the storage for a file and the internal path of the file
+     * unlike getPathById this does not limit the search to files on this storage and
+     * instead does a global search in the cache table
+     *
+     * @param int $id
+     * @return array first element holding the storage id, second the path
+     * @deprecated use getPathById() instead
+     */
+    public static function getById($id) {
+        $query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
+        $query->select('path', 'storage')
+            ->from('filecache')
+            ->where($query->expr()->eq('fileid', $query->createNamedParameter($id, IQueryBuilder::PARAM_INT)));
+
+        $result = $query->execute();
+        $row = $result->fetch();
+        $result->closeCursor();
+
+        if ($row) {
+            $numericId = $row['storage'];
+            $path = $row['path'];
+        } else {
+            return null;
+        }
+
+        if ($id = Storage::getStorageId($numericId)) {
+            return [$id, $path];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * normalize the given path
+     *
+     * @param string $path
+     * @return string
+     */
+    public function normalize($path) {
+        return trim(\OC_Util::normalizeUnicode($path), '/');
+    }
+
+    /**
+     * Copy a file or folder in the cache
+     *
+     * @param ICache $sourceCache
+     * @param ICacheEntry $sourceEntry
+     * @param string $targetPath
+     * @return int fileid of copied entry
+     */
+    public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, string $targetPath): int {
+        if ($sourceEntry->getId() < 0) {
+            throw new \RuntimeException("Invalid source cache entry on copyFromCache");
+        }
+        $data = $this->cacheEntryToArray($sourceEntry);
+        $fileId = $this->put($targetPath, $data);
+        if ($fileId <= 0) {
+            throw new \RuntimeException("Failed to copy to " . $targetPath . " from cache with source data " . json_encode($data) . " ");
+        }
+        if ($sourceEntry->getMimeType() === ICacheEntry::DIRECTORY_MIMETYPE) {
+            $folderContent = $sourceCache->getFolderContentsById($sourceEntry->getId());
+            foreach ($folderContent as $subEntry) {
+                $subTargetPath = $targetPath . '/' . $subEntry->getName();
+                $this->copyFromCache($sourceCache, $subEntry, $subTargetPath);
+            }
+        }
+        return $fileId;
+    }
+
+    private function cacheEntryToArray(ICacheEntry $entry): array {
+        return [
+            'size' => $entry->getSize(),
+            'mtime' => $entry->getMTime(),
+            'storage_mtime' => $entry->getStorageMTime(),
+            'mimetype' => $entry->getMimeType(),
+            'mimepart' => $entry->getMimePart(),
+            'etag' => $entry->getEtag(),
+            'permissions' => $entry->getPermissions(),
+            'encrypted' => $entry->isEncrypted(),
+            'creation_time' => $entry->getCreationTime(),
+            'upload_time' => $entry->getUploadTime(),
+            'metadata_etag' => $entry->getMetadataEtag(),
+        ];
+    }
+
+    public function getQueryFilterForStorage(): ISearchOperator {
+        return new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'storage', $this->getNumericStorageId());
+    }
+
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        if ($rawEntry->getStorageId() === $this->getNumericStorageId()) {
+            return $rawEntry;
+        } else {
+            return null;
+        }
+    }
 }

Spacing +30 added lines, -30 removed lines

@@ -184,26 +184,26 @@ 
 	 */
 	public static function cacheEntryFromData($data, IMimeTypeLoader $mimetypeLoader) {
 		//fix types
-		$data['fileid'] = (int)$data['fileid'];
-		$data['parent'] = (int)$data['parent'];
+		$data['fileid'] = (int) $data['fileid'];
+		$data['parent'] = (int) $data['parent'];
 		$data['size'] = 0 + $data['size'];
-		$data['mtime'] = (int)$data['mtime'];
-		$data['storage_mtime'] = (int)$data['storage_mtime'];
-		$data['encryptedVersion'] = (int)$data['encrypted'];
-		$data['encrypted'] = (bool)$data['encrypted'];
+		$data['mtime'] = (int) $data['mtime'];
+		$data['storage_mtime'] = (int) $data['storage_mtime'];
+		$data['encryptedVersion'] = (int) $data['encrypted'];
+		$data['encrypted'] = (bool) $data['encrypted'];
 		$data['storage_id'] = $data['storage'];
-		$data['storage'] = (int)$data['storage'];
+		$data['storage'] = (int) $data['storage'];
 		$data['mimetype'] = $mimetypeLoader->getMimetypeById($data['mimetype']);
 		$data['mimepart'] = $mimetypeLoader->getMimetypeById($data['mimepart']);
 		if ($data['storage_mtime'] == 0) {
 			$data['storage_mtime'] = $data['mtime'];
 		}
-		$data['permissions'] = (int)$data['permissions'];
+		$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);
 	}
@@ -236,7 +236,7 @@ 
 			$files = $result->fetchAll();
 			$result->closeCursor();
 
-			return array_map(function (array $data) {
+			return array_map(function(array $data) {
 				return self::cacheEntryFromData($data, $this->mimetypeLoader);
 			}, $files);
 		}
@@ -365,7 +365,7 @@ 
 
 			$query->update('filecache')
 				->whereFileId($id)
-				->andWhere($query->expr()->orX(...array_map(function ($key, $value) use ($query) {
+				->andWhere($query->expr()->orX(...array_map(function($key, $value) use ($query) {
 					return $query->expr()->orX(
 						$query->expr()->neq($key, $query->createNamedParameter($value)),
 						$query->expr()->isNull($key)
@@ -394,7 +394,7 @@ 
 				$query = $this->getQueryBuilder();
 				$query->update('filecache_extended')
 					->whereFileId($id)
-					->andWhere($query->expr()->orX(...array_map(function ($key, $value) use ($query) {
+					->andWhere($query->expr()->orX(...array_map(function($key, $value) use ($query) {
 						return $query->expr()->orX(
 							$query->expr()->neq($key, $query->createNamedParameter($value)),
 							$query->expr()->isNull($key)
@@ -491,7 +491,7 @@ 
 		$id = $result->fetchOne();
 		$result->closeCursor();
 
-		return $id === false ? -1 : (int)$id;
+		return $id === false ? -1 : (int) $id;
 	}
 
 	/**
@@ -505,7 +505,7 @@ 
 			return -1;
 		} else {
 			$parent = $this->getParentPath($file);
-			return (int)$this->getId($parent);
+			return (int) $this->getId($parent);
 		}
 	}
 
@@ -564,7 +564,7 @@ 
 	 */
 	private function getSubFolders(ICacheEntry $entry) {
 		$children = $this->getFolderContentsById($entry->getId());
-		return array_filter($children, function ($child) {
+		return array_filter($children, function($child) {
 			return $child->getMimeType() == FileInfo::MIMETYPE_FOLDER;
 		});
 	}
@@ -583,7 +583,7 @@ 
 		// and collecting all folder ids to later use to delete the filecache entries
 		while ($entryId = array_pop($queue)) {
 			$children = $this->getFolderContentsById($entryId);
-			$childIds = array_map(function (ICacheEntry $cacheEntry) {
+			$childIds = array_map(function(ICacheEntry $cacheEntry) {
 				return $cacheEntry->getId();
 			}, $children);
 
@@ -593,7 +593,7 @@ 
 			$query->execute();
 
 			/** @var ICacheEntry[] $childFolders */
-			$childFolders = array_filter($children, function ($child) {
+			$childFolders = array_filter($children, function($child) {
 				return $child->getMimeType() == FileInfo::MIMETYPE_FOLDER;
 			});
 			foreach ($childFolders as $folder) {
@@ -645,7 +645,7 @@ 
 
 			$sourceData = $sourceCache->get($sourcePath);
 			if ($sourceData === false) {
-				throw new \Exception('Invalid source storage path: ' . $sourcePath);
+				throw new \Exception('Invalid source storage path: '.$sourcePath);
 			}
 
 			$sourceId = $sourceData['fileid'];
@@ -655,10 +655,10 @@ 
 			[$targetStorageId, $targetPath] = $this->getMoveInfo($targetPath);
 
 			if (is_null($sourceStorageId) || $sourceStorageId === false) {
-				throw new \Exception('Invalid source storage id: ' . $sourceStorageId);
+				throw new \Exception('Invalid source storage id: '.$sourceStorageId);
 			}
 			if (is_null($targetStorageId) || $targetStorageId === false) {
-				throw new \Exception('Invalid target storage id: ' . $targetStorageId);
+				throw new \Exception('Invalid target storage id: '.$targetStorageId);
 			}
 
 			$this->connection->beginTransaction();
@@ -677,7 +677,7 @@ 
 					->set('path_hash', $fun->md5($newPathFunction))
 					->set('path', $newPathFunction)
 					->where($query->expr()->eq('storage', $query->createNamedParameter($sourceStorageId, IQueryBuilder::PARAM_INT)))
-					->andWhere($query->expr()->like('path', $query->createNamedParameter($this->connection->escapeLikeParameter($sourcePath) . '/%')));
+					->andWhere($query->expr()->like('path', $query->createNamedParameter($this->connection->escapeLikeParameter($sourcePath).'/%')));
 
 				try {
 					$query->execute();
@@ -756,7 +756,7 @@ 
 		$result->closeCursor();
 
 		if ($size !== false) {
-			if ((int)$size === -1) {
+			if ((int) $size === -1) {
 				return self::SHALLOW;
 			} else {
 				return self::COMPLETE;
@@ -790,7 +790,7 @@ 
 	 */
 	public function searchByMime($mimetype) {
 		if (strpos($mimetype, '/') === false) {
-			$operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%');
+			$operator = new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype.'/%');
 		} else {
 			$operator = new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype);
 		}
@@ -840,7 +840,7 @@ 
 				->andWhere($query->expr()->lt('size', $query->createNamedParameter(0, IQueryBuilder::PARAM_INT)));
 
 			$result = $query->execute();
-			$size = (int)$result->fetchOne();
+			$size = (int) $result->fetchOne();
 			$result->closeCursor();
 
 			return $size;
@@ -906,8 +906,8 @@ 
 		$files = $result->fetchAll(\PDO::FETCH_COLUMN);
 		$result->closeCursor();
 
-		return array_map(function ($id) {
-			return (int)$id;
+		return array_map(function($id) {
+			return (int) $id;
 		}, $files);
 	}
 
@@ -957,7 +957,7 @@ 
 			return null;
 		}
 
-		return (string)$path;
+		return (string) $path;
 	}
 
 	/**
@@ -1018,12 +1018,12 @@ 
 		$data = $this->cacheEntryToArray($sourceEntry);
 		$fileId = $this->put($targetPath, $data);
 		if ($fileId <= 0) {
-			throw new \RuntimeException("Failed to copy to " . $targetPath . " from cache with source data " . json_encode($data) . " ");
+			throw new \RuntimeException("Failed to copy to ".$targetPath." from cache with source data ".json_encode($data)." ");
 		}
 		if ($sourceEntry->getMimeType() === ICacheEntry::DIRECTORY_MIMETYPE) {
 			$folderContent = $sourceCache->getFolderContentsById($sourceEntry->getId());
 			foreach ($folderContent as $subEntry) {
-				$subTargetPath = $targetPath . '/' . $subEntry->getName();
+				$subTargetPath = $targetPath.'/'.$subEntry->getName();
 				$this->copyFromCache($sourceCache, $subEntry, $subTargetPath);
 			}
 		}

lib/private/Files/Cache/QuerySearchHelper.php

Indentation +119 added lines, -119 removed lines

@@ -37,123 +37,123 @@
 
 class QuerySearchHelper {
 
-	/** @var IMimeTypeLoader */
-	private $mimetypeLoader;
-	/** @var IDBConnection */
-	private $connection;
-	/** @var SystemConfig */
-	private $systemConfig;
-	/** @var ILogger */
-	private $logger;
-	/** @var SearchBuilder */
-	private $searchBuilder;
-
-	public function __construct(
-		IMimeTypeLoader $mimetypeLoader,
-		IDBConnection $connection,
-		SystemConfig $systemConfig,
-		ILogger $logger,
-		SearchBuilder $searchBuilder
-	) {
-		$this->mimetypeLoader = $mimetypeLoader;
-		$this->connection = $connection;
-		$this->systemConfig = $systemConfig;
-		$this->logger = $logger;
-		$this->searchBuilder = $searchBuilder;
-	}
-
-	protected function getQueryBuilder() {
-		return new CacheQueryBuilder(
-			$this->connection,
-			$this->systemConfig,
-			$this->logger
-		);
-	}
-
-	/**
-	 * Perform a file system search in multiple caches
-	 *
-	 * the results will be grouped by the same array keys as the $caches argument to allow
-	 * post-processing based on which cache the result came from
-	 *
-	 * @template T of array-key
-	 * @param ISearchQuery $searchQuery
-	 * @param array<T, ICache> $caches
-	 * @return array<T, ICacheEntry[]>
-	 */
-	public function searchInCaches(ISearchQuery $searchQuery, array $caches): array {
-		// search in multiple caches at once by creating one query in the following format
-		// SELECT ... FROM oc_filecache WHERE
-		//     <filter expressions from the search query>
-		// AND (
-		//     <filter expression for storage1> OR
-		//     <filter expression for storage2> OR
-		//     ...
-		// );
-		//
-		// This gives us all the files matching the search query from all caches
-		//
-		// while the resulting rows don't have a way to tell what storage they came from (multiple storages/caches can share storage_id)
-		// we can just ask every cache if the row belongs to them and give them the cache to do any post processing on the result.
-
-		$builder = $this->getQueryBuilder();
-
-		$query = $builder->selectFileCache('file');
-
-		if ($this->searchBuilder->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(
-					$builder->expr()->eq('tagmap.type', 'tag.type'),
-					$builder->expr()->eq('tagmap.categoryid', 'tag.id')
-				))
-				->andWhere($builder->expr()->eq('tag.type', $builder->createNamedParameter('files')))
-				->andWhere($builder->expr()->eq('tag.uid', $builder->createNamedParameter($user->getUID())));
-		}
-
-		$searchExpr = $this->searchBuilder->searchOperatorToDBExpr($builder, $searchQuery->getSearchOperation());
-		if ($searchExpr) {
-			$query->andWhere($searchExpr);
-		}
-
-		$storageFilters = array_values(array_map(function (ICache $cache) {
-			return $cache->getQueryFilterForStorage();
-		}, $caches));
-		$query->andWhere($this->searchBuilder->searchOperatorToDBExpr($builder, new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, $storageFilters)));
-
-		$this->searchBuilder->addSearchOrdersToQuery($query, $searchQuery->getOrder());
-
-		if ($searchQuery->getLimit()) {
-			$query->setMaxResults($searchQuery->getLimit());
-		}
-		if ($searchQuery->getOffset()) {
-			$query->setFirstResult($searchQuery->getOffset());
-		}
-
-		$result = $query->execute();
-		$files = $result->fetchAll();
-
-		$rawEntries = array_map(function (array $data) {
-			return Cache::cacheEntryFromData($data, $this->mimetypeLoader);
-		}, $files);
-
-		$result->closeCursor();
-
-		// loop trough all caches for each result to see if the result matches that storage
-		// results are grouped by the same array keys as the caches argument to allow the caller to distringuish the source of the results
-		$results = array_fill_keys(array_keys($caches), []);
-		foreach ($rawEntries as $rawEntry) {
-			foreach ($caches as $cacheKey => $cache) {
-				$entry = $cache->getCacheEntryFromSearchResult($rawEntry);
-				if ($entry) {
-					$results[$cacheKey][] = $entry;
-				}
-			}
-		}
-		return $results;
-	}
+    /** @var IMimeTypeLoader */
+    private $mimetypeLoader;
+    /** @var IDBConnection */
+    private $connection;
+    /** @var SystemConfig */
+    private $systemConfig;
+    /** @var ILogger */
+    private $logger;
+    /** @var SearchBuilder */
+    private $searchBuilder;
+
+    public function __construct(
+        IMimeTypeLoader $mimetypeLoader,
+        IDBConnection $connection,
+        SystemConfig $systemConfig,
+        ILogger $logger,
+        SearchBuilder $searchBuilder
+    ) {
+        $this->mimetypeLoader = $mimetypeLoader;
+        $this->connection = $connection;
+        $this->systemConfig = $systemConfig;
+        $this->logger = $logger;
+        $this->searchBuilder = $searchBuilder;
+    }
+
+    protected function getQueryBuilder() {
+        return new CacheQueryBuilder(
+            $this->connection,
+            $this->systemConfig,
+            $this->logger
+        );
+    }
+
+    /**
+     * Perform a file system search in multiple caches
+     *
+     * the results will be grouped by the same array keys as the $caches argument to allow
+     * post-processing based on which cache the result came from
+     *
+     * @template T of array-key
+     * @param ISearchQuery $searchQuery
+     * @param array<T, ICache> $caches
+     * @return array<T, ICacheEntry[]>
+     */
+    public function searchInCaches(ISearchQuery $searchQuery, array $caches): array {
+        // search in multiple caches at once by creating one query in the following format
+        // SELECT ... FROM oc_filecache WHERE
+        //     <filter expressions from the search query>
+        // AND (
+        //     <filter expression for storage1> OR
+        //     <filter expression for storage2> OR
+        //     ...
+        // );
+        //
+        // This gives us all the files matching the search query from all caches
+        //
+        // while the resulting rows don't have a way to tell what storage they came from (multiple storages/caches can share storage_id)
+        // we can just ask every cache if the row belongs to them and give them the cache to do any post processing on the result.
+
+        $builder = $this->getQueryBuilder();
+
+        $query = $builder->selectFileCache('file');
+
+        if ($this->searchBuilder->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(
+                    $builder->expr()->eq('tagmap.type', 'tag.type'),
+                    $builder->expr()->eq('tagmap.categoryid', 'tag.id')
+                ))
+                ->andWhere($builder->expr()->eq('tag.type', $builder->createNamedParameter('files')))
+                ->andWhere($builder->expr()->eq('tag.uid', $builder->createNamedParameter($user->getUID())));
+        }
+
+        $searchExpr = $this->searchBuilder->searchOperatorToDBExpr($builder, $searchQuery->getSearchOperation());
+        if ($searchExpr) {
+            $query->andWhere($searchExpr);
+        }
+
+        $storageFilters = array_values(array_map(function (ICache $cache) {
+            return $cache->getQueryFilterForStorage();
+        }, $caches));
+        $query->andWhere($this->searchBuilder->searchOperatorToDBExpr($builder, new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, $storageFilters)));
+
+        $this->searchBuilder->addSearchOrdersToQuery($query, $searchQuery->getOrder());
+
+        if ($searchQuery->getLimit()) {
+            $query->setMaxResults($searchQuery->getLimit());
+        }
+        if ($searchQuery->getOffset()) {
+            $query->setFirstResult($searchQuery->getOffset());
+        }
+
+        $result = $query->execute();
+        $files = $result->fetchAll();
+
+        $rawEntries = array_map(function (array $data) {
+            return Cache::cacheEntryFromData($data, $this->mimetypeLoader);
+        }, $files);
+
+        $result->closeCursor();
+
+        // loop trough all caches for each result to see if the result matches that storage
+        // results are grouped by the same array keys as the caches argument to allow the caller to distringuish the source of the results
+        $results = array_fill_keys(array_keys($caches), []);
+        foreach ($rawEntries as $rawEntry) {
+            foreach ($caches as $cacheKey => $cache) {
+                $entry = $cache->getCacheEntryFromSearchResult($rawEntry);
+                if ($entry) {
+                    $results[$cacheKey][] = $entry;
+                }
+            }
+        }
+        return $results;
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -120,7 +120,7 @@ 
 			$query->andWhere($searchExpr);
 		}
 
-		$storageFilters = array_values(array_map(function (ICache $cache) {
+		$storageFilters = array_values(array_map(function(ICache $cache) {
 			return $cache->getQueryFilterForStorage();
 		}, $caches));
 		$query->andWhere($this->searchBuilder->searchOperatorToDBExpr($builder, new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR, $storageFilters)));
@@ -137,7 +137,7 @@ 
 		$result = $query->execute();
 		$files = $result->fetchAll();
 
-		$rawEntries = array_map(function (array $data) {
+		$rawEntries = array_map(function(array $data) {
 			return Cache::cacheEntryFromData($data, $this->mimetypeLoader);
 		}, $files);
 

lib/private/Files/Cache/FailedCache.php

Indentation +116 added lines, -116 removed lines

@@ -33,120 +33,120 @@
  * Storage placeholder to represent a missing precondition, storage unavailable
  */
 class FailedCache implements ICache {
-	/** @var bool whether to show the failed storage in the ui */
-	private $visible;
-
-	/**
-	 * FailedCache constructor.
-	 *
-	 * @param bool $visible
-	 */
-	public function __construct($visible = true) {
-		$this->visible = $visible;
-	}
-
-
-	public function getNumericStorageId() {
-		return -1;
-	}
-
-	public function get($file) {
-		if ($file === '') {
-			return new CacheEntry([
-				'fileid' => -1,
-				'size' => 0,
-				'mimetype' => 'httpd/unix-directory',
-				'mimepart' => 'httpd',
-				'permissions' => $this->visible ? Constants::PERMISSION_READ : 0,
-				'mtime' => time()
-			]);
-		} else {
-			return false;
-		}
-	}
-
-	public function getFolderContents($folder) {
-		return [];
-	}
-
-	public function getFolderContentsById($fileId) {
-		return [];
-	}
-
-	public function put($file, array $data) {
-	}
-
-	public function insert($file, array $data) {
-	}
-
-	public function update($id, array $data) {
-	}
-
-	public function getId($file) {
-		return -1;
-	}
-
-	public function getParentId($file) {
-		return -1;
-	}
-
-	public function inCache($file) {
-		return false;
-	}
-
-	public function remove($file) {
-	}
-
-	public function move($source, $target) {
-	}
-
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-	}
-
-	public function clear() {
-	}
-
-	public function getStatus($file) {
-		return ICache::NOT_FOUND;
-	}
-
-	public function search($pattern) {
-		return [];
-	}
-
-	public function searchByMime($mimetype) {
-		return [];
-	}
-
-	public function searchQuery(ISearchQuery $query) {
-		return [];
-	}
-
-	public function getAll() {
-		return [];
-	}
-
-	public function getIncomplete() {
-		return [];
-	}
-
-	public function getPathById($id) {
-		return null;
-	}
-
-	public function normalize($path) {
-		return $path;
-	}
-
-	public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, string $targetPath): int {
-		throw new \Exception("Invalid cache");
-	}
-
-	public function getQueryFilterForStorage(): ISearchOperator {
-		return new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'storage', -1);
-	}
-
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		return null;
-	}
+    /** @var bool whether to show the failed storage in the ui */
+    private $visible;
+
+    /**
+     * FailedCache constructor.
+     *
+     * @param bool $visible
+     */
+    public function __construct($visible = true) {
+        $this->visible = $visible;
+    }
+
+
+    public function getNumericStorageId() {
+        return -1;
+    }
+
+    public function get($file) {
+        if ($file === '') {
+            return new CacheEntry([
+                'fileid' => -1,
+                'size' => 0,
+                'mimetype' => 'httpd/unix-directory',
+                'mimepart' => 'httpd',
+                'permissions' => $this->visible ? Constants::PERMISSION_READ : 0,
+                'mtime' => time()
+            ]);
+        } else {
+            return false;
+        }
+    }
+
+    public function getFolderContents($folder) {
+        return [];
+    }
+
+    public function getFolderContentsById($fileId) {
+        return [];
+    }
+
+    public function put($file, array $data) {
+    }
+
+    public function insert($file, array $data) {
+    }
+
+    public function update($id, array $data) {
+    }
+
+    public function getId($file) {
+        return -1;
+    }
+
+    public function getParentId($file) {
+        return -1;
+    }
+
+    public function inCache($file) {
+        return false;
+    }
+
+    public function remove($file) {
+    }
+
+    public function move($source, $target) {
+    }
+
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+    }
+
+    public function clear() {
+    }
+
+    public function getStatus($file) {
+        return ICache::NOT_FOUND;
+    }
+
+    public function search($pattern) {
+        return [];
+    }
+
+    public function searchByMime($mimetype) {
+        return [];
+    }
+
+    public function searchQuery(ISearchQuery $query) {
+        return [];
+    }
+
+    public function getAll() {
+        return [];
+    }
+
+    public function getIncomplete() {
+        return [];
+    }
+
+    public function getPathById($id) {
+        return null;
+    }
+
+    public function normalize($path) {
+        return $path;
+    }
+
+    public function copyFromCache(ICache $sourceCache, ICacheEntry $sourceEntry, string $targetPath): int {
+        throw new \Exception("Invalid cache");
+    }
+
+    public function getQueryFilterForStorage(): ISearchOperator {
+        return new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'storage', -1);
+    }
+
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        return null;
+    }
 }

lib/private/Files/Cache/CacheQueryBuilder.php

Indentation +51 added lines, -51 removed lines

@@ -35,72 +35,72 @@
  * Query builder with commonly used helpers for filecache queries
  */
 class CacheQueryBuilder extends QueryBuilder {
-	private $alias = null;
+    private $alias = null;
 
-	public function __construct(IDBConnection $connection, SystemConfig $systemConfig, ILogger $logger) {
-		parent::__construct($connection, $systemConfig, $logger);
-	}
+    public function __construct(IDBConnection $connection, SystemConfig $systemConfig, ILogger $logger) {
+        parent::__construct($connection, $systemConfig, $logger);
+    }
 
-	public function selectFileCache(string $alias = null) {
-		$name = $alias ? $alias : 'filecache';
-		$this->select("$name.fileid", 'storage', 'path', 'path_hash', "$name.parent", 'name', 'mimetype', 'mimepart', 'size', 'mtime',
-			'storage_mtime', 'encrypted', 'etag', 'permissions', 'checksum', 'metadata_etag', 'creation_time', 'upload_time')
-			->from('filecache', $name)
-			->leftJoin($name, 'filecache_extended', 'fe', $this->expr()->eq("$name.fileid", 'fe.fileid'));
+    public function selectFileCache(string $alias = null) {
+        $name = $alias ? $alias : 'filecache';
+        $this->select("$name.fileid", 'storage', 'path', 'path_hash', "$name.parent", 'name', 'mimetype', 'mimepart', 'size', 'mtime',
+            'storage_mtime', 'encrypted', 'etag', 'permissions', 'checksum', 'metadata_etag', 'creation_time', 'upload_time')
+            ->from('filecache', $name)
+            ->leftJoin($name, 'filecache_extended', 'fe', $this->expr()->eq("$name.fileid", 'fe.fileid'));
 
-		$this->alias = $name;
+        $this->alias = $name;
 
-		return $this;
-	}
+        return $this;
+    }
 
-	public function whereStorageId(int $storageId) {
-		$this->andWhere($this->expr()->eq('storage', $this->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
+    public function whereStorageId(int $storageId) {
+        $this->andWhere($this->expr()->eq('storage', $this->createNamedParameter($storageId, IQueryBuilder::PARAM_INT)));
 
-		return $this;
-	}
+        return $this;
+    }
 
-	public function whereFileId(int $fileId) {
-		$alias = $this->alias;
-		if ($alias) {
-			$alias .= '.';
-		} else {
-			$alias = '';
-		}
+    public function whereFileId(int $fileId) {
+        $alias = $this->alias;
+        if ($alias) {
+            $alias .= '.';
+        } else {
+            $alias = '';
+        }
 
-		$this->andWhere($this->expr()->eq("{$alias}fileid", $this->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
+        $this->andWhere($this->expr()->eq("{$alias}fileid", $this->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
 
-		return $this;
-	}
+        return $this;
+    }
 
-	public function wherePath(string $path) {
-		$this->andWhere($this->expr()->eq('path_hash', $this->createNamedParameter(md5($path))));
+    public function wherePath(string $path) {
+        $this->andWhere($this->expr()->eq('path_hash', $this->createNamedParameter(md5($path))));
 
-		return $this;
-	}
+        return $this;
+    }
 
-	public function whereParent(int $parent) {
-		$alias = $this->alias;
-		if ($alias) {
-			$alias .= '.';
-		} else {
-			$alias = '';
-		}
+    public function whereParent(int $parent) {
+        $alias = $this->alias;
+        if ($alias) {
+            $alias .= '.';
+        } else {
+            $alias = '';
+        }
 
-		$this->andWhere($this->expr()->eq("{$alias}parent", $this->createNamedParameter($parent, IQueryBuilder::PARAM_INT)));
+        $this->andWhere($this->expr()->eq("{$alias}parent", $this->createNamedParameter($parent, IQueryBuilder::PARAM_INT)));
 
-		return $this;
-	}
+        return $this;
+    }
 
-	public function whereParentIn(array $parents) {
-		$alias = $this->alias;
-		if ($alias) {
-			$alias .= '.';
-		} else {
-			$alias = '';
-		}
+    public function whereParentIn(array $parents) {
+        $alias = $this->alias;
+        if ($alias) {
+            $alias .= '.';
+        } else {
+            $alias = '';
+        }
 
-		$this->andWhere($this->expr()->in("{$alias}parent", $this->createNamedParameter($parents, IQueryBuilder::PARAM_INT_ARRAY)));
+        $this->andWhere($this->expr()->in("{$alias}parent", $this->createNamedParameter($parents, IQueryBuilder::PARAM_INT_ARRAY)));
 
-		return $this;
-	}
+        return $this;
+    }
 }

lib/private/Files/Cache/Wrapper/CacheWrapper.php

Indentation +250 added lines, -250 removed lines

@@ -37,283 +37,283 @@
 use OCP\Files\Search\ISearchQuery;
 
 class CacheWrapper extends Cache {
-	/**
-	 * @var \OCP\Files\Cache\ICache
-	 */
-	protected $cache;
+    /**
+     * @var \OCP\Files\Cache\ICache
+     */
+    protected $cache;
 
-	/**
-	 * @param \OCP\Files\Cache\ICache $cache
-	 */
-	public function __construct($cache) {
-		$this->cache = $cache;
-		$this->mimetypeLoader = \OC::$server->getMimeTypeLoader();
-		$this->connection = \OC::$server->getDatabaseConnection();
-		$this->querySearchHelper = \OC::$server->get(QuerySearchHelper::class);
-	}
+    /**
+     * @param \OCP\Files\Cache\ICache $cache
+     */
+    public function __construct($cache) {
+        $this->cache = $cache;
+        $this->mimetypeLoader = \OC::$server->getMimeTypeLoader();
+        $this->connection = \OC::$server->getDatabaseConnection();
+        $this->querySearchHelper = \OC::$server->get(QuerySearchHelper::class);
+    }
 
-	protected function getCache() {
-		return $this->cache;
-	}
+    protected function getCache() {
+        return $this->cache;
+    }
 
-	/**
-	 * Make it easy for wrappers to modify every returned cache entry
-	 *
-	 * @param ICacheEntry $entry
-	 * @return ICacheEntry
-	 */
-	protected function formatCacheEntry($entry) {
-		return $entry;
-	}
+    /**
+     * Make it easy for wrappers to modify every returned cache entry
+     *
+     * @param ICacheEntry $entry
+     * @return ICacheEntry
+     */
+    protected function formatCacheEntry($entry) {
+        return $entry;
+    }
 
-	/**
-	 * get the stored metadata of a file or folder
-	 *
-	 * @param string|int $file
-	 * @return ICacheEntry|false
-	 */
-	public function get($file) {
-		$result = $this->getCache()->get($file);
-		if ($result) {
-			$result = $this->formatCacheEntry($result);
-		}
-		return $result;
-	}
+    /**
+     * get the stored metadata of a file or folder
+     *
+     * @param string|int $file
+     * @return ICacheEntry|false
+     */
+    public function get($file) {
+        $result = $this->getCache()->get($file);
+        if ($result) {
+            $result = $this->formatCacheEntry($result);
+        }
+        return $result;
+    }
 
-	/**
-	 * get the metadata of all files stored in $folder
-	 *
-	 * @param string $folder
-	 * @return ICacheEntry[]
-	 */
-	public function getFolderContents($folder) {
-		// can't do a simple $this->getCache()->.... call here since getFolderContentsById needs to be called on this
-		// and not the wrapped cache
-		$fileId = $this->getId($folder);
-		return $this->getFolderContentsById($fileId);
-	}
+    /**
+     * get the metadata of all files stored in $folder
+     *
+     * @param string $folder
+     * @return ICacheEntry[]
+     */
+    public function getFolderContents($folder) {
+        // can't do a simple $this->getCache()->.... call here since getFolderContentsById needs to be called on this
+        // and not the wrapped cache
+        $fileId = $this->getId($folder);
+        return $this->getFolderContentsById($fileId);
+    }
 
-	/**
-	 * get the metadata of all files stored in $folder
-	 *
-	 * @param int $fileId the file id of the folder
-	 * @return array
-	 */
-	public function getFolderContentsById($fileId) {
-		$results = $this->getCache()->getFolderContentsById($fileId);
-		return array_map([$this, 'formatCacheEntry'], $results);
-	}
+    /**
+     * get the metadata of all files stored in $folder
+     *
+     * @param int $fileId the file id of the folder
+     * @return array
+     */
+    public function getFolderContentsById($fileId) {
+        $results = $this->getCache()->getFolderContentsById($fileId);
+        return array_map([$this, 'formatCacheEntry'], $results);
+    }
 
-	/**
-	 * insert or update meta data for a file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function put($file, array $data) {
-		if (($id = $this->getId($file)) > -1) {
-			$this->update($id, $data);
-			return $id;
-		} else {
-			return $this->insert($file, $data);
-		}
-	}
+    /**
+     * insert or update meta data for a file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function put($file, array $data) {
+        if (($id = $this->getId($file)) > -1) {
+            $this->update($id, $data);
+            return $id;
+        } else {
+            return $this->insert($file, $data);
+        }
+    }
 
-	/**
-	 * insert meta data for a new file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function insert($file, array $data) {
-		return $this->getCache()->insert($file, $data);
-	}
+    /**
+     * insert meta data for a new file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function insert($file, array $data) {
+        return $this->getCache()->insert($file, $data);
+    }
 
-	/**
-	 * update the metadata in the cache
-	 *
-	 * @param int $id
-	 * @param array $data
-	 */
-	public function update($id, array $data) {
-		$this->getCache()->update($id, $data);
-	}
+    /**
+     * update the metadata in the cache
+     *
+     * @param int $id
+     * @param array $data
+     */
+    public function update($id, array $data) {
+        $this->getCache()->update($id, $data);
+    }
 
-	/**
-	 * get the file id for a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getId($file) {
-		return $this->getCache()->getId($file);
-	}
+    /**
+     * get the file id for a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getId($file) {
+        return $this->getCache()->getId($file);
+    }
 
-	/**
-	 * get the id of the parent folder of a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getParentId($file) {
-		return $this->getCache()->getParentId($file);
-	}
+    /**
+     * get the id of the parent folder of a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getParentId($file) {
+        return $this->getCache()->getParentId($file);
+    }
 
-	/**
-	 * check if a file is available in the cache
-	 *
-	 * @param string $file
-	 * @return bool
-	 */
-	public function inCache($file) {
-		return $this->getCache()->inCache($file);
-	}
+    /**
+     * check if a file is available in the cache
+     *
+     * @param string $file
+     * @return bool
+     */
+    public function inCache($file) {
+        return $this->getCache()->inCache($file);
+    }
 
-	/**
-	 * remove a file or folder from the cache
-	 *
-	 * @param string $file
-	 */
-	public function remove($file) {
-		$this->getCache()->remove($file);
-	}
+    /**
+     * remove a file or folder from the cache
+     *
+     * @param string $file
+     */
+    public function remove($file) {
+        $this->getCache()->remove($file);
+    }
 
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function move($source, $target) {
-		$this->getCache()->move($source, $target);
-	}
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param string $source
+     * @param string $target
+     */
+    public function move($source, $target) {
+        $this->getCache()->move($source, $target);
+    }
 
-	protected function getMoveInfo($path) {
-		/** @var Cache $cache */
-		$cache = $this->getCache();
-		return $cache->getMoveInfo($path);
-	}
+    protected function getMoveInfo($path) {
+        /** @var Cache $cache */
+        $cache = $this->getCache();
+        return $cache->getMoveInfo($path);
+    }
 
-	public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
-		$this->getCache()->moveFromCache($sourceCache, $sourcePath, $targetPath);
-	}
+    public function moveFromCache(ICache $sourceCache, $sourcePath, $targetPath) {
+        $this->getCache()->moveFromCache($sourceCache, $sourcePath, $targetPath);
+    }
 
-	/**
-	 * remove all entries for files that are stored on the storage from the cache
-	 */
-	public function clear() {
-		$this->getCache()->clear();
-	}
+    /**
+     * remove all entries for files that are stored on the storage from the cache
+     */
+    public function clear() {
+        $this->getCache()->clear();
+    }
 
-	/**
-	 * @param string $file
-	 *
-	 * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
-	 */
-	public function getStatus($file) {
-		return $this->getCache()->getStatus($file);
-	}
+    /**
+     * @param string $file
+     *
+     * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
+     */
+    public function getStatus($file) {
+        return $this->getCache()->getStatus($file);
+    }
 
-	public function searchQuery(ISearchQuery $searchQuery) {
-		return current($this->querySearchHelper->searchInCaches($searchQuery, [$this]));
-	}
+    public function searchQuery(ISearchQuery $searchQuery) {
+        return current($this->querySearchHelper->searchInCaches($searchQuery, [$this]));
+    }
 
-	/**
-	 * update the folder size and the size of all parent folders
-	 *
-	 * @param string|boolean $path
-	 * @param array $data (optional) meta data of the folder
-	 */
-	public function correctFolderSize($path, $data = null, $isBackgroundScan = false) {
-		if ($this->getCache() instanceof Cache) {
-			$this->getCache()->correctFolderSize($path, $data, $isBackgroundScan);
-		}
-	}
+    /**
+     * update the folder size and the size of all parent folders
+     *
+     * @param string|boolean $path
+     * @param array $data (optional) meta data of the folder
+     */
+    public function correctFolderSize($path, $data = null, $isBackgroundScan = false) {
+        if ($this->getCache() instanceof Cache) {
+            $this->getCache()->correctFolderSize($path, $data, $isBackgroundScan);
+        }
+    }
 
-	/**
-	 * get the size of a folder and set it in the cache
-	 *
-	 * @param string $path
-	 * @param array $entry (optional) meta data of the folder
-	 * @return int
-	 */
-	public function calculateFolderSize($path, $entry = null) {
-		if ($this->getCache() instanceof Cache) {
-			return $this->getCache()->calculateFolderSize($path, $entry);
-		} else {
-			return 0;
-		}
-	}
+    /**
+     * get the size of a folder and set it in the cache
+     *
+     * @param string $path
+     * @param array $entry (optional) meta data of the folder
+     * @return int
+     */
+    public function calculateFolderSize($path, $entry = null) {
+        if ($this->getCache() instanceof Cache) {
+            return $this->getCache()->calculateFolderSize($path, $entry);
+        } else {
+            return 0;
+        }
+    }
 
-	/**
-	 * get all file ids on the files on the storage
-	 *
-	 * @return int[]
-	 */
-	public function getAll() {
-		return $this->getCache()->getAll();
-	}
+    /**
+     * get all file ids on the files on the storage
+     *
+     * @return int[]
+     */
+    public function getAll() {
+        return $this->getCache()->getAll();
+    }
 
-	/**
-	 * find a folder in the cache which has not been fully scanned
-	 *
-	 * If multiple incomplete folders are in the cache, the one with the highest id will be returned,
-	 * use the one with the highest id gives the best result with the background scanner, since that is most
-	 * likely the folder where we stopped scanning previously
-	 *
-	 * @return string|bool the path of the folder or false when no folder matched
-	 */
-	public function getIncomplete() {
-		return $this->getCache()->getIncomplete();
-	}
+    /**
+     * find a folder in the cache which has not been fully scanned
+     *
+     * If multiple incomplete folders are in the cache, the one with the highest id will be returned,
+     * use the one with the highest id gives the best result with the background scanner, since that is most
+     * likely the folder where we stopped scanning previously
+     *
+     * @return string|bool the path of the folder or false when no folder matched
+     */
+    public function getIncomplete() {
+        return $this->getCache()->getIncomplete();
+    }
 
-	/**
-	 * get the path of a file on this storage by it's id
-	 *
-	 * @param int $id
-	 * @return string|null
-	 */
-	public function getPathById($id) {
-		return $this->getCache()->getPathById($id);
-	}
+    /**
+     * get the path of a file on this storage by it's id
+     *
+     * @param int $id
+     * @return string|null
+     */
+    public function getPathById($id) {
+        return $this->getCache()->getPathById($id);
+    }
 
-	/**
-	 * Returns the numeric storage id
-	 *
-	 * @return int
-	 */
-	public function getNumericStorageId() {
-		return $this->getCache()->getNumericStorageId();
-	}
+    /**
+     * Returns the numeric storage id
+     *
+     * @return int
+     */
+    public function getNumericStorageId() {
+        return $this->getCache()->getNumericStorageId();
+    }
 
-	/**
-	 * get the storage id of the storage for a file and the internal path of the file
-	 * unlike getPathById this does not limit the search to files on this storage and
-	 * instead does a global search in the cache table
-	 *
-	 * @param int $id
-	 * @return array first element holding the storage id, second the path
-	 */
-	public static function getById($id) {
-		return parent::getById($id);
-	}
+    /**
+     * get the storage id of the storage for a file and the internal path of the file
+     * unlike getPathById this does not limit the search to files on this storage and
+     * instead does a global search in the cache table
+     *
+     * @param int $id
+     * @return array first element holding the storage id, second the path
+     */
+    public static function getById($id) {
+        return parent::getById($id);
+    }
 
-	public function getQueryFilterForStorage(): ISearchOperator {
-		return $this->getCache()->getQueryFilterForStorage();
-	}
+    public function getQueryFilterForStorage(): ISearchOperator {
+        return $this->getCache()->getQueryFilterForStorage();
+    }
 
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		$rawEntry = $this->getCache()->getCacheEntryFromSearchResult($rawEntry);
-		if ($rawEntry) {
-			return $this->formatCacheEntry(clone $rawEntry);
-		}
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        $rawEntry = $this->getCache()->getCacheEntryFromSearchResult($rawEntry);
+        if ($rawEntry) {
+            return $this->formatCacheEntry(clone $rawEntry);
+        }
 
-		return null;
-	}
+        return null;
+    }
 }

lib/private/Files/Cache/Wrapper/CacheJail.php

Indentation +263 added lines, -263 removed lines

@@ -39,295 +39,295 @@
  * Jail to a subdirectory of the wrapped cache
  */
 class CacheJail extends CacheWrapper {
-	/**
-	 * @var string
-	 */
-	protected $root;
-	protected $unjailedRoot;
+    /**
+     * @var string
+     */
+    protected $root;
+    protected $unjailedRoot;
 
-	/**
-	 * @param \OCP\Files\Cache\ICache $cache
-	 * @param string $root
-	 */
-	public function __construct($cache, $root) {
-		parent::__construct($cache);
-		$this->root = $root;
-		$this->connection = \OC::$server->getDatabaseConnection();
-		$this->mimetypeLoader = \OC::$server->getMimeTypeLoader();
+    /**
+     * @param \OCP\Files\Cache\ICache $cache
+     * @param string $root
+     */
+    public function __construct($cache, $root) {
+        parent::__construct($cache);
+        $this->root = $root;
+        $this->connection = \OC::$server->getDatabaseConnection();
+        $this->mimetypeLoader = \OC::$server->getMimeTypeLoader();
 
-		if ($cache instanceof CacheJail) {
-			$this->unjailedRoot = $cache->getSourcePath($root);
-		} else {
-			$this->unjailedRoot = $root;
-		}
-	}
+        if ($cache instanceof CacheJail) {
+            $this->unjailedRoot = $cache->getSourcePath($root);
+        } else {
+            $this->unjailedRoot = $root;
+        }
+    }
 
-	protected function getRoot() {
-		return $this->root;
-	}
+    protected function getRoot() {
+        return $this->root;
+    }
 
-	/**
-	 * Get the root path with any nested jails resolved
-	 *
-	 * @return string
-	 */
-	protected function getGetUnjailedRoot() {
-		return $this->unjailedRoot;
-	}
+    /**
+     * Get the root path with any nested jails resolved
+     *
+     * @return string
+     */
+    protected function getGetUnjailedRoot() {
+        return $this->unjailedRoot;
+    }
 
-	protected function getSourcePath($path) {
-		if ($path === '') {
-			return $this->getRoot();
-		} else {
-			return $this->getRoot() . '/' . ltrim($path, '/');
-		}
-	}
+    protected function getSourcePath($path) {
+        if ($path === '') {
+            return $this->getRoot();
+        } else {
+            return $this->getRoot() . '/' . ltrim($path, '/');
+        }
+    }
 
-	/**
-	 * @param string $path
-	 * @param null|string $root
-	 * @return null|string the jailed path or null if the path is outside the jail
-	 */
-	protected function getJailedPath(string $path, string $root = null) {
-		if ($root === null) {
-			$root = $this->getRoot();
-		}
-		if ($root === '') {
-			return $path;
-		}
-		$rootLength = strlen($root) + 1;
-		if ($path === $root) {
-			return '';
-		} elseif (substr($path, 0, $rootLength) === $root . '/') {
-			return substr($path, $rootLength);
-		} else {
-			return null;
-		}
-	}
+    /**
+     * @param string $path
+     * @param null|string $root
+     * @return null|string the jailed path or null if the path is outside the jail
+     */
+    protected function getJailedPath(string $path, string $root = null) {
+        if ($root === null) {
+            $root = $this->getRoot();
+        }
+        if ($root === '') {
+            return $path;
+        }
+        $rootLength = strlen($root) + 1;
+        if ($path === $root) {
+            return '';
+        } elseif (substr($path, 0, $rootLength) === $root . '/') {
+            return substr($path, $rootLength);
+        } else {
+            return null;
+        }
+    }
 
-	protected function formatCacheEntry($entry) {
-		if (isset($entry['path'])) {
-			$entry['path'] = $this->getJailedPath($entry['path']);
-		}
-		return $entry;
-	}
+    protected function formatCacheEntry($entry) {
+        if (isset($entry['path'])) {
+            $entry['path'] = $this->getJailedPath($entry['path']);
+        }
+        return $entry;
+    }
 
-	/**
-	 * get the stored metadata of a file or folder
-	 *
-	 * @param string /int $file
-	 * @return ICacheEntry|false
-	 */
-	public function get($file) {
-		if (is_string($file) or $file == '') {
-			$file = $this->getSourcePath($file);
-		}
-		return parent::get($file);
-	}
+    /**
+     * get the stored metadata of a file or folder
+     *
+     * @param string /int $file
+     * @return ICacheEntry|false
+     */
+    public function get($file) {
+        if (is_string($file) or $file == '') {
+            $file = $this->getSourcePath($file);
+        }
+        return parent::get($file);
+    }
 
-	/**
-	 * insert meta data for a new file or folder
-	 *
-	 * @param string $file
-	 * @param array $data
-	 *
-	 * @return int file id
-	 * @throws \RuntimeException
-	 */
-	public function insert($file, array $data) {
-		return $this->getCache()->insert($this->getSourcePath($file), $data);
-	}
+    /**
+     * insert meta data for a new file or folder
+     *
+     * @param string $file
+     * @param array $data
+     *
+     * @return int file id
+     * @throws \RuntimeException
+     */
+    public function insert($file, array $data) {
+        return $this->getCache()->insert($this->getSourcePath($file), $data);
+    }
 
-	/**
-	 * update the metadata in the cache
-	 *
-	 * @param int $id
-	 * @param array $data
-	 */
-	public function update($id, array $data) {
-		$this->getCache()->update($id, $data);
-	}
+    /**
+     * update the metadata in the cache
+     *
+     * @param int $id
+     * @param array $data
+     */
+    public function update($id, array $data) {
+        $this->getCache()->update($id, $data);
+    }
 
-	/**
-	 * get the file id for a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getId($file) {
-		return $this->getCache()->getId($this->getSourcePath($file));
-	}
+    /**
+     * get the file id for a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getId($file) {
+        return $this->getCache()->getId($this->getSourcePath($file));
+    }
 
-	/**
-	 * get the id of the parent folder of a file
-	 *
-	 * @param string $file
-	 * @return int
-	 */
-	public function getParentId($file) {
-		return $this->getCache()->getParentId($this->getSourcePath($file));
-	}
+    /**
+     * get the id of the parent folder of a file
+     *
+     * @param string $file
+     * @return int
+     */
+    public function getParentId($file) {
+        return $this->getCache()->getParentId($this->getSourcePath($file));
+    }
 
-	/**
-	 * check if a file is available in the cache
-	 *
-	 * @param string $file
-	 * @return bool
-	 */
-	public function inCache($file) {
-		return $this->getCache()->inCache($this->getSourcePath($file));
-	}
+    /**
+     * check if a file is available in the cache
+     *
+     * @param string $file
+     * @return bool
+     */
+    public function inCache($file) {
+        return $this->getCache()->inCache($this->getSourcePath($file));
+    }
 
-	/**
-	 * remove a file or folder from the cache
-	 *
-	 * @param string $file
-	 */
-	public function remove($file) {
-		$this->getCache()->remove($this->getSourcePath($file));
-	}
+    /**
+     * remove a file or folder from the cache
+     *
+     * @param string $file
+     */
+    public function remove($file) {
+        $this->getCache()->remove($this->getSourcePath($file));
+    }
 
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * @param string $source
-	 * @param string $target
-	 */
-	public function move($source, $target) {
-		$this->getCache()->move($this->getSourcePath($source), $this->getSourcePath($target));
-	}
+    /**
+     * Move a file or folder in the cache
+     *
+     * @param string $source
+     * @param string $target
+     */
+    public function move($source, $target) {
+        $this->getCache()->move($this->getSourcePath($source), $this->getSourcePath($target));
+    }
 
-	/**
-	 * Get the storage id and path needed for a move
-	 *
-	 * @param string $path
-	 * @return array [$storageId, $internalPath]
-	 */
-	protected function getMoveInfo($path) {
-		return [$this->getNumericStorageId(), $this->getSourcePath($path)];
-	}
+    /**
+     * Get the storage id and path needed for a move
+     *
+     * @param string $path
+     * @return array [$storageId, $internalPath]
+     */
+    protected function getMoveInfo($path) {
+        return [$this->getNumericStorageId(), $this->getSourcePath($path)];
+    }
 
-	/**
-	 * remove all entries for files that are stored on the storage from the cache
-	 */
-	public function clear() {
-		$this->getCache()->remove($this->getRoot());
-	}
+    /**
+     * remove all entries for files that are stored on the storage from the cache
+     */
+    public function clear() {
+        $this->getCache()->remove($this->getRoot());
+    }
 
-	/**
-	 * @param string $file
-	 *
-	 * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
-	 */
-	public function getStatus($file) {
-		return $this->getCache()->getStatus($this->getSourcePath($file));
-	}
+    /**
+     * @param string $file
+     *
+     * @return int Cache::NOT_FOUND, Cache::PARTIAL, Cache::SHALLOW or Cache::COMPLETE
+     */
+    public function getStatus($file) {
+        return $this->getCache()->getStatus($this->getSourcePath($file));
+    }
 
-	/**
-	 * update the folder size and the size of all parent folders
-	 *
-	 * @param string|boolean $path
-	 * @param array $data (optional) meta data of the folder
-	 */
-	public function correctFolderSize($path, $data = null, $isBackgroundScan = false) {
-		if ($this->getCache() instanceof Cache) {
-			$this->getCache()->correctFolderSize($this->getSourcePath($path), $data, $isBackgroundScan);
-		}
-	}
+    /**
+     * update the folder size and the size of all parent folders
+     *
+     * @param string|boolean $path
+     * @param array $data (optional) meta data of the folder
+     */
+    public function correctFolderSize($path, $data = null, $isBackgroundScan = false) {
+        if ($this->getCache() instanceof Cache) {
+            $this->getCache()->correctFolderSize($this->getSourcePath($path), $data, $isBackgroundScan);
+        }
+    }
 
-	/**
-	 * get the size of a folder and set it in the cache
-	 *
-	 * @param string $path
-	 * @param array $entry (optional) meta data of the folder
-	 * @return int
-	 */
-	public function calculateFolderSize($path, $entry = null) {
-		if ($this->getCache() instanceof Cache) {
-			return $this->getCache()->calculateFolderSize($this->getSourcePath($path), $entry);
-		} else {
-			return 0;
-		}
-	}
+    /**
+     * get the size of a folder and set it in the cache
+     *
+     * @param string $path
+     * @param array $entry (optional) meta data of the folder
+     * @return int
+     */
+    public function calculateFolderSize($path, $entry = null) {
+        if ($this->getCache() instanceof Cache) {
+            return $this->getCache()->calculateFolderSize($this->getSourcePath($path), $entry);
+        } else {
+            return 0;
+        }
+    }
 
-	/**
-	 * get all file ids on the files on the storage
-	 *
-	 * @return int[]
-	 */
-	public function getAll() {
-		// not supported
-		return [];
-	}
+    /**
+     * get all file ids on the files on the storage
+     *
+     * @return int[]
+     */
+    public function getAll() {
+        // not supported
+        return [];
+    }
 
-	/**
-	 * find a folder in the cache which has not been fully scanned
-	 *
-	 * If multiply incomplete folders are in the cache, the one with the highest id will be returned,
-	 * use the one with the highest id gives the best result with the background scanner, since that is most
-	 * likely the folder where we stopped scanning previously
-	 *
-	 * @return string|bool the path of the folder or false when no folder matched
-	 */
-	public function getIncomplete() {
-		// not supported
-		return false;
-	}
+    /**
+     * find a folder in the cache which has not been fully scanned
+     *
+     * If multiply incomplete folders are in the cache, the one with the highest id will be returned,
+     * use the one with the highest id gives the best result with the background scanner, since that is most
+     * likely the folder where we stopped scanning previously
+     *
+     * @return string|bool the path of the folder or false when no folder matched
+     */
+    public function getIncomplete() {
+        // not supported
+        return false;
+    }
 
-	/**
-	 * get the path of a file on this storage by it's id
-	 *
-	 * @param int $id
-	 * @return string|null
-	 */
-	public function getPathById($id) {
-		$path = $this->getCache()->getPathById($id);
-		if ($path === null) {
-			return null;
-		}
+    /**
+     * get the path of a file on this storage by it's id
+     *
+     * @param int $id
+     * @return string|null
+     */
+    public function getPathById($id) {
+        $path = $this->getCache()->getPathById($id);
+        if ($path === null) {
+            return null;
+        }
 
-		return $this->getJailedPath($path);
-	}
+        return $this->getJailedPath($path);
+    }
 
-	/**
-	 * Move a file or folder in the cache
-	 *
-	 * Note that this should make sure the entries are removed from the source cache
-	 *
-	 * @param \OCP\Files\Cache\ICache $sourceCache
-	 * @param string $sourcePath
-	 * @param string $targetPath
-	 */
-	public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
-		if ($sourceCache === $this) {
-			return $this->move($sourcePath, $targetPath);
-		}
-		return $this->getCache()->moveFromCache($sourceCache, $sourcePath, $this->getSourcePath($targetPath));
-	}
+    /**
+     * Move a file or folder in the cache
+     *
+     * Note that this should make sure the entries are removed from the source cache
+     *
+     * @param \OCP\Files\Cache\ICache $sourceCache
+     * @param string $sourcePath
+     * @param string $targetPath
+     */
+    public function moveFromCache(\OCP\Files\Cache\ICache $sourceCache, $sourcePath, $targetPath) {
+        if ($sourceCache === $this) {
+            return $this->move($sourcePath, $targetPath);
+        }
+        return $this->getCache()->moveFromCache($sourceCache, $sourcePath, $this->getSourcePath($targetPath));
+    }
 
-	public function getQueryFilterForStorage(): ISearchOperator {
-		return new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND,
-			[
-				$this->getCache()->getQueryFilterForStorage(),
-				new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR,
-					[
-						new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
-						new SearchComparison(ISearchComparison::COMPARE_LIKE, 'path', $this->getGetUnjailedRoot() . '/%'),
-					],
-				)
-			]
-		);
-	}
+    public function getQueryFilterForStorage(): ISearchOperator {
+        return new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_AND,
+            [
+                $this->getCache()->getQueryFilterForStorage(),
+                new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR,
+                    [
+                        new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
+                        new SearchComparison(ISearchComparison::COMPARE_LIKE, 'path', $this->getGetUnjailedRoot() . '/%'),
+                    ],
+                )
+            ]
+        );
+    }
 
-	public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
-		$rawEntry = $this->getCache()->getCacheEntryFromSearchResult($rawEntry);
-		if ($rawEntry) {
-			$jailedPath = $this->getJailedPath($rawEntry->getPath());
-			if ($jailedPath !== null) {
-				return $this->formatCacheEntry(clone $rawEntry);
-			}
-		}
+    public function getCacheEntryFromSearchResult(ICacheEntry $rawEntry): ?ICacheEntry {
+        $rawEntry = $this->getCache()->getCacheEntryFromSearchResult($rawEntry);
+        if ($rawEntry) {
+            $jailedPath = $this->getJailedPath($rawEntry->getPath());
+            if ($jailedPath !== null) {
+                return $this->formatCacheEntry(clone $rawEntry);
+            }
+        }
 
-		return null;
-	}
+        return null;
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -79,7 +79,7 @@ 
 		if ($path === '') {
 			return $this->getRoot();
 		} else {
-			return $this->getRoot() . '/' . ltrim($path, '/');
+			return $this->getRoot().'/'.ltrim($path, '/');
 		}
 	}
 
@@ -98,7 +98,7 @@ 
 		$rootLength = strlen($root) + 1;
 		if ($path === $root) {
 			return '';
-		} elseif (substr($path, 0, $rootLength) === $root . '/') {
+		} elseif (substr($path, 0, $rootLength) === $root.'/') {
 			return substr($path, $rootLength);
 		} else {
 			return null;
@@ -312,7 +312,7 @@ 
 				new SearchBinaryOperator(ISearchBinaryOperator::OPERATOR_OR,
 					[
 						new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'path', $this->getGetUnjailedRoot()),
-						new SearchComparison(ISearchComparison::COMPARE_LIKE, 'path', $this->getGetUnjailedRoot() . '/%'),
+						new SearchComparison(ISearchComparison::COMPARE_LIKE, 'path', $this->getGetUnjailedRoot().'/%'),
 					],
 				)
 			]

lib/private/Files/Cache/CacheEntry.php

Indentation +74 added lines, -74 removed lines

@@ -28,104 +28,104 @@
  * meta data for a file or folder
  */
 class CacheEntry implements ICacheEntry {
-	/**
-	 * @var array
-	 */
-	private $data;
+    /**
+     * @var array
+     */
+    private $data;
 
-	public function __construct(array $data) {
-		$this->data = $data;
-	}
+    public function __construct(array $data) {
+        $this->data = $data;
+    }
 
-	public function offsetSet($offset, $value) {
-		$this->data[$offset] = $value;
-	}
+    public function offsetSet($offset, $value) {
+        $this->data[$offset] = $value;
+    }
 
-	public function offsetExists($offset) {
-		return isset($this->data[$offset]);
-	}
+    public function offsetExists($offset) {
+        return isset($this->data[$offset]);
+    }
 
-	public function offsetUnset($offset) {
-		unset($this->data[$offset]);
-	}
+    public function offsetUnset($offset) {
+        unset($this->data[$offset]);
+    }
 
-	public function offsetGet($offset) {
-		if (isset($this->data[$offset])) {
-			return $this->data[$offset];
-		} else {
-			return null;
-		}
-	}
+    public function offsetGet($offset) {
+        if (isset($this->data[$offset])) {
+            return $this->data[$offset];
+        } else {
+            return null;
+        }
+    }
 
-	public function getId() {
-		return (int)$this->data['fileid'];
-	}
+    public function getId() {
+        return (int)$this->data['fileid'];
+    }
 
-	public function getStorageId() {
-		return $this->data['storage'];
-	}
+    public function getStorageId() {
+        return $this->data['storage'];
+    }
 
 
-	public function getPath() {
-		return (string)$this->data['path'];
-	}
+    public function getPath() {
+        return (string)$this->data['path'];
+    }
 
 
-	public function getName() {
-		return $this->data['name'];
-	}
+    public function getName() {
+        return $this->data['name'];
+    }
 
 
-	public function getMimeType() {
-		return $this->data['mimetype'];
-	}
+    public function getMimeType() {
+        return $this->data['mimetype'];
+    }
 
 
-	public function getMimePart() {
-		return $this->data['mimepart'];
-	}
+    public function getMimePart() {
+        return $this->data['mimepart'];
+    }
 
-	public function getSize() {
-		return $this->data['size'];
-	}
+    public function getSize() {
+        return $this->data['size'];
+    }
 
-	public function getMTime() {
-		return $this->data['mtime'];
-	}
+    public function getMTime() {
+        return $this->data['mtime'];
+    }
 
-	public function getStorageMTime() {
-		return $this->data['storage_mtime'];
-	}
+    public function getStorageMTime() {
+        return $this->data['storage_mtime'];
+    }
 
-	public function getEtag() {
-		return $this->data['etag'];
-	}
+    public function getEtag() {
+        return $this->data['etag'];
+    }
 
-	public function getPermissions() {
-		return $this->data['permissions'];
-	}
+    public function getPermissions() {
+        return $this->data['permissions'];
+    }
 
-	public function isEncrypted() {
-		return isset($this->data['encrypted']) && $this->data['encrypted'];
-	}
+    public function isEncrypted() {
+        return isset($this->data['encrypted']) && $this->data['encrypted'];
+    }
 
-	public function getMetadataEtag(): ?string {
-		return $this->data['metadata_etag'];
-	}
+    public function getMetadataEtag(): ?string {
+        return $this->data['metadata_etag'];
+    }
 
-	public function getCreationTime(): ?int {
-		return $this->data['creation_time'];
-	}
+    public function getCreationTime(): ?int {
+        return $this->data['creation_time'];
+    }
 
-	public function getUploadTime(): ?int {
-		return $this->data['upload_time'];
-	}
+    public function getUploadTime(): ?int {
+        return $this->data['upload_time'];
+    }
 
-	public function getData() {
-		return $this->data;
-	}
+    public function getData() {
+        return $this->data;
+    }
 
-	public function __clone() {
-		$this->data = array_merge([], $this->data);
-	}
+    public function __clone() {
+        $this->data = array_merge([], $this->data);
+    }
 }

lib/private/Files/Node/Folder.php

Indentation +447 added lines, -447 removed lines

@@ -50,451 +50,451 @@
 use OCP\IUserManager;
 
 class Folder extends Node implements \OCP\Files\Folder {
-	/**
-	 * Creates a Folder that represents a non-existing path
-	 *
-	 * @param string $path path
-	 * @return string non-existing node class
-	 */
-	protected function createNonExistingNode($path) {
-		return new NonExistingFolder($this->root, $this->view, $path);
-	}
-
-	/**
-	 * @param string $path path relative to the folder
-	 * @return string
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function getFullPath($path) {
-		if (!$this->isValidPath($path)) {
-			throw new NotPermittedException('Invalid path');
-		}
-		return $this->path . $this->normalizePath($path);
-	}
-
-	/**
-	 * @param string $path
-	 * @return string|null
-	 */
-	public function getRelativePath($path) {
-		if ($this->path === '' or $this->path === '/') {
-			return $this->normalizePath($path);
-		}
-		if ($path === $this->path) {
-			return '/';
-		} elseif (strpos($path, $this->path . '/') !== 0) {
-			return null;
-		} else {
-			$path = substr($path, strlen($this->path));
-			return $this->normalizePath($path);
-		}
-	}
-
-	/**
-	 * check if a node is a (grand-)child of the folder
-	 *
-	 * @param \OC\Files\Node\Node $node
-	 * @return bool
-	 */
-	public function isSubNode($node) {
-		return strpos($node->getPath(), $this->path . '/') === 0;
-	}
-
-	/**
-	 * get the content of this directory
-	 *
-	 * @return Node[]
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function getDirectoryListing() {
-		$folderContent = $this->view->getDirectoryContent($this->path);
-
-		return array_map(function (FileInfo $info) {
-			if ($info->getMimetype() === 'httpd/unix-directory') {
-				return new Folder($this->root, $this->view, $info->getPath(), $info);
-			} else {
-				return new File($this->root, $this->view, $info->getPath(), $info);
-			}
-		}, $folderContent);
-	}
-
-	/**
-	 * @param string $path
-	 * @param FileInfo $info
-	 * @return File|Folder
-	 */
-	protected function createNode($path, FileInfo $info = null) {
-		if (is_null($info)) {
-			$isDir = $this->view->is_dir($path);
-		} else {
-			$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
-		}
-		if ($isDir) {
-			return new Folder($this->root, $this->view, $path, $info);
-		} else {
-			return new File($this->root, $this->view, $path, $info);
-		}
-	}
-
-	/**
-	 * Get the node at $path
-	 *
-	 * @param string $path
-	 * @return \OC\Files\Node\Node
-	 * @throws \OCP\Files\NotFoundException
-	 */
-	public function get($path) {
-		return $this->root->get($this->getFullPath($path));
-	}
-
-	/**
-	 * @param string $path
-	 * @return bool
-	 */
-	public function nodeExists($path) {
-		try {
-			$this->get($path);
-			return true;
-		} catch (NotFoundException $e) {
-			return false;
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @return \OC\Files\Node\Folder
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function newFolder($path) {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
-			$fullPath = $this->getFullPath($path);
-			$nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
-			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
-			if (!$this->view->mkdir($fullPath)) {
-				throw new NotPermittedException('Could not create folder');
-			}
-			$node = new Folder($this->root, $this->view, $fullPath);
-			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
-			return $node;
-		} else {
-			throw new NotPermittedException('No create permission for folder');
-		}
-	}
-
-	/**
-	 * @param string $path
-	 * @param string | resource | null $content
-	 * @return \OC\Files\Node\File
-	 * @throws \OCP\Files\NotPermittedException
-	 */
-	public function newFile($path, $content = null) {
-		if (empty($path)) {
-			throw new NotPermittedException('Could not create as provided path is empty');
-		}
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
-			$fullPath = $this->getFullPath($path);
-			$nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
-			$this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
-			if ($content !== null) {
-				$result = $this->view->file_put_contents($fullPath, $content);
-			} else {
-				$result = $this->view->touch($fullPath);
-			}
-			if ($result === false) {
-				throw new NotPermittedException('Could not create path');
-			}
-			$node = new File($this->root, $this->view, $fullPath);
-			$this->sendHooks(['postWrite', 'postCreate'], [$node]);
-			return $node;
-		}
-		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
-	 *
-	 * @param string|ISearchQuery $query
-	 * @return \OC\Files\Node\Node[]
-	 */
-	public function search($query) {
-		if (is_string($query)) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
-		}
-
-		// search is handled by a single query covering all caches that this folder contains
-		// this is done by collect
-
-		$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);
-
-		// collect all caches for this folder, indexed by their mountpoint relative to this folder
-		// and save the mount which is needed later to construct the FileInfo objects
-
-		if ($internalPath !== '') {
-			// a temporary CacheJail is used to handle filtering down the results to within this folder
-			$caches = ['' => new CacheJail($storage->getCache(''), $internalPath)];
-		} else {
-			$caches = ['' => $storage->getCache('')];
-		}
-		$mountByMountPoint = ['' => $mount];
-
-		if (!$limitToHome) {
-			$mounts = $this->root->getMountsIn($this->path);
-			foreach ($mounts as $mount) {
-				$storage = $mount->getStorage();
-				if ($storage) {
-					$relativeMountPoint = ltrim(substr($mount->getMountPoint(), $rootLength), '/');
-					$caches[$relativeMountPoint] = $storage->getCache('');
-					$mountByMountPoint[$relativeMountPoint] = $mount;
-				}
-			}
-		}
-
-		/** @var QuerySearchHelper $searchHelper */
-		$searchHelper = \OC::$server->get(QuerySearchHelper::class);
-		$resultsPerCache = $searchHelper->searchInCaches($query, $caches);
-
-		// loop trough all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
-		$files = array_merge(...array_map(function (array $results, $relativeMountPoint) use ($mountByMountPoint) {
-			$mount = $mountByMountPoint[$relativeMountPoint];
-			return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
-				return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
-			}, $results);
-		}, array_values($resultsPerCache), array_keys($resultsPerCache)));
-
-		// since results were returned per-cache, they are no longer fully sorted
-		$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;
-			});
-		}
-
-		return array_map(function (FileInfo $file) {
-			return $this->createNode($file->getPath(), $file);
-		}, $files);
-	}
-
-	private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
-		$cacheEntry['internalPath'] = $cacheEntry['path'];
-		$cacheEntry['path'] = $appendRoot . $cacheEntry->getPath();
-		return new \OC\Files\FileInfo($this->path . '/' . $cacheEntry['path'], $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
-	}
-
-	/**
-	 * search for files by mimetype
-	 *
-	 * @param string $mimetype
-	 * @return Node[]
-	 */
-	public function 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);
-	}
-
-	/**
-	 * search for files by tag
-	 *
-	 * @param string|int $tag name or tag id
-	 * @param string $userId owner of the tags
-	 * @return Node[]
-	 */
-	public function searchByTag($tag, $userId) {
-		$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'tagname', $tag), $userId);
-		return $this->search($query);
-	}
-
-	/**
-	 * @param int $id
-	 * @return \OC\Files\Node\Node[]
-	 */
-	public function getById($id) {
-		$mountCache = $this->root->getUserMountCache();
-		if (strpos($this->getPath(), '/', 1) > 0) {
-			[, $user] = explode('/', $this->getPath());
-		} else {
-			$user = null;
-		}
-		$mountsContainingFile = $mountCache->getMountsForFileId((int)$id, $user);
-		$mounts = $this->root->getMountsIn($this->path);
-		$mounts[] = $this->root->getMount($this->path);
-		/** @var IMountPoint[] $folderMounts */
-		$folderMounts = array_combine(array_map(function (IMountPoint $mountPoint) {
-			return $mountPoint->getMountPoint();
-		}, $mounts), $mounts);
-
-		/** @var ICachedMountInfo[] $mountsContainingFile */
-		$mountsContainingFile = array_values(array_filter($mountsContainingFile, function (ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
-			return isset($folderMounts[$cachedMountInfo->getMountPoint()]);
-		}));
-
-		if (count($mountsContainingFile) === 0) {
-			if ($user === $this->getAppDataDirectoryName()) {
-				return $this->getByIdInRootMount((int)$id);
-			}
-			return [];
-		}
-
-		$nodes = array_map(function (ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
-			$mount = $folderMounts[$cachedMountInfo->getMountPoint()];
-			$cacheEntry = $mount->getStorage()->getCache()->get((int)$id);
-			if (!$cacheEntry) {
-				return null;
-			}
-
-			// cache jails will hide the "true" internal path
-			$internalPath = ltrim($cachedMountInfo->getRootInternalPath() . '/' . $cacheEntry->getPath(), '/');
-			$pathRelativeToMount = substr($internalPath, strlen($cachedMountInfo->getRootInternalPath()));
-			$pathRelativeToMount = ltrim($pathRelativeToMount, '/');
-			$absolutePath = rtrim($cachedMountInfo->getMountPoint() . $pathRelativeToMount, '/');
-			return $this->root->createNode($absolutePath, new \OC\Files\FileInfo(
-				$absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
-				\OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
-			));
-		}, $mountsContainingFile);
-
-		$nodes = array_filter($nodes);
-
-		return array_filter($nodes, function (Node $node) {
-			return $this->getRelativePath($node->getPath());
-		});
-	}
-
-	protected function getAppDataDirectoryName(): string {
-		$instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
-		return 'appdata_' . $instanceId;
-	}
-
-	/**
-	 * In case the path we are currently in is inside the appdata_* folder,
-	 * the original getById method does not work, because it can only look inside
-	 * the user's mount points. But the user has no mount point for the root storage.
-	 *
-	 * So in that case we directly check the mount of the root if it contains
-	 * the id. If it does we check if the path is inside the path we are working
-	 * in.
-	 *
-	 * @param int $id
-	 * @return array
-	 */
-	protected function getByIdInRootMount(int $id): array {
-		$mount = $this->root->getMount('');
-		$cacheEntry = $mount->getStorage()->getCache($this->path)->get($id);
-		if (!$cacheEntry) {
-			return [];
-		}
-
-		$absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
-		$currentPath = rtrim($this->path, '/') . '/';
-
-		if (strpos($absolutePath, $currentPath) !== 0) {
-			return [];
-		}
-
-		return [$this->root->createNode(
-			$absolutePath, new \OC\Files\FileInfo(
-			$absolutePath,
-			$mount->getStorage(),
-			$cacheEntry->getPath(),
-			$cacheEntry,
-			$mount
-		))];
-	}
-
-	public function getFreeSpace() {
-		return $this->view->free_space($this->path);
-	}
-
-	public function delete() {
-		if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
-			$this->sendHooks(['preDelete']);
-			$fileInfo = $this->getFileInfo();
-			$this->view->rmdir($this->path);
-			$nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
-			$this->sendHooks(['postDelete'], [$nonExisting]);
-			$this->exists = false;
-		} else {
-			throw new NotPermittedException('No delete permission for path');
-		}
-	}
-
-	/**
-	 * Add a suffix to the name in case the file exists
-	 *
-	 * @param string $name
-	 * @return string
-	 * @throws NotPermittedException
-	 */
-	public function getNonExistingName($name) {
-		$uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
-		return trim($this->getRelativePath($uniqueName), '/');
-	}
-
-	/**
-	 * @param int $limit
-	 * @param int $offset
-	 * @return \OCP\Files\Node[]
-	 */
-	public function getRecent($limit, $offset = 0) {
-		$query = new SearchQuery(
-			new SearchBinaryOperator(
-				// filter out non empty folders
-				ISearchBinaryOperator::OPERATOR_OR,
-				[
-					new SearchBinaryOperator(
-						ISearchBinaryOperator::OPERATOR_NOT,
-						[
-							new SearchComparison(
-								ISearchComparison::COMPARE_EQUAL,
-								'mimetype',
-								FileInfo::MIMETYPE_FOLDER
-							),
-						]
-					),
-					new SearchComparison(
-						ISearchComparison::COMPARE_EQUAL,
-						'size',
-						0
-					),
-				]
-			),
-			$limit,
-			$offset,
-			[
-				new SearchOrder(
-					ISearchOrder::DIRECTION_DESCENDING,
-					'mtime'
-				),
-			]
-		);
-		return $this->search($query);
-	}
+    /**
+     * Creates a Folder that represents a non-existing path
+     *
+     * @param string $path path
+     * @return string non-existing node class
+     */
+    protected function createNonExistingNode($path) {
+        return new NonExistingFolder($this->root, $this->view, $path);
+    }
+
+    /**
+     * @param string $path path relative to the folder
+     * @return string
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function getFullPath($path) {
+        if (!$this->isValidPath($path)) {
+            throw new NotPermittedException('Invalid path');
+        }
+        return $this->path . $this->normalizePath($path);
+    }
+
+    /**
+     * @param string $path
+     * @return string|null
+     */
+    public function getRelativePath($path) {
+        if ($this->path === '' or $this->path === '/') {
+            return $this->normalizePath($path);
+        }
+        if ($path === $this->path) {
+            return '/';
+        } elseif (strpos($path, $this->path . '/') !== 0) {
+            return null;
+        } else {
+            $path = substr($path, strlen($this->path));
+            return $this->normalizePath($path);
+        }
+    }
+
+    /**
+     * check if a node is a (grand-)child of the folder
+     *
+     * @param \OC\Files\Node\Node $node
+     * @return bool
+     */
+    public function isSubNode($node) {
+        return strpos($node->getPath(), $this->path . '/') === 0;
+    }
+
+    /**
+     * get the content of this directory
+     *
+     * @return Node[]
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function getDirectoryListing() {
+        $folderContent = $this->view->getDirectoryContent($this->path);
+
+        return array_map(function (FileInfo $info) {
+            if ($info->getMimetype() === 'httpd/unix-directory') {
+                return new Folder($this->root, $this->view, $info->getPath(), $info);
+            } else {
+                return new File($this->root, $this->view, $info->getPath(), $info);
+            }
+        }, $folderContent);
+    }
+
+    /**
+     * @param string $path
+     * @param FileInfo $info
+     * @return File|Folder
+     */
+    protected function createNode($path, FileInfo $info = null) {
+        if (is_null($info)) {
+            $isDir = $this->view->is_dir($path);
+        } else {
+            $isDir = $info->getType() === FileInfo::TYPE_FOLDER;
+        }
+        if ($isDir) {
+            return new Folder($this->root, $this->view, $path, $info);
+        } else {
+            return new File($this->root, $this->view, $path, $info);
+        }
+    }
+
+    /**
+     * Get the node at $path
+     *
+     * @param string $path
+     * @return \OC\Files\Node\Node
+     * @throws \OCP\Files\NotFoundException
+     */
+    public function get($path) {
+        return $this->root->get($this->getFullPath($path));
+    }
+
+    /**
+     * @param string $path
+     * @return bool
+     */
+    public function nodeExists($path) {
+        try {
+            $this->get($path);
+            return true;
+        } catch (NotFoundException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * @param string $path
+     * @return \OC\Files\Node\Folder
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function newFolder($path) {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+            $fullPath = $this->getFullPath($path);
+            $nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
+            $this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
+            if (!$this->view->mkdir($fullPath)) {
+                throw new NotPermittedException('Could not create folder');
+            }
+            $node = new Folder($this->root, $this->view, $fullPath);
+            $this->sendHooks(['postWrite', 'postCreate'], [$node]);
+            return $node;
+        } else {
+            throw new NotPermittedException('No create permission for folder');
+        }
+    }
+
+    /**
+     * @param string $path
+     * @param string | resource | null $content
+     * @return \OC\Files\Node\File
+     * @throws \OCP\Files\NotPermittedException
+     */
+    public function newFile($path, $content = null) {
+        if (empty($path)) {
+            throw new NotPermittedException('Could not create as provided path is empty');
+        }
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
+            $fullPath = $this->getFullPath($path);
+            $nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
+            $this->sendHooks(['preWrite', 'preCreate'], [$nonExisting]);
+            if ($content !== null) {
+                $result = $this->view->file_put_contents($fullPath, $content);
+            } else {
+                $result = $this->view->touch($fullPath);
+            }
+            if ($result === false) {
+                throw new NotPermittedException('Could not create path');
+            }
+            $node = new File($this->root, $this->view, $fullPath);
+            $this->sendHooks(['postWrite', 'postCreate'], [$node]);
+            return $node;
+        }
+        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
+     *
+     * @param string|ISearchQuery $query
+     * @return \OC\Files\Node\Node[]
+     */
+    public function search($query) {
+        if (is_string($query)) {
+            $query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
+        }
+
+        // search is handled by a single query covering all caches that this folder contains
+        // this is done by collect
+
+        $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);
+
+        // collect all caches for this folder, indexed by their mountpoint relative to this folder
+        // and save the mount which is needed later to construct the FileInfo objects
+
+        if ($internalPath !== '') {
+            // a temporary CacheJail is used to handle filtering down the results to within this folder
+            $caches = ['' => new CacheJail($storage->getCache(''), $internalPath)];
+        } else {
+            $caches = ['' => $storage->getCache('')];
+        }
+        $mountByMountPoint = ['' => $mount];
+
+        if (!$limitToHome) {
+            $mounts = $this->root->getMountsIn($this->path);
+            foreach ($mounts as $mount) {
+                $storage = $mount->getStorage();
+                if ($storage) {
+                    $relativeMountPoint = ltrim(substr($mount->getMountPoint(), $rootLength), '/');
+                    $caches[$relativeMountPoint] = $storage->getCache('');
+                    $mountByMountPoint[$relativeMountPoint] = $mount;
+                }
+            }
+        }
+
+        /** @var QuerySearchHelper $searchHelper */
+        $searchHelper = \OC::$server->get(QuerySearchHelper::class);
+        $resultsPerCache = $searchHelper->searchInCaches($query, $caches);
+
+        // loop trough all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
+        $files = array_merge(...array_map(function (array $results, $relativeMountPoint) use ($mountByMountPoint) {
+            $mount = $mountByMountPoint[$relativeMountPoint];
+            return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
+                return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
+            }, $results);
+        }, array_values($resultsPerCache), array_keys($resultsPerCache)));
+
+        // since results were returned per-cache, they are no longer fully sorted
+        $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;
+            });
+        }
+
+        return array_map(function (FileInfo $file) {
+            return $this->createNode($file->getPath(), $file);
+        }, $files);
+    }
+
+    private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
+        $cacheEntry['internalPath'] = $cacheEntry['path'];
+        $cacheEntry['path'] = $appendRoot . $cacheEntry->getPath();
+        return new \OC\Files\FileInfo($this->path . '/' . $cacheEntry['path'], $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
+    }
+
+    /**
+     * search for files by mimetype
+     *
+     * @param string $mimetype
+     * @return Node[]
+     */
+    public function 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);
+    }
+
+    /**
+     * search for files by tag
+     *
+     * @param string|int $tag name or tag id
+     * @param string $userId owner of the tags
+     * @return Node[]
+     */
+    public function searchByTag($tag, $userId) {
+        $query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'tagname', $tag), $userId);
+        return $this->search($query);
+    }
+
+    /**
+     * @param int $id
+     * @return \OC\Files\Node\Node[]
+     */
+    public function getById($id) {
+        $mountCache = $this->root->getUserMountCache();
+        if (strpos($this->getPath(), '/', 1) > 0) {
+            [, $user] = explode('/', $this->getPath());
+        } else {
+            $user = null;
+        }
+        $mountsContainingFile = $mountCache->getMountsForFileId((int)$id, $user);
+        $mounts = $this->root->getMountsIn($this->path);
+        $mounts[] = $this->root->getMount($this->path);
+        /** @var IMountPoint[] $folderMounts */
+        $folderMounts = array_combine(array_map(function (IMountPoint $mountPoint) {
+            return $mountPoint->getMountPoint();
+        }, $mounts), $mounts);
+
+        /** @var ICachedMountInfo[] $mountsContainingFile */
+        $mountsContainingFile = array_values(array_filter($mountsContainingFile, function (ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
+            return isset($folderMounts[$cachedMountInfo->getMountPoint()]);
+        }));
+
+        if (count($mountsContainingFile) === 0) {
+            if ($user === $this->getAppDataDirectoryName()) {
+                return $this->getByIdInRootMount((int)$id);
+            }
+            return [];
+        }
+
+        $nodes = array_map(function (ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
+            $mount = $folderMounts[$cachedMountInfo->getMountPoint()];
+            $cacheEntry = $mount->getStorage()->getCache()->get((int)$id);
+            if (!$cacheEntry) {
+                return null;
+            }
+
+            // cache jails will hide the "true" internal path
+            $internalPath = ltrim($cachedMountInfo->getRootInternalPath() . '/' . $cacheEntry->getPath(), '/');
+            $pathRelativeToMount = substr($internalPath, strlen($cachedMountInfo->getRootInternalPath()));
+            $pathRelativeToMount = ltrim($pathRelativeToMount, '/');
+            $absolutePath = rtrim($cachedMountInfo->getMountPoint() . $pathRelativeToMount, '/');
+            return $this->root->createNode($absolutePath, new \OC\Files\FileInfo(
+                $absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
+                \OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
+            ));
+        }, $mountsContainingFile);
+
+        $nodes = array_filter($nodes);
+
+        return array_filter($nodes, function (Node $node) {
+            return $this->getRelativePath($node->getPath());
+        });
+    }
+
+    protected function getAppDataDirectoryName(): string {
+        $instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
+        return 'appdata_' . $instanceId;
+    }
+
+    /**
+     * In case the path we are currently in is inside the appdata_* folder,
+     * the original getById method does not work, because it can only look inside
+     * the user's mount points. But the user has no mount point for the root storage.
+     *
+     * So in that case we directly check the mount of the root if it contains
+     * the id. If it does we check if the path is inside the path we are working
+     * in.
+     *
+     * @param int $id
+     * @return array
+     */
+    protected function getByIdInRootMount(int $id): array {
+        $mount = $this->root->getMount('');
+        $cacheEntry = $mount->getStorage()->getCache($this->path)->get($id);
+        if (!$cacheEntry) {
+            return [];
+        }
+
+        $absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
+        $currentPath = rtrim($this->path, '/') . '/';
+
+        if (strpos($absolutePath, $currentPath) !== 0) {
+            return [];
+        }
+
+        return [$this->root->createNode(
+            $absolutePath, new \OC\Files\FileInfo(
+            $absolutePath,
+            $mount->getStorage(),
+            $cacheEntry->getPath(),
+            $cacheEntry,
+            $mount
+        ))];
+    }
+
+    public function getFreeSpace() {
+        return $this->view->free_space($this->path);
+    }
+
+    public function delete() {
+        if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
+            $this->sendHooks(['preDelete']);
+            $fileInfo = $this->getFileInfo();
+            $this->view->rmdir($this->path);
+            $nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
+            $this->sendHooks(['postDelete'], [$nonExisting]);
+            $this->exists = false;
+        } else {
+            throw new NotPermittedException('No delete permission for path');
+        }
+    }
+
+    /**
+     * Add a suffix to the name in case the file exists
+     *
+     * @param string $name
+     * @return string
+     * @throws NotPermittedException
+     */
+    public function getNonExistingName($name) {
+        $uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
+        return trim($this->getRelativePath($uniqueName), '/');
+    }
+
+    /**
+     * @param int $limit
+     * @param int $offset
+     * @return \OCP\Files\Node[]
+     */
+    public function getRecent($limit, $offset = 0) {
+        $query = new SearchQuery(
+            new SearchBinaryOperator(
+                // filter out non empty folders
+                ISearchBinaryOperator::OPERATOR_OR,
+                [
+                    new SearchBinaryOperator(
+                        ISearchBinaryOperator::OPERATOR_NOT,
+                        [
+                            new SearchComparison(
+                                ISearchComparison::COMPARE_EQUAL,
+                                'mimetype',
+                                FileInfo::MIMETYPE_FOLDER
+                            ),
+                        ]
+                    ),
+                    new SearchComparison(
+                        ISearchComparison::COMPARE_EQUAL,
+                        'size',
+                        0
+                    ),
+                ]
+            ),
+            $limit,
+            $offset,
+            [
+                new SearchOrder(
+                    ISearchOrder::DIRECTION_DESCENDING,
+                    'mtime'
+                ),
+            ]
+        );
+        return $this->search($query);
+    }
 }

Spacing +24 added lines, -24 removed lines

@@ -69,7 +69,7 @@ 
 		if (!$this->isValidPath($path)) {
 			throw new NotPermittedException('Invalid path');
 		}
-		return $this->path . $this->normalizePath($path);
+		return $this->path.$this->normalizePath($path);
 	}
 
 	/**
@@ -82,7 +82,7 @@ 
 		}
 		if ($path === $this->path) {
 			return '/';
-		} elseif (strpos($path, $this->path . '/') !== 0) {
+		} elseif (strpos($path, $this->path.'/') !== 0) {
 			return null;
 		} else {
 			$path = substr($path, strlen($this->path));
@@ -97,7 +97,7 @@ 
 	 * @return bool
 	 */
 	public function isSubNode($node) {
-		return strpos($node->getPath(), $this->path . '/') === 0;
+		return strpos($node->getPath(), $this->path.'/') === 0;
 	}
 
 	/**
@@ -109,7 +109,7 @@ 
 	public function getDirectoryListing() {
 		$folderContent = $this->view->getDirectoryContent($this->path);
 
-		return array_map(function (FileInfo $info) {
+		return array_map(function(FileInfo $info) {
 			if ($info->getMimetype() === 'httpd/unix-directory') {
 				return new Folder($this->root, $this->view, $info->getPath(), $info);
 			} else {
@@ -229,7 +229,7 @@ 
 	 */
 	public function search($query) {
 		if (is_string($query)) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%' . $query . '%'));
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'name', '%'.$query.'%'));
 		}
 
 		// search is handled by a single query covering all caches that this folder contains
@@ -273,9 +273,9 @@ 
 		$resultsPerCache = $searchHelper->searchInCaches($query, $caches);
 
 		// loop trough all results per-cache, constructing the FileInfo object from the CacheEntry and merge them all
-		$files = array_merge(...array_map(function (array $results, $relativeMountPoint) use ($mountByMountPoint) {
+		$files = array_merge(...array_map(function(array $results, $relativeMountPoint) use ($mountByMountPoint) {
 			$mount = $mountByMountPoint[$relativeMountPoint];
-			return array_map(function (ICacheEntry $result) use ($relativeMountPoint, $mount) {
+			return array_map(function(ICacheEntry $result) use ($relativeMountPoint, $mount) {
 				return $this->cacheEntryToFileInfo($mount, $relativeMountPoint, $result);
 			}, $results);
 		}, array_values($resultsPerCache), array_keys($resultsPerCache)));
@@ -283,7 +283,7 @@ 
 		// since results were returned per-cache, they are no longer fully sorted
 		$order = $query->getOrder();
 		if ($order) {
-			usort($files, function (FileInfo $a, FileInfo $b) use ($order) {
+			usort($files, function(FileInfo $a, FileInfo $b) use ($order) {
 				foreach ($order as $orderField) {
 					$cmp = $orderField->sortFileInfo($a, $b);
 					if ($cmp !== 0) {
@@ -294,15 +294,15 @@ 
 			});
 		}
 
-		return array_map(function (FileInfo $file) {
+		return array_map(function(FileInfo $file) {
 			return $this->createNode($file->getPath(), $file);
 		}, $files);
 	}
 
 	private function cacheEntryToFileInfo(IMountPoint $mount, string $appendRoot, ICacheEntry $cacheEntry): FileInfo {
 		$cacheEntry['internalPath'] = $cacheEntry['path'];
-		$cacheEntry['path'] = $appendRoot . $cacheEntry->getPath();
-		return new \OC\Files\FileInfo($this->path . '/' . $cacheEntry['path'], $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
+		$cacheEntry['path'] = $appendRoot.$cacheEntry->getPath();
+		return new \OC\Files\FileInfo($this->path.'/'.$cacheEntry['path'], $mount->getStorage(), $cacheEntry['internalPath'], $cacheEntry, $mount);
 	}
 
 	/**
@@ -313,7 +313,7 @@ 
 	 */
 	public function searchByMime($mimetype) {
 		if (strpos($mimetype, '/') === false) {
-			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype . '/%'));
+			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_LIKE, 'mimetype', $mimetype.'/%'));
 		} else {
 			$query = $this->queryFromOperator(new SearchComparison(ISearchComparison::COMPARE_EQUAL, 'mimetype', $mimetype));
 		}
@@ -343,38 +343,38 @@ 
 		} else {
 			$user = null;
 		}
-		$mountsContainingFile = $mountCache->getMountsForFileId((int)$id, $user);
+		$mountsContainingFile = $mountCache->getMountsForFileId((int) $id, $user);
 		$mounts = $this->root->getMountsIn($this->path);
 		$mounts[] = $this->root->getMount($this->path);
 		/** @var IMountPoint[] $folderMounts */
-		$folderMounts = array_combine(array_map(function (IMountPoint $mountPoint) {
+		$folderMounts = array_combine(array_map(function(IMountPoint $mountPoint) {
 			return $mountPoint->getMountPoint();
 		}, $mounts), $mounts);
 
 		/** @var ICachedMountInfo[] $mountsContainingFile */
-		$mountsContainingFile = array_values(array_filter($mountsContainingFile, function (ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
+		$mountsContainingFile = array_values(array_filter($mountsContainingFile, function(ICachedMountInfo $cachedMountInfo) use ($folderMounts) {
 			return isset($folderMounts[$cachedMountInfo->getMountPoint()]);
 		}));
 
 		if (count($mountsContainingFile) === 0) {
 			if ($user === $this->getAppDataDirectoryName()) {
-				return $this->getByIdInRootMount((int)$id);
+				return $this->getByIdInRootMount((int) $id);
 			}
 			return [];
 		}
 
-		$nodes = array_map(function (ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
+		$nodes = array_map(function(ICachedMountInfo $cachedMountInfo) use ($folderMounts, $id) {
 			$mount = $folderMounts[$cachedMountInfo->getMountPoint()];
-			$cacheEntry = $mount->getStorage()->getCache()->get((int)$id);
+			$cacheEntry = $mount->getStorage()->getCache()->get((int) $id);
 			if (!$cacheEntry) {
 				return null;
 			}
 
 			// cache jails will hide the "true" internal path
-			$internalPath = ltrim($cachedMountInfo->getRootInternalPath() . '/' . $cacheEntry->getPath(), '/');
+			$internalPath = ltrim($cachedMountInfo->getRootInternalPath().'/'.$cacheEntry->getPath(), '/');
 			$pathRelativeToMount = substr($internalPath, strlen($cachedMountInfo->getRootInternalPath()));
 			$pathRelativeToMount = ltrim($pathRelativeToMount, '/');
-			$absolutePath = rtrim($cachedMountInfo->getMountPoint() . $pathRelativeToMount, '/');
+			$absolutePath = rtrim($cachedMountInfo->getMountPoint().$pathRelativeToMount, '/');
 			return $this->root->createNode($absolutePath, new \OC\Files\FileInfo(
 				$absolutePath, $mount->getStorage(), $cacheEntry->getPath(), $cacheEntry, $mount,
 				\OC::$server->getUserManager()->get($mount->getStorage()->getOwner($pathRelativeToMount))
@@ -383,14 +383,14 @@ 
 
 		$nodes = array_filter($nodes);
 
-		return array_filter($nodes, function (Node $node) {
+		return array_filter($nodes, function(Node $node) {
 			return $this->getRelativePath($node->getPath());
 		});
 	}
 
 	protected function getAppDataDirectoryName(): string {
 		$instanceId = \OC::$server->getConfig()->getSystemValueString('instanceid');
-		return 'appdata_' . $instanceId;
+		return 'appdata_'.$instanceId;
 	}
 
 	/**
@@ -412,8 +412,8 @@ 
 			return [];
 		}
 
-		$absolutePath = '/' . ltrim($cacheEntry->getPath(), '/');
-		$currentPath = rtrim($this->path, '/') . '/';
+		$absolutePath = '/'.ltrim($cacheEntry->getPath(), '/');
+		$currentPath = rtrim($this->path, '/').'/';
 
 		if (strpos($absolutePath, $currentPath) !== 0) {
 			return [];