nextcloud / server

lib/public/DB/QueryBuilder/IQueryBuilder.php

Indentation +1068 added lines, -1068 removed lines

@@ -22,1072 +22,1072 @@
  * @psalm-taint-specialize
  */
 interface IQueryBuilder {
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_NULL = ParameterType::NULL;
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_BOOL = Types::BOOLEAN;
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_INT = ParameterType::INTEGER;
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_STR = ParameterType::STRING;
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_LOB = ParameterType::LARGE_OBJECT;
-
-	/**
-	 * @since 9.0.0
-	 * @deprecated 31.0.0 - use PARAM_DATETIME_MUTABLE instead
-	 */
-	public const PARAM_DATE = Types::DATETIME_MUTABLE;
-
-	/**
-	 * For passing a \DateTime instance when only interested in the time part (without timezone support)
-	 * @since 31.0.0
-	 */
-	public const PARAM_TIME_MUTABLE = Types::TIME_MUTABLE;
-
-	/**
-	 * For passing a \DateTime instance when only interested in the date part (without timezone support)
-	 * @since 31.0.0
-	 */
-	public const PARAM_DATE_MUTABLE = Types::DATE_MUTABLE;
-
-	/**
-	 * For passing a \DateTime instance (without timezone support)
-	 * @since 31.0.0
-	 */
-	public const PARAM_DATETIME_MUTABLE = Types::DATETIME_MUTABLE;
-
-	/**
-	 * For passing a \DateTime instance with timezone support
-	 * @since 31.0.0
-	 */
-	public const PARAM_DATETIME_TZ_MUTABLE = Types::DATETIMETZ_MUTABLE;
-
-	/**
-	 * For passing a \DateTimeImmutable instance when only interested in the time part (without timezone support)
-	 * @since 31.0.0
-	 */
-	public const PARAM_TIME_IMMUTABLE = Types::TIME_MUTABLE;
-
-	/**
-	 * For passing a \DateTime instance when only interested in the date part (without timezone support)
-	 * @since 9.0.0
-	 */
-	public const PARAM_DATE_IMMUTABLE = Types::DATE_IMMUTABLE;
-
-	/**
-	 * For passing a \DateTime instance (without timezone support)
-	 * @since 31.0.0
-	 */
-	public const PARAM_DATETIME_IMMUTABLE = Types::DATETIME_IMMUTABLE;
-
-	/**
-	 * For passing a \DateTime instance with timezone support
-	 * @since 31.0.0
-	 */
-	public const PARAM_DATETIME_TZ_IMMUTABLE = Types::DATETIMETZ_IMMUTABLE;
-
-	/**
-	 * @since 24.0.0
-	 */
-	public const PARAM_JSON = 'json';
-
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_INT_ARRAY = ArrayParameterType::INTEGER;
-	/**
-	 * @since 9.0.0
-	 */
-	public const PARAM_STR_ARRAY = ArrayParameterType::STRING;
-
-	/**
-	 * @since 24.0.0 Indicates how many rows can be deleted at once with MySQL
-	 * database server.
-	 */
-	public const MAX_ROW_DELETION = 100000;
-
-	/**
-	 * Enable/disable automatic prefixing of table names with the oc_ prefix
-	 *
-	 * @param bool $enabled If set to true table names will be prefixed with the
-	 *                      owncloud database prefix automatically.
-	 * @since 8.2.0
-	 */
-	public function automaticTablePrefix($enabled);
-
-	/**
-	 * Gets an ExpressionBuilder used for object-oriented construction of query expressions.
-	 * This producer method is intended for convenient inline usage. Example:
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u')
-	 *         ->from('users', 'u')
-	 *         ->where($qb->expr()->eq('u.id', 1));
-	 * </code>
-	 *
-	 * For more complex expression construction, consider storing the expression
-	 * builder object in a local variable.
-	 *
-	 * @return \OCP\DB\QueryBuilder\IExpressionBuilder
-	 * @since 8.2.0
-	 */
-	public function expr();
-
-	/**
-	 * Gets an FunctionBuilder used for object-oriented construction of query functions.
-	 * This producer method is intended for convenient inline usage. Example:
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u')
-	 *         ->from('users', 'u')
-	 *         ->where($qb->fun()->md5('u.id'));
-	 * </code>
-	 *
-	 * For more complex function construction, consider storing the function
-	 * builder object in a local variable.
-	 *
-	 * @return \OCP\DB\QueryBuilder\IFunctionBuilder
-	 * @since 12.0.0
-	 */
-	public function func();
-
-	/**
-	 * Gets the type of the currently built query.
-	 *
-	 * @return integer
-	 * @since 8.2.0
-	 */
-	public function getType();
-
-	/**
-	 * Gets the associated DBAL Connection for this query builder.
-	 *
-	 * @return \OCP\IDBConnection
-	 * @since 8.2.0
-	 */
-	public function getConnection();
-
-	/**
-	 * Gets the state of this query builder instance.
-	 *
-	 * @return integer Either QueryBuilder::STATE_DIRTY or QueryBuilder::STATE_CLEAN.
-	 * @since 8.2.0
-	 * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
-	 *    and we can not fix this in our wrapper.
-	 */
-	public function getState();
-
-	/**
-	 * Execute for select statements
-	 *
-	 * @param ?IDBConnection $connection (optional) the connection to run the query against. since 30.0
-	 * @return IResult
-	 * @since 22.0.0
-	 *
-	 * @throws Exception
-	 * @throws \RuntimeException in case of usage with non select query
-	 */
-	public function executeQuery(?IDBConnection $connection = null): IResult;
-
-	/**
-	 * Execute insert, update and delete statements
-	 *
-	 * @param ?IDBConnection $connection (optional) the connection to run the query against. since 30.0
-	 * @return int the number of affected rows
-	 * @since 22.0.0
-	 *
-	 * @throws Exception
-	 * @throws \RuntimeException in case of usage with select query
-	 */
-	public function executeStatement(?IDBConnection $connection = null): int;
-
-	/**
-	 * Gets the complete SQL string formed by the current specifications of this QueryBuilder.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u')
-	 *         ->from('User', 'u')
-	 *     echo $qb->getSQL(); // SELECT u FROM User u
-	 * </code>
-	 *
-	 * @return string The SQL query string.
-	 * @since 8.2.0
-	 */
-	public function getSQL();
-
-	/**
-	 * Sets a query parameter for the query being constructed.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u')
-	 *         ->from('users', 'u')
-	 *         ->where('u.id = :user_id')
-	 *         ->setParameter(':user_id', 1);
-	 * </code>
-	 *
-	 * @param string|integer $key The parameter position or name.
-	 * @param mixed $value The parameter value.
-	 * @param string|null|int $type One of the IQueryBuilder::PARAM_* constants.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 */
-	public function setParameter($key, $value, $type = null);
-
-	/**
-	 * Sets a collection of query parameters for the query being constructed.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u')
-	 *         ->from('users', 'u')
-	 *         ->where('u.id = :user_id1 OR u.id = :user_id2')
-	 *         ->setParameters(array(
-	 *             ':user_id1' => 1,
-	 *             ':user_id2' => 2
-	 *         ));
-	 * </code>
-	 *
-	 * @param array $params The query parameters to set.
-	 * @param array $types The query parameters types to set.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 */
-	public function setParameters(array $params, array $types = []);
-
-	/**
-	 * Gets all defined query parameters for the query being constructed indexed by parameter index or name.
-	 *
-	 * @return array The currently defined query parameters indexed by parameter index or name.
-	 * @since 8.2.0
-	 */
-	public function getParameters();
-
-	/**
-	 * Gets a (previously set) query parameter of the query being constructed.
-	 *
-	 * @param mixed $key The key (index or name) of the bound parameter.
-	 *
-	 * @return mixed The value of the bound parameter.
-	 * @since 8.2.0
-	 */
-	public function getParameter($key);
-
-	/**
-	 * Gets all defined query parameter types for the query being constructed indexed by parameter index or name.
-	 *
-	 * @return array The currently defined query parameter types indexed by parameter index or name.
-	 * @since 8.2.0
-	 */
-	public function getParameterTypes();
-
-	/**
-	 * Gets a (previously set) query parameter type of the query being constructed.
-	 *
-	 * @param mixed $key The key (index or name) of the bound parameter type.
-	 *
-	 * @return mixed The value of the bound parameter type.
-	 * @since 8.2.0
-	 */
-	public function getParameterType($key);
-
-	/**
-	 * Sets the position of the first result to retrieve (the "offset").
-	 *
-	 * @param int $firstResult The first result to return.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 */
-	public function setFirstResult($firstResult);
-
-	/**
-	 * Gets the position of the first result the query object was set to retrieve (the "offset").
-	 * Returns 0 if {@link setFirstResult} was not applied to this QueryBuilder.
-	 *
-	 * @return int The position of the first result.
-	 * @since 8.2.0
-	 */
-	public function getFirstResult();
-
-	/**
-	 * Sets the maximum number of results to retrieve (the "limit").
-	 *
-	 * @param int|null $maxResults The maximum number of results to retrieve.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 */
-	public function setMaxResults($maxResults);
-
-	/**
-	 * Gets the maximum number of results the query object was set to retrieve (the "limit").
-	 * Returns NULL if {@link setMaxResults} was not applied to this query builder.
-	 *
-	 * @return int|null The maximum number of results.
-	 * @since 8.2.0
-	 */
-	public function getMaxResults();
-
-	/**
-	 * Specifies an item that is to be returned in the query result.
-	 * Replaces any previously specified selections, if any.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.id', 'p.id')
-	 *         ->from('users', 'u')
-	 *         ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
-	 * </code>
-	 *
-	 * @param mixed ...$selects The selection expressions.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $selects
-	 */
-	public function select(...$selects);
-
-	/**
-	 * Specifies an item that is to be returned with a different name in the query result.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->selectAlias('u.id', 'user_id')
-	 *         ->from('users', 'u')
-	 *         ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
-	 * </code>
-	 *
-	 * @param mixed $select The selection expressions.
-	 * @param string $alias The column alias used in the constructed query.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.1
-	 *
-	 * @psalm-taint-sink sql $select
-	 * @psalm-taint-sink sql $alias
-	 */
-	public function selectAlias($select, $alias);
-
-	/**
-	 * Specifies an item that is to be returned uniquely in the query result.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->selectDistinct('type')
-	 *         ->from('users');
-	 * </code>
-	 *
-	 * @param mixed $select The selection expressions.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 9.0.0
-	 *
-	 * @psalm-taint-sink sql $select
-	 */
-	public function selectDistinct($select);
-
-	/**
-	 * Adds an item that is to be returned in the query result.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.id')
-	 *         ->addSelect('p.id')
-	 *         ->from('users', 'u')
-	 *         ->leftJoin('u', 'phonenumbers', 'u.id = p.user_id');
-	 * </code>
-	 *
-	 * @param mixed ...$select The selection expression.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $select
-	 */
-	public function addSelect(...$select);
-
-	/**
-	 * Turns the query being built into a bulk delete query that ranges over
-	 * a certain table.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->delete('users')
-	 *         ->where('id = :user_id');
-	 *         ->setParameter(':user_id', 1);
-	 * </code>
-	 *
-	 * @param string $delete The table whose rows are subject to the deletion.
-	 * @param string $alias The table alias used in the constructed query.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 * @since 30.0.0 Alias is deprecated and will no longer be used with the next Doctrine/DBAL update
-	 *
-	 * @psalm-taint-sink sql $delete
-	 */
-	public function delete($delete = null, $alias = null);
-
-	/**
-	 * Turns the query being built into a bulk update query that ranges over
-	 * a certain table
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->update('users')
-	 *         ->set('email', ':email')
-	 *         ->where('id = :user_id');
-	 *         ->setParameter(':user_id', 1);
-	 * </code>
-	 *
-	 * @param string $update The table whose rows are subject to the update.
-	 * @param string $alias The table alias used in the constructed query.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 * @since 30.0.0 Alias is deprecated and will no longer be used with the next Doctrine/DBAL update
-	 *
-	 * @psalm-taint-sink sql $update
-	 */
-	public function update($update = null, $alias = null);
-
-	/**
-	 * Turns the query being built into an insert query that inserts into
-	 * a certain table
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->insert('users')
-	 *         ->values(
-	 *             array(
-	 *                 'name' => '?',
-	 *                 'password' => '?'
-	 *             )
-	 *         );
-	 * </code>
-	 *
-	 * @param string $insert The table into which the rows should be inserted.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $insert
-	 */
-	public function insert($insert = null);
-
-	/**
-	 * Creates and adds a query root corresponding to the table identified by the
-	 * given alias, forming a cartesian product with any existing query roots.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.id')
-	 *         ->from('users', 'u')
-	 * </code>
-	 *
-	 * @param string|IQueryFunction $from The table.
-	 * @param string|null $alias The alias of the table.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $from
-	 */
-	public function from($from, $alias = null);
-
-	/**
-	 * Creates and adds a join to the query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->join('u', 'phonenumbers', 'p', 'p.is_primary = 1');
-	 * </code>
-	 *
-	 * @param string $fromAlias The alias that points to a from clause.
-	 * @param string|IQueryFunction $join The table name to join.
-	 * @param string $alias The alias of the join table.
-	 * @param string|ICompositeExpression|null $condition The condition for the join.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $fromAlias
-	 * @psalm-taint-sink sql $join
-	 * @psalm-taint-sink sql $alias
-	 * @psalm-taint-sink sql $condition
-	 */
-	public function join($fromAlias, $join, $alias, $condition = null);
-
-	/**
-	 * Creates and adds a join to the query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->innerJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
-	 * </code>
-	 *
-	 * @param string $fromAlias The alias that points to a from clause.
-	 * @param string|IQueryFunction $join The table name to join.
-	 * @param string $alias The alias of the join table.
-	 * @param string|ICompositeExpression|null $condition The condition for the join.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $fromAlias
-	 * @psalm-taint-sink sql $join
-	 * @psalm-taint-sink sql $alias
-	 * @psalm-taint-sink sql $condition
-	 */
-	public function innerJoin($fromAlias, $join, $alias, $condition = null);
-
-	/**
-	 * Creates and adds a left join to the query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->leftJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
-	 * </code>
-	 *
-	 * @param string $fromAlias The alias that points to a from clause.
-	 * @param string|IQueryFunction $join The table name to join.
-	 * @param string $alias The alias of the join table.
-	 * @param string|ICompositeExpression|null $condition The condition for the join.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 * @since 30.0.0 Allow passing IQueryFunction as parameter for `$join` to allow join with a sub-query.
-	 *
-	 * @psalm-taint-sink sql $fromAlias
-	 * @psalm-taint-sink sql $join
-	 * @psalm-taint-sink sql $alias
-	 * @psalm-taint-sink sql $condition
-	 */
-	public function leftJoin($fromAlias, $join, $alias, $condition = null);
-
-	/**
-	 * Creates and adds a right join to the query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->rightJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
-	 * </code>
-	 *
-	 * @param string $fromAlias The alias that points to a from clause.
-	 * @param string|IQueryFunction $join The table name to join.
-	 * @param string $alias The alias of the join table.
-	 * @param string|ICompositeExpression|null $condition The condition for the join.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $fromAlias
-	 * @psalm-taint-sink sql $join
-	 * @psalm-taint-sink sql $alias
-	 * @psalm-taint-sink sql $condition
-	 */
-	public function rightJoin($fromAlias, $join, $alias, $condition = null);
-
-	/**
-	 * Sets a new value for a column in a bulk update query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->update('users', 'u')
-	 *         ->set('u.password', md5('password'))
-	 *         ->where('u.id = ?');
-	 * </code>
-	 *
-	 * @param string $key The column to set.
-	 * @param ILiteral|IParameter|IQueryFunction|string $value The value, expression, placeholder, etc.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $key
-	 * @psalm-taint-sink sql $value
-	 */
-	public function set($key, $value);
-
-	/**
-	 * Specifies one or more restrictions to the query result.
-	 * Replaces any previously specified restrictions, if any.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->where('u.id = ?');
-	 *
-	 *     // You can optionally programmatically build and/or expressions
-	 *     $qb = $conn->getQueryBuilder();
-	 *
-	 *     $or = $qb->expr()->orx(
-	 *         $qb->expr()->eq('u.id', 1),
-	 *         $qb->expr()->eq('u.id', 2),
-	 *     );
-	 *
-	 *     $qb->update('users', 'u')
-	 *         ->set('u.password', md5('password'))
-	 *         ->where($or);
-	 * </code>
-	 *
-	 * @param mixed $predicates The restriction predicates.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $predicates
-	 */
-	public function where(...$predicates);
-
-	/**
-	 * Adds one or more restrictions to the query results, forming a logical
-	 * conjunction with any previously specified restrictions.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u')
-	 *         ->from('users', 'u')
-	 *         ->where('u.username LIKE ?')
-	 *         ->andWhere('u.is_active = 1');
-	 * </code>
-	 *
-	 * @param mixed ...$where The query restrictions.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 *
-	 * @see where()
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $where
-	 */
-	public function andWhere(...$where);
-
-	/**
-	 * Adds one or more restrictions to the query results, forming a logical
-	 * disjunction with any previously specified restrictions.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->where('u.id = 1')
-	 *         ->orWhere('u.id = 2');
-	 * </code>
-	 *
-	 * @param mixed ...$where The WHERE statement.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 *
-	 * @see where()
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $where
-	 */
-	public function orWhere(...$where);
-
-	/**
-	 * Specifies a grouping over the results of the query.
-	 * Replaces any previously specified groupings, if any.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->groupBy('u.id');
-	 * </code>
-	 *
-	 * @param mixed ...$groupBys The grouping expression.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $groupBys
-	 */
-	public function groupBy(...$groupBys);
-
-	/**
-	 * Adds a grouping expression to the query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->select('u.name')
-	 *         ->from('users', 'u')
-	 *         ->groupBy('u.lastLogin');
-	 *         ->addGroupBy('u.createdAt')
-	 * </code>
-	 *
-	 * @param mixed ...$groupBy The grouping expression.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $groupby
-	 */
-	public function addGroupBy(...$groupBy);
-
-	/**
-	 * Sets a value for a column in an insert query.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->insert('users')
-	 *         ->values(
-	 *             array(
-	 *                 'name' => '?'
-	 *             )
-	 *         )
-	 *         ->setValue('password', '?');
-	 * </code>
-	 *
-	 * @param string $column The column into which the value should be inserted.
-	 * @param IParameter|string $value The value that should be inserted into the column.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $column
-	 * @psalm-taint-sink sql $value
-	 */
-	public function setValue($column, $value);
-
-	/**
-	 * Specifies values for an insert query indexed by column names.
-	 * Replaces any previous values, if any.
-	 *
-	 * <code>
-	 *     $qb = $conn->getQueryBuilder()
-	 *         ->insert('users')
-	 *         ->values(
-	 *             array(
-	 *                 'name' => '?',
-	 *                 'password' => '?'
-	 *             )
-	 *         );
-	 * </code>
-	 *
-	 * @param array $values The values to specify for the insert query indexed by column names.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $values
-	 */
-	public function values(array $values);
-
-	/**
-	 * Specifies a restriction over the groups of the query.
-	 * Replaces any previous having restrictions, if any.
-	 *
-	 * @param mixed ...$having The restriction over the groups.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $having
-	 */
-	public function having(...$having);
-
-	/**
-	 * Adds a restriction over the groups of the query, forming a logical
-	 * conjunction with any existing having restrictions.
-	 *
-	 * @param mixed ...$having The restriction to append.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $andHaving
-	 */
-	public function andHaving(...$having);
-
-	/**
-	 * Adds a restriction over the groups of the query, forming a logical
-	 * disjunction with any existing having restrictions.
-	 *
-	 * @param mixed ...$having The restriction to add.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $having
-	 */
-	public function orHaving(...$having);
-
-	/**
-	 * Specifies an ordering for the query results.
-	 * Replaces any previously specified orderings, if any.
-	 *
-	 * @param string|IQueryFunction|ILiteral|IParameter $sort The ordering expression.
-	 * @param string $order The ordering direction.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $sort
-	 * @psalm-taint-sink sql $order
-	 */
-	public function orderBy($sort, $order = null);
-
-	/**
-	 * Adds an ordering to the query results.
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $sort The ordering expression.
-	 * @param string $order The ordering direction.
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $sort
-	 * @psalm-taint-sink sql $order
-	 */
-	public function addOrderBy($sort, $order = null);
-
-	/**
-	 * Gets a query part by its name.
-	 *
-	 * @param string $queryPartName
-	 *
-	 * @return mixed
-	 * @since 8.2.0
-	 * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
-	 *  and we can not fix this in our wrapper. Please track the details you need, outside the object.
-	 */
-	public function getQueryPart($queryPartName);
-
-	/**
-	 * Gets all query parts.
-	 *
-	 * @return array
-	 * @since 8.2.0
-	 * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
-	 *  and we can not fix this in our wrapper. Please track the details you need, outside the object.
-	 */
-	public function getQueryParts();
-
-	/**
-	 * Resets SQL parts.
-	 *
-	 * @param array|null $queryPartNames
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
-	 * and we can not fix this in our wrapper. Please create a new IQueryBuilder instead.
-	 */
-	public function resetQueryParts($queryPartNames = null);
-
-	/**
-	 * Resets a single SQL part.
-	 *
-	 * @param string $queryPartName
-	 *
-	 * @return $this This QueryBuilder instance.
-	 * @since 8.2.0
-	 * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
-	 *  and we can not fix this in our wrapper. Please create a new IQueryBuilder instead.
-	 */
-	public function resetQueryPart($queryPartName);
-
-	/**
-	 * Creates a new named parameter and bind the value $value to it.
-	 *
-	 * This method provides a shortcut for PDOStatement::bindValue
-	 * when using prepared statements.
-	 *
-	 * The parameter $value specifies the value that you want to bind. If
-	 * $placeholder is not provided bindValue() will automatically create a
-	 * placeholder for you. An automatic placeholder will be of the name
-	 * ':dcValue1', ':dcValue2' etc.
-	 *
-	 * For more information see {@link https://www.php.net/pdostatement-bindparam}
-	 *
-	 * Example:
-	 * <code>
-	 * $value = 2;
-	 * $q->eq( 'id', $q->bindValue( $value ) );
-	 * $stmt = $q->executeQuery(); // executed with 'id = 2'
-	 * </code>
-	 *
-	 * @license New BSD License
-	 * @link http://www.zetacomponents.org
-	 *
-	 * @param mixed $value
-	 * @param self::PARAM_* $type
-	 * @param string $placeHolder The name to bind with. The string must start with a colon ':'.
-	 *
-	 * @return IParameter
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-escape sql
-	 */
-	public function createNamedParameter($value, $type = self::PARAM_STR, $placeHolder = null);
-
-	/**
-	 * Creates a new positional parameter and bind the given value to it.
-	 *
-	 * Attention: If you are using positional parameters with the query builder you have
-	 * to be very careful to bind all parameters in the order they appear in the SQL
-	 * statement , otherwise they get bound in the wrong order which can lead to serious
-	 * bugs in your code.
-	 *
-	 * Example:
-	 * <code>
-	 *  $qb = $conn->getQueryBuilder();
-	 *  $qb->select('u.*')
-	 *     ->from('users', 'u')
-	 *     ->where('u.username = ' . $qb->createPositionalParameter('Foo', IQueryBuilder::PARAM_STR))
-	 *     ->orWhere('u.username = ' . $qb->createPositionalParameter('Bar', IQueryBuilder::PARAM_STR))
-	 * </code>
-	 *
-	 * @param mixed $value
-	 * @param self::PARAM_* $type
-	 *
-	 * @return IParameter
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-escape sql
-	 */
-	public function createPositionalParameter($value, $type = self::PARAM_STR);
-
-	/**
-	 * Creates a new parameter
-	 *
-	 * Example:
-	 * <code>
-	 *  $qb = $conn->getQueryBuilder();
-	 *  $qb->select('u.*')
-	 *     ->from('users', 'u')
-	 *     ->where('u.username = ' . $qb->createParameter('name'))
-	 *     ->setParameter('name', 'Bar', IQueryBuilder::PARAM_STR))
-	 * </code>
-	 *
-	 * @param string $name
-	 *
-	 * @return IParameter
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-escape sql
-	 */
-	public function createParameter($name);
-
-	/**
-	 * Creates a new function
-	 *
-	 * Attention: Column names inside the call have to be quoted before hand
-	 *
-	 * Example:
-	 * <code>
-	 *  $qb = $conn->getQueryBuilder();
-	 *  $qb->select($qb->createFunction('COUNT(*)'))
-	 *     ->from('users', 'u')
-	 *  echo $qb->getSQL(); // SELECT COUNT(*) FROM `users` u
-	 * </code>
-	 * <code>
-	 *  $qb = $conn->getQueryBuilder();
-	 *  $qb->select($qb->createFunction('COUNT(`column`)'))
-	 *     ->from('users', 'u')
-	 *  echo $qb->getSQL(); // SELECT COUNT(`column`) FROM `users` u
-	 * </code>
-	 *
-	 * @param string $call
-	 *
-	 * @return IQueryFunction
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $call
-	 */
-	public function createFunction($call);
-
-	/**
-	 * Used to get the id of the last inserted element
-	 * @return int
-	 * @throws \BadMethodCallException When being called before an insert query has been run.
-	 * @since 9.0.0
-	 */
-	public function getLastInsertId(): int;
-
-	/**
-	 * Returns the table name quoted and with database prefix as needed by the implementation.
-	 * If a query function is passed the function is casted to string,
-	 * this allows passing functions as sub-queries for join expression.
-	 *
-	 * @param string|IQueryFunction $table
-	 * @return string
-	 * @since 9.0.0
-	 * @since 24.0.0 accepts IQueryFunction as parameter
-	 */
-	public function getTableName($table);
-
-	/**
-	 * Returns the table name with database prefix as needed by the implementation
-	 *
-	 * @param string $table
-	 * @return string
-	 * @since 30.0.0
-	 */
-	public function prefixTableName(string $table): string;
-
-	/**
-	 * Returns the column name quoted and with table alias prefix as needed by the implementation
-	 *
-	 * @param string $column
-	 * @param string $tableAlias
-	 * @return string
-	 * @since 9.0.0
-	 */
-	public function getColumnName($column, $tableAlias = '');
-
-	/**
-	 * Provide a hint for the shard key for queries where this can't be detected otherwise
-	 *
-	 * @param string $column
-	 * @param mixed $value
-	 * @return $this
-	 * @since 30.0.0
-	 */
-	public function hintShardKey(string $column, mixed $value, bool $overwrite = false): self;
-
-	/**
-	 * Set the query to run across all shards if sharding is enabled.
-	 *
-	 * @return $this
-	 * @since 30.0.0
-	 */
-	public function runAcrossAllShards(): self;
-
-	/**
-	 * Get a list of column names that are expected in the query output
-	 *
-	 * @return array
-	 * @since 30.0.0
-	 */
-	public function getOutputColumns(): array;
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_NULL = ParameterType::NULL;
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_BOOL = Types::BOOLEAN;
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_INT = ParameterType::INTEGER;
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_STR = ParameterType::STRING;
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_LOB = ParameterType::LARGE_OBJECT;
+
+    /**
+     * @since 9.0.0
+     * @deprecated 31.0.0 - use PARAM_DATETIME_MUTABLE instead
+     */
+    public const PARAM_DATE = Types::DATETIME_MUTABLE;
+
+    /**
+     * For passing a \DateTime instance when only interested in the time part (without timezone support)
+     * @since 31.0.0
+     */
+    public const PARAM_TIME_MUTABLE = Types::TIME_MUTABLE;
+
+    /**
+     * For passing a \DateTime instance when only interested in the date part (without timezone support)
+     * @since 31.0.0
+     */
+    public const PARAM_DATE_MUTABLE = Types::DATE_MUTABLE;
+
+    /**
+     * For passing a \DateTime instance (without timezone support)
+     * @since 31.0.0
+     */
+    public const PARAM_DATETIME_MUTABLE = Types::DATETIME_MUTABLE;
+
+    /**
+     * For passing a \DateTime instance with timezone support
+     * @since 31.0.0
+     */
+    public const PARAM_DATETIME_TZ_MUTABLE = Types::DATETIMETZ_MUTABLE;
+
+    /**
+     * For passing a \DateTimeImmutable instance when only interested in the time part (without timezone support)
+     * @since 31.0.0
+     */
+    public const PARAM_TIME_IMMUTABLE = Types::TIME_MUTABLE;
+
+    /**
+     * For passing a \DateTime instance when only interested in the date part (without timezone support)
+     * @since 9.0.0
+     */
+    public const PARAM_DATE_IMMUTABLE = Types::DATE_IMMUTABLE;
+
+    /**
+     * For passing a \DateTime instance (without timezone support)
+     * @since 31.0.0
+     */
+    public const PARAM_DATETIME_IMMUTABLE = Types::DATETIME_IMMUTABLE;
+
+    /**
+     * For passing a \DateTime instance with timezone support
+     * @since 31.0.0
+     */
+    public const PARAM_DATETIME_TZ_IMMUTABLE = Types::DATETIMETZ_IMMUTABLE;
+
+    /**
+     * @since 24.0.0
+     */
+    public const PARAM_JSON = 'json';
+
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_INT_ARRAY = ArrayParameterType::INTEGER;
+    /**
+     * @since 9.0.0
+     */
+    public const PARAM_STR_ARRAY = ArrayParameterType::STRING;
+
+    /**
+     * @since 24.0.0 Indicates how many rows can be deleted at once with MySQL
+     * database server.
+     */
+    public const MAX_ROW_DELETION = 100000;
+
+    /**
+     * Enable/disable automatic prefixing of table names with the oc_ prefix
+     *
+     * @param bool $enabled If set to true table names will be prefixed with the
+     *                      owncloud database prefix automatically.
+     * @since 8.2.0
+     */
+    public function automaticTablePrefix($enabled);
+
+    /**
+     * Gets an ExpressionBuilder used for object-oriented construction of query expressions.
+     * This producer method is intended for convenient inline usage. Example:
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u')
+     *         ->from('users', 'u')
+     *         ->where($qb->expr()->eq('u.id', 1));
+     * </code>
+     *
+     * For more complex expression construction, consider storing the expression
+     * builder object in a local variable.
+     *
+     * @return \OCP\DB\QueryBuilder\IExpressionBuilder
+     * @since 8.2.0
+     */
+    public function expr();
+
+    /**
+     * Gets an FunctionBuilder used for object-oriented construction of query functions.
+     * This producer method is intended for convenient inline usage. Example:
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u')
+     *         ->from('users', 'u')
+     *         ->where($qb->fun()->md5('u.id'));
+     * </code>
+     *
+     * For more complex function construction, consider storing the function
+     * builder object in a local variable.
+     *
+     * @return \OCP\DB\QueryBuilder\IFunctionBuilder
+     * @since 12.0.0
+     */
+    public function func();
+
+    /**
+     * Gets the type of the currently built query.
+     *
+     * @return integer
+     * @since 8.2.0
+     */
+    public function getType();
+
+    /**
+     * Gets the associated DBAL Connection for this query builder.
+     *
+     * @return \OCP\IDBConnection
+     * @since 8.2.0
+     */
+    public function getConnection();
+
+    /**
+     * Gets the state of this query builder instance.
+     *
+     * @return integer Either QueryBuilder::STATE_DIRTY or QueryBuilder::STATE_CLEAN.
+     * @since 8.2.0
+     * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
+     *    and we can not fix this in our wrapper.
+     */
+    public function getState();
+
+    /**
+     * Execute for select statements
+     *
+     * @param ?IDBConnection $connection (optional) the connection to run the query against. since 30.0
+     * @return IResult
+     * @since 22.0.0
+     *
+     * @throws Exception
+     * @throws \RuntimeException in case of usage with non select query
+     */
+    public function executeQuery(?IDBConnection $connection = null): IResult;
+
+    /**
+     * Execute insert, update and delete statements
+     *
+     * @param ?IDBConnection $connection (optional) the connection to run the query against. since 30.0
+     * @return int the number of affected rows
+     * @since 22.0.0
+     *
+     * @throws Exception
+     * @throws \RuntimeException in case of usage with select query
+     */
+    public function executeStatement(?IDBConnection $connection = null): int;
+
+    /**
+     * Gets the complete SQL string formed by the current specifications of this QueryBuilder.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u')
+     *         ->from('User', 'u')
+     *     echo $qb->getSQL(); // SELECT u FROM User u
+     * </code>
+     *
+     * @return string The SQL query string.
+     * @since 8.2.0
+     */
+    public function getSQL();
+
+    /**
+     * Sets a query parameter for the query being constructed.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u')
+     *         ->from('users', 'u')
+     *         ->where('u.id = :user_id')
+     *         ->setParameter(':user_id', 1);
+     * </code>
+     *
+     * @param string|integer $key The parameter position or name.
+     * @param mixed $value The parameter value.
+     * @param string|null|int $type One of the IQueryBuilder::PARAM_* constants.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     */
+    public function setParameter($key, $value, $type = null);
+
+    /**
+     * Sets a collection of query parameters for the query being constructed.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u')
+     *         ->from('users', 'u')
+     *         ->where('u.id = :user_id1 OR u.id = :user_id2')
+     *         ->setParameters(array(
+     *             ':user_id1' => 1,
+     *             ':user_id2' => 2
+     *         ));
+     * </code>
+     *
+     * @param array $params The query parameters to set.
+     * @param array $types The query parameters types to set.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     */
+    public function setParameters(array $params, array $types = []);
+
+    /**
+     * Gets all defined query parameters for the query being constructed indexed by parameter index or name.
+     *
+     * @return array The currently defined query parameters indexed by parameter index or name.
+     * @since 8.2.0
+     */
+    public function getParameters();
+
+    /**
+     * Gets a (previously set) query parameter of the query being constructed.
+     *
+     * @param mixed $key The key (index or name) of the bound parameter.
+     *
+     * @return mixed The value of the bound parameter.
+     * @since 8.2.0
+     */
+    public function getParameter($key);
+
+    /**
+     * Gets all defined query parameter types for the query being constructed indexed by parameter index or name.
+     *
+     * @return array The currently defined query parameter types indexed by parameter index or name.
+     * @since 8.2.0
+     */
+    public function getParameterTypes();
+
+    /**
+     * Gets a (previously set) query parameter type of the query being constructed.
+     *
+     * @param mixed $key The key (index or name) of the bound parameter type.
+     *
+     * @return mixed The value of the bound parameter type.
+     * @since 8.2.0
+     */
+    public function getParameterType($key);
+
+    /**
+     * Sets the position of the first result to retrieve (the "offset").
+     *
+     * @param int $firstResult The first result to return.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     */
+    public function setFirstResult($firstResult);
+
+    /**
+     * Gets the position of the first result the query object was set to retrieve (the "offset").
+     * Returns 0 if {@link setFirstResult} was not applied to this QueryBuilder.
+     *
+     * @return int The position of the first result.
+     * @since 8.2.0
+     */
+    public function getFirstResult();
+
+    /**
+     * Sets the maximum number of results to retrieve (the "limit").
+     *
+     * @param int|null $maxResults The maximum number of results to retrieve.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     */
+    public function setMaxResults($maxResults);
+
+    /**
+     * Gets the maximum number of results the query object was set to retrieve (the "limit").
+     * Returns NULL if {@link setMaxResults} was not applied to this query builder.
+     *
+     * @return int|null The maximum number of results.
+     * @since 8.2.0
+     */
+    public function getMaxResults();
+
+    /**
+     * Specifies an item that is to be returned in the query result.
+     * Replaces any previously specified selections, if any.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.id', 'p.id')
+     *         ->from('users', 'u')
+     *         ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
+     * </code>
+     *
+     * @param mixed ...$selects The selection expressions.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $selects
+     */
+    public function select(...$selects);
+
+    /**
+     * Specifies an item that is to be returned with a different name in the query result.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->selectAlias('u.id', 'user_id')
+     *         ->from('users', 'u')
+     *         ->leftJoin('u', 'phonenumbers', 'p', 'u.id = p.user_id');
+     * </code>
+     *
+     * @param mixed $select The selection expressions.
+     * @param string $alias The column alias used in the constructed query.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.1
+     *
+     * @psalm-taint-sink sql $select
+     * @psalm-taint-sink sql $alias
+     */
+    public function selectAlias($select, $alias);
+
+    /**
+     * Specifies an item that is to be returned uniquely in the query result.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->selectDistinct('type')
+     *         ->from('users');
+     * </code>
+     *
+     * @param mixed $select The selection expressions.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 9.0.0
+     *
+     * @psalm-taint-sink sql $select
+     */
+    public function selectDistinct($select);
+
+    /**
+     * Adds an item that is to be returned in the query result.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.id')
+     *         ->addSelect('p.id')
+     *         ->from('users', 'u')
+     *         ->leftJoin('u', 'phonenumbers', 'u.id = p.user_id');
+     * </code>
+     *
+     * @param mixed ...$select The selection expression.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $select
+     */
+    public function addSelect(...$select);
+
+    /**
+     * Turns the query being built into a bulk delete query that ranges over
+     * a certain table.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->delete('users')
+     *         ->where('id = :user_id');
+     *         ->setParameter(':user_id', 1);
+     * </code>
+     *
+     * @param string $delete The table whose rows are subject to the deletion.
+     * @param string $alias The table alias used in the constructed query.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     * @since 30.0.0 Alias is deprecated and will no longer be used with the next Doctrine/DBAL update
+     *
+     * @psalm-taint-sink sql $delete
+     */
+    public function delete($delete = null, $alias = null);
+
+    /**
+     * Turns the query being built into a bulk update query that ranges over
+     * a certain table
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->update('users')
+     *         ->set('email', ':email')
+     *         ->where('id = :user_id');
+     *         ->setParameter(':user_id', 1);
+     * </code>
+     *
+     * @param string $update The table whose rows are subject to the update.
+     * @param string $alias The table alias used in the constructed query.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     * @since 30.0.0 Alias is deprecated and will no longer be used with the next Doctrine/DBAL update
+     *
+     * @psalm-taint-sink sql $update
+     */
+    public function update($update = null, $alias = null);
+
+    /**
+     * Turns the query being built into an insert query that inserts into
+     * a certain table
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->insert('users')
+     *         ->values(
+     *             array(
+     *                 'name' => '?',
+     *                 'password' => '?'
+     *             )
+     *         );
+     * </code>
+     *
+     * @param string $insert The table into which the rows should be inserted.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $insert
+     */
+    public function insert($insert = null);
+
+    /**
+     * Creates and adds a query root corresponding to the table identified by the
+     * given alias, forming a cartesian product with any existing query roots.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.id')
+     *         ->from('users', 'u')
+     * </code>
+     *
+     * @param string|IQueryFunction $from The table.
+     * @param string|null $alias The alias of the table.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $from
+     */
+    public function from($from, $alias = null);
+
+    /**
+     * Creates and adds a join to the query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->join('u', 'phonenumbers', 'p', 'p.is_primary = 1');
+     * </code>
+     *
+     * @param string $fromAlias The alias that points to a from clause.
+     * @param string|IQueryFunction $join The table name to join.
+     * @param string $alias The alias of the join table.
+     * @param string|ICompositeExpression|null $condition The condition for the join.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $fromAlias
+     * @psalm-taint-sink sql $join
+     * @psalm-taint-sink sql $alias
+     * @psalm-taint-sink sql $condition
+     */
+    public function join($fromAlias, $join, $alias, $condition = null);
+
+    /**
+     * Creates and adds a join to the query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->innerJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
+     * </code>
+     *
+     * @param string $fromAlias The alias that points to a from clause.
+     * @param string|IQueryFunction $join The table name to join.
+     * @param string $alias The alias of the join table.
+     * @param string|ICompositeExpression|null $condition The condition for the join.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $fromAlias
+     * @psalm-taint-sink sql $join
+     * @psalm-taint-sink sql $alias
+     * @psalm-taint-sink sql $condition
+     */
+    public function innerJoin($fromAlias, $join, $alias, $condition = null);
+
+    /**
+     * Creates and adds a left join to the query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->leftJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
+     * </code>
+     *
+     * @param string $fromAlias The alias that points to a from clause.
+     * @param string|IQueryFunction $join The table name to join.
+     * @param string $alias The alias of the join table.
+     * @param string|ICompositeExpression|null $condition The condition for the join.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     * @since 30.0.0 Allow passing IQueryFunction as parameter for `$join` to allow join with a sub-query.
+     *
+     * @psalm-taint-sink sql $fromAlias
+     * @psalm-taint-sink sql $join
+     * @psalm-taint-sink sql $alias
+     * @psalm-taint-sink sql $condition
+     */
+    public function leftJoin($fromAlias, $join, $alias, $condition = null);
+
+    /**
+     * Creates and adds a right join to the query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->rightJoin('u', 'phonenumbers', 'p', 'p.is_primary = 1');
+     * </code>
+     *
+     * @param string $fromAlias The alias that points to a from clause.
+     * @param string|IQueryFunction $join The table name to join.
+     * @param string $alias The alias of the join table.
+     * @param string|ICompositeExpression|null $condition The condition for the join.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $fromAlias
+     * @psalm-taint-sink sql $join
+     * @psalm-taint-sink sql $alias
+     * @psalm-taint-sink sql $condition
+     */
+    public function rightJoin($fromAlias, $join, $alias, $condition = null);
+
+    /**
+     * Sets a new value for a column in a bulk update query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->update('users', 'u')
+     *         ->set('u.password', md5('password'))
+     *         ->where('u.id = ?');
+     * </code>
+     *
+     * @param string $key The column to set.
+     * @param ILiteral|IParameter|IQueryFunction|string $value The value, expression, placeholder, etc.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $key
+     * @psalm-taint-sink sql $value
+     */
+    public function set($key, $value);
+
+    /**
+     * Specifies one or more restrictions to the query result.
+     * Replaces any previously specified restrictions, if any.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->where('u.id = ?');
+     *
+     *     // You can optionally programmatically build and/or expressions
+     *     $qb = $conn->getQueryBuilder();
+     *
+     *     $or = $qb->expr()->orx(
+     *         $qb->expr()->eq('u.id', 1),
+     *         $qb->expr()->eq('u.id', 2),
+     *     );
+     *
+     *     $qb->update('users', 'u')
+     *         ->set('u.password', md5('password'))
+     *         ->where($or);
+     * </code>
+     *
+     * @param mixed $predicates The restriction predicates.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $predicates
+     */
+    public function where(...$predicates);
+
+    /**
+     * Adds one or more restrictions to the query results, forming a logical
+     * conjunction with any previously specified restrictions.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u')
+     *         ->from('users', 'u')
+     *         ->where('u.username LIKE ?')
+     *         ->andWhere('u.is_active = 1');
+     * </code>
+     *
+     * @param mixed ...$where The query restrictions.
+     *
+     * @return $this This QueryBuilder instance.
+     *
+     * @see where()
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $where
+     */
+    public function andWhere(...$where);
+
+    /**
+     * Adds one or more restrictions to the query results, forming a logical
+     * disjunction with any previously specified restrictions.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->where('u.id = 1')
+     *         ->orWhere('u.id = 2');
+     * </code>
+     *
+     * @param mixed ...$where The WHERE statement.
+     *
+     * @return $this This QueryBuilder instance.
+     *
+     * @see where()
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $where
+     */
+    public function orWhere(...$where);
+
+    /**
+     * Specifies a grouping over the results of the query.
+     * Replaces any previously specified groupings, if any.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->groupBy('u.id');
+     * </code>
+     *
+     * @param mixed ...$groupBys The grouping expression.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $groupBys
+     */
+    public function groupBy(...$groupBys);
+
+    /**
+     * Adds a grouping expression to the query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->select('u.name')
+     *         ->from('users', 'u')
+     *         ->groupBy('u.lastLogin');
+     *         ->addGroupBy('u.createdAt')
+     * </code>
+     *
+     * @param mixed ...$groupBy The grouping expression.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $groupby
+     */
+    public function addGroupBy(...$groupBy);
+
+    /**
+     * Sets a value for a column in an insert query.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->insert('users')
+     *         ->values(
+     *             array(
+     *                 'name' => '?'
+     *             )
+     *         )
+     *         ->setValue('password', '?');
+     * </code>
+     *
+     * @param string $column The column into which the value should be inserted.
+     * @param IParameter|string $value The value that should be inserted into the column.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $column
+     * @psalm-taint-sink sql $value
+     */
+    public function setValue($column, $value);
+
+    /**
+     * Specifies values for an insert query indexed by column names.
+     * Replaces any previous values, if any.
+     *
+     * <code>
+     *     $qb = $conn->getQueryBuilder()
+     *         ->insert('users')
+     *         ->values(
+     *             array(
+     *                 'name' => '?',
+     *                 'password' => '?'
+     *             )
+     *         );
+     * </code>
+     *
+     * @param array $values The values to specify for the insert query indexed by column names.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $values
+     */
+    public function values(array $values);
+
+    /**
+     * Specifies a restriction over the groups of the query.
+     * Replaces any previous having restrictions, if any.
+     *
+     * @param mixed ...$having The restriction over the groups.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $having
+     */
+    public function having(...$having);
+
+    /**
+     * Adds a restriction over the groups of the query, forming a logical
+     * conjunction with any existing having restrictions.
+     *
+     * @param mixed ...$having The restriction to append.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $andHaving
+     */
+    public function andHaving(...$having);
+
+    /**
+     * Adds a restriction over the groups of the query, forming a logical
+     * disjunction with any existing having restrictions.
+     *
+     * @param mixed ...$having The restriction to add.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $having
+     */
+    public function orHaving(...$having);
+
+    /**
+     * Specifies an ordering for the query results.
+     * Replaces any previously specified orderings, if any.
+     *
+     * @param string|IQueryFunction|ILiteral|IParameter $sort The ordering expression.
+     * @param string $order The ordering direction.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $sort
+     * @psalm-taint-sink sql $order
+     */
+    public function orderBy($sort, $order = null);
+
+    /**
+     * Adds an ordering to the query results.
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $sort The ordering expression.
+     * @param string $order The ordering direction.
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $sort
+     * @psalm-taint-sink sql $order
+     */
+    public function addOrderBy($sort, $order = null);
+
+    /**
+     * Gets a query part by its name.
+     *
+     * @param string $queryPartName
+     *
+     * @return mixed
+     * @since 8.2.0
+     * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
+     *  and we can not fix this in our wrapper. Please track the details you need, outside the object.
+     */
+    public function getQueryPart($queryPartName);
+
+    /**
+     * Gets all query parts.
+     *
+     * @return array
+     * @since 8.2.0
+     * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
+     *  and we can not fix this in our wrapper. Please track the details you need, outside the object.
+     */
+    public function getQueryParts();
+
+    /**
+     * Resets SQL parts.
+     *
+     * @param array|null $queryPartNames
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
+     * and we can not fix this in our wrapper. Please create a new IQueryBuilder instead.
+     */
+    public function resetQueryParts($queryPartNames = null);
+
+    /**
+     * Resets a single SQL part.
+     *
+     * @param string $queryPartName
+     *
+     * @return $this This QueryBuilder instance.
+     * @since 8.2.0
+     * @deprecated 30.0.0 This function is going to be removed with the next Doctrine/DBAL update
+     *  and we can not fix this in our wrapper. Please create a new IQueryBuilder instead.
+     */
+    public function resetQueryPart($queryPartName);
+
+    /**
+     * Creates a new named parameter and bind the value $value to it.
+     *
+     * This method provides a shortcut for PDOStatement::bindValue
+     * when using prepared statements.
+     *
+     * The parameter $value specifies the value that you want to bind. If
+     * $placeholder is not provided bindValue() will automatically create a
+     * placeholder for you. An automatic placeholder will be of the name
+     * ':dcValue1', ':dcValue2' etc.
+     *
+     * For more information see {@link https://www.php.net/pdostatement-bindparam}
+     *
+     * Example:
+     * <code>
+     * $value = 2;
+     * $q->eq( 'id', $q->bindValue( $value ) );
+     * $stmt = $q->executeQuery(); // executed with 'id = 2'
+     * </code>
+     *
+     * @license New BSD License
+     * @link http://www.zetacomponents.org
+     *
+     * @param mixed $value
+     * @param self::PARAM_* $type
+     * @param string $placeHolder The name to bind with. The string must start with a colon ':'.
+     *
+     * @return IParameter
+     * @since 8.2.0
+     *
+     * @psalm-taint-escape sql
+     */
+    public function createNamedParameter($value, $type = self::PARAM_STR, $placeHolder = null);
+
+    /**
+     * Creates a new positional parameter and bind the given value to it.
+     *
+     * Attention: If you are using positional parameters with the query builder you have
+     * to be very careful to bind all parameters in the order they appear in the SQL
+     * statement , otherwise they get bound in the wrong order which can lead to serious
+     * bugs in your code.
+     *
+     * Example:
+     * <code>
+     *  $qb = $conn->getQueryBuilder();
+     *  $qb->select('u.*')
+     *     ->from('users', 'u')
+     *     ->where('u.username = ' . $qb->createPositionalParameter('Foo', IQueryBuilder::PARAM_STR))
+     *     ->orWhere('u.username = ' . $qb->createPositionalParameter('Bar', IQueryBuilder::PARAM_STR))
+     * </code>
+     *
+     * @param mixed $value
+     * @param self::PARAM_* $type
+     *
+     * @return IParameter
+     * @since 8.2.0
+     *
+     * @psalm-taint-escape sql
+     */
+    public function createPositionalParameter($value, $type = self::PARAM_STR);
+
+    /**
+     * Creates a new parameter
+     *
+     * Example:
+     * <code>
+     *  $qb = $conn->getQueryBuilder();
+     *  $qb->select('u.*')
+     *     ->from('users', 'u')
+     *     ->where('u.username = ' . $qb->createParameter('name'))
+     *     ->setParameter('name', 'Bar', IQueryBuilder::PARAM_STR))
+     * </code>
+     *
+     * @param string $name
+     *
+     * @return IParameter
+     * @since 8.2.0
+     *
+     * @psalm-taint-escape sql
+     */
+    public function createParameter($name);
+
+    /**
+     * Creates a new function
+     *
+     * Attention: Column names inside the call have to be quoted before hand
+     *
+     * Example:
+     * <code>
+     *  $qb = $conn->getQueryBuilder();
+     *  $qb->select($qb->createFunction('COUNT(*)'))
+     *     ->from('users', 'u')
+     *  echo $qb->getSQL(); // SELECT COUNT(*) FROM `users` u
+     * </code>
+     * <code>
+     *  $qb = $conn->getQueryBuilder();
+     *  $qb->select($qb->createFunction('COUNT(`column`)'))
+     *     ->from('users', 'u')
+     *  echo $qb->getSQL(); // SELECT COUNT(`column`) FROM `users` u
+     * </code>
+     *
+     * @param string $call
+     *
+     * @return IQueryFunction
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $call
+     */
+    public function createFunction($call);
+
+    /**
+     * Used to get the id of the last inserted element
+     * @return int
+     * @throws \BadMethodCallException When being called before an insert query has been run.
+     * @since 9.0.0
+     */
+    public function getLastInsertId(): int;
+
+    /**
+     * Returns the table name quoted and with database prefix as needed by the implementation.
+     * If a query function is passed the function is casted to string,
+     * this allows passing functions as sub-queries for join expression.
+     *
+     * @param string|IQueryFunction $table
+     * @return string
+     * @since 9.0.0
+     * @since 24.0.0 accepts IQueryFunction as parameter
+     */
+    public function getTableName($table);
+
+    /**
+     * Returns the table name with database prefix as needed by the implementation
+     *
+     * @param string $table
+     * @return string
+     * @since 30.0.0
+     */
+    public function prefixTableName(string $table): string;
+
+    /**
+     * Returns the column name quoted and with table alias prefix as needed by the implementation
+     *
+     * @param string $column
+     * @param string $tableAlias
+     * @return string
+     * @since 9.0.0
+     */
+    public function getColumnName($column, $tableAlias = '');
+
+    /**
+     * Provide a hint for the shard key for queries where this can't be detected otherwise
+     *
+     * @param string $column
+     * @param mixed $value
+     * @return $this
+     * @since 30.0.0
+     */
+    public function hintShardKey(string $column, mixed $value, bool $overwrite = false): self;
+
+    /**
+     * Set the query to run across all shards if sharding is enabled.
+     *
+     * @return $this
+     * @since 30.0.0
+     */
+    public function runAcrossAllShards(): self;
+
+    /**
+     * Get a list of column names that are expected in the query output
+     *
+     * @return array
+     * @since 30.0.0
+     */
+    public function getOutputColumns(): array;
 }

lib/private/Preview/PreviewService.php

Indentation +107 added lines, -107 removed lines

@@ -16,111 +16,111 @@
 use OCP\IDBConnection;
 
 class PreviewService {
-	public function __construct(
-		private readonly StorageFactory $storageFactory,
-		private readonly PreviewMapper $previewMapper,
-		private readonly IDBConnection $connection,
-	) {
-	}
-
-	public function deletePreview(Preview $preview): void {
-		$this->storageFactory->deletePreview($preview);
-		$this->previewMapper->delete($preview);
-	}
-
-	/**
-	 * Get storageId and fileIds for which we have at least one preview.
-	 *
-	 * @return \Generator<array{storageId: int, fileIds: int[]}>
-	 */
-	public function getAvailableFileIds(): \Generator {
-		$lastId = null;
-		while (true) {
-			$maxQb = $this->connection->getQueryBuilder();
-			$maxQb->selectAlias($maxQb->func()->max('id'), 'max_id')
-				->from($this->previewMapper->getTableName())
-				->groupBy('file_id')
-				->orderBy('max_id', 'ASC');
-
-			$qb = $this->connection->getQueryBuilder();
-
-			if ($lastId !== null) {
-				$maxQb->andWhere($maxQb->expr()->gt('id', $qb->createNamedParameter($lastId)));
-			}
-
-			$qb->select('id', 'file_id', 'storage_id')
-				->from($this->previewMapper->getTableName(), 'p1')
-				->innerJoin('p1', $qb->createFunction('(' . $maxQb->getSQL() . ')'), 'p2', $qb->expr()->eq('p1.id', 'p2.max_id'))
-				->setMaxResults(1000);
-
-			$result = $qb->executeQuery();
-
-			$lastStorageId = -1;
-			/** @var int[] $fileIds */
-			$fileIds = [];
-
-			$found = false;
-			// Previews next to each others in the database are likely in the same storage, so group them
-			while ($row = $result->fetch()) {
-				$found = true;
-				if ($lastStorageId !== (int)$row['storage_id']) {
-					if ($lastStorageId !== -1) {
-						yield ['storageId' => $lastStorageId, 'fileIds' => $fileIds];
-						$fileIds = [];
-					}
-					$lastStorageId = (int)$row['storage_id'];
-				}
-				$fileIds[] = (int)$row['file_id'];
-				$lastId = $row['id'];
-			}
-
-			if (count($fileIds) > 0) {
-				yield ['storageId' => $lastStorageId, 'fileIds' => $fileIds];
-			}
-
-			if (!$found) {
-				break;
-			}
-		}
-	}
-
-	/**
-	 * @return \Generator<Preview>
-	 */
-	public function getAvailablePreviewsForFile(int $fileId): \Generator {
-		return $this->previewMapper->getAvailablePreviewsForFile($fileId);
-	}
-
-	/**
-	 * @param string[] $mimeTypes
-	 * @return \Generator<Preview>
-	 */
-	public function getPreviewsForMimeTypes(array $mimeTypes): \Generator {
-		return $this->previewMapper->getPreviewsForMimeTypes($mimeTypes);
-	}
-
-	public function deleteAll(): void {
-		$lastId = 0;
-		while (true) {
-			$previews = $this->previewMapper->getPreviews($lastId, 1000);
-			$i = 0;
-			foreach ($previews as $preview) {
-				$this->deletePreview($preview);
-				$i++;
-				$lastId = $preview->getId();
-			}
-
-			if ($i !== 1000) {
-				break;
-			}
-		}
-	}
-
-	/**
-	 * @param int[] $fileIds
-	 * @return array<int, Preview[]>
-	 */
-	public function getAvailablePreviews(array $fileIds): array {
-		return $this->previewMapper->getAvailablePreviews($fileIds);
-	}
+    public function __construct(
+        private readonly StorageFactory $storageFactory,
+        private readonly PreviewMapper $previewMapper,
+        private readonly IDBConnection $connection,
+    ) {
+    }
+
+    public function deletePreview(Preview $preview): void {
+        $this->storageFactory->deletePreview($preview);
+        $this->previewMapper->delete($preview);
+    }
+
+    /**
+     * Get storageId and fileIds for which we have at least one preview.
+     *
+     * @return \Generator<array{storageId: int, fileIds: int[]}>
+     */
+    public function getAvailableFileIds(): \Generator {
+        $lastId = null;
+        while (true) {
+            $maxQb = $this->connection->getQueryBuilder();
+            $maxQb->selectAlias($maxQb->func()->max('id'), 'max_id')
+                ->from($this->previewMapper->getTableName())
+                ->groupBy('file_id')
+                ->orderBy('max_id', 'ASC');
+
+            $qb = $this->connection->getQueryBuilder();
+
+            if ($lastId !== null) {
+                $maxQb->andWhere($maxQb->expr()->gt('id', $qb->createNamedParameter($lastId)));
+            }
+
+            $qb->select('id', 'file_id', 'storage_id')
+                ->from($this->previewMapper->getTableName(), 'p1')
+                ->innerJoin('p1', $qb->createFunction('(' . $maxQb->getSQL() . ')'), 'p2', $qb->expr()->eq('p1.id', 'p2.max_id'))
+                ->setMaxResults(1000);
+
+            $result = $qb->executeQuery();
+
+            $lastStorageId = -1;
+            /** @var int[] $fileIds */
+            $fileIds = [];
+
+            $found = false;
+            // Previews next to each others in the database are likely in the same storage, so group them
+            while ($row = $result->fetch()) {
+                $found = true;
+                if ($lastStorageId !== (int)$row['storage_id']) {
+                    if ($lastStorageId !== -1) {
+                        yield ['storageId' => $lastStorageId, 'fileIds' => $fileIds];
+                        $fileIds = [];
+                    }
+                    $lastStorageId = (int)$row['storage_id'];
+                }
+                $fileIds[] = (int)$row['file_id'];
+                $lastId = $row['id'];
+            }
+
+            if (count($fileIds) > 0) {
+                yield ['storageId' => $lastStorageId, 'fileIds' => $fileIds];
+            }
+
+            if (!$found) {
+                break;
+            }
+        }
+    }
+
+    /**
+     * @return \Generator<Preview>
+     */
+    public function getAvailablePreviewsForFile(int $fileId): \Generator {
+        return $this->previewMapper->getAvailablePreviewsForFile($fileId);
+    }
+
+    /**
+     * @param string[] $mimeTypes
+     * @return \Generator<Preview>
+     */
+    public function getPreviewsForMimeTypes(array $mimeTypes): \Generator {
+        return $this->previewMapper->getPreviewsForMimeTypes($mimeTypes);
+    }
+
+    public function deleteAll(): void {
+        $lastId = 0;
+        while (true) {
+            $previews = $this->previewMapper->getPreviews($lastId, 1000);
+            $i = 0;
+            foreach ($previews as $preview) {
+                $this->deletePreview($preview);
+                $i++;
+                $lastId = $preview->getId();
+            }
+
+            if ($i !== 1000) {
+                break;
+            }
+        }
+    }
+
+    /**
+     * @param int[] $fileIds
+     * @return array<int, Preview[]>
+     */
+    public function getAvailablePreviews(array $fileIds): array {
+        return $this->previewMapper->getAvailablePreviews($fileIds);
+    }
 }

Spacing +4 added lines, -4 removed lines

@@ -50,7 +50,7 @@ 
 
 			$qb->select('id', 'file_id', 'storage_id')
 				->from($this->previewMapper->getTableName(), 'p1')
-				->innerJoin('p1', $qb->createFunction('(' . $maxQb->getSQL() . ')'), 'p2', $qb->expr()->eq('p1.id', 'p2.max_id'))
+				->innerJoin('p1', $qb->createFunction('('.$maxQb->getSQL().')'), 'p2', $qb->expr()->eq('p1.id', 'p2.max_id'))
 				->setMaxResults(1000);
 
 			$result = $qb->executeQuery();
@@ -63,14 +63,14 @@ 
 			// Previews next to each others in the database are likely in the same storage, so group them
 			while ($row = $result->fetch()) {
 				$found = true;
-				if ($lastStorageId !== (int)$row['storage_id']) {
+				if ($lastStorageId !== (int) $row['storage_id']) {
 					if ($lastStorageId !== -1) {
 						yield ['storageId' => $lastStorageId, 'fileIds' => $fileIds];
 						$fileIds = [];
 					}
-					$lastStorageId = (int)$row['storage_id'];
+					$lastStorageId = (int) $row['storage_id'];
 				}
-				$fileIds[] = (int)$row['file_id'];
+				$fileIds[] = (int) $row['file_id'];
 				$lastId = $row['id'];
 			}
 

lib/private/DB/QueryBuilder/Sharded/ShardedQueryBuilder.php

Indentation +381 added lines, -381 removed lines

@@ -25,387 +25,387 @@
  * from the query. The logic for actually running the query across the shards is mostly delegated to `ShardQueryRunner`.
  */
 class ShardedQueryBuilder extends ExtendedQueryBuilder {
-	private array $shardKeys = [];
-	private array $primaryKeys = [];
-	private ?ShardDefinition $shardDefinition = null;
-	/** @var bool Run the query across all shards */
-	private bool $allShards = false;
-	private ?string $insertTable = null;
-	private mixed $lastInsertId = null;
-	private ?IDBConnection $lastInsertConnection = null;
-	private ?int $updateShardKey = null;
-	private ?int $limit = null;
-	private ?int $offset = null;
-	/** @var array{column: string, order: string}[] */
-	private array $sortList = [];
-	private string $mainTable = '';
-
-	public function __construct(
-		IQueryBuilder $builder,
-		protected array $shardDefinitions,
-		protected ShardConnectionManager $shardConnectionManager,
-		protected AutoIncrementHandler $autoIncrementHandler,
-	) {
-		parent::__construct($builder);
-	}
-
-	public function getShardKeys(): array {
-		return $this->getKeyValues($this->shardKeys);
-	}
-
-	public function getPrimaryKeys(): array {
-		return $this->getKeyValues($this->primaryKeys);
-	}
-
-	private function getKeyValues(array $keys): array {
-		$values = [];
-		foreach ($keys as $key) {
-			$values = array_merge($values, $this->getKeyValue($key));
-		}
-		return array_values(array_unique($values));
-	}
-
-	private function getKeyValue($value): array {
-		if ($value instanceof Parameter) {
-			$value = (string)$value;
-		}
-		if (is_string($value) && str_starts_with($value, ':')) {
-			$param = $this->getParameter(substr($value, 1));
-			if (is_array($param)) {
-				return $param;
-			} else {
-				return [$param];
-			}
-		} elseif ($value !== null) {
-			return [$value];
-		} else {
-			return [];
-		}
-	}
-
-	public function where(...$predicates) {
-		return $this->andWhere(...$predicates);
-	}
-
-	public function andWhere(...$where) {
-		if ($where) {
-			foreach ($where as $predicate) {
-				$this->tryLoadShardKey($predicate);
-			}
-			parent::andWhere(...$where);
-		}
-		return $this;
-	}
-
-	private function tryLoadShardKey($predicate): void {
-		if (!$this->shardDefinition) {
-			return;
-		}
-		if ($keys = $this->tryExtractShardKeys($predicate, $this->shardDefinition->shardKey)) {
-			$this->shardKeys += $keys;
-		}
-		if ($keys = $this->tryExtractShardKeys($predicate, $this->shardDefinition->primaryKey)) {
-			$this->primaryKeys += $keys;
-		}
-		foreach ($this->shardDefinition->companionKeys as $companionKey) {
-			if ($keys = $this->tryExtractShardKeys($predicate, $companionKey)) {
-				$this->primaryKeys += $keys;
-			}
-		}
-	}
-
-	/**
-	 * @param $predicate
-	 * @param string $column
-	 * @return string[]
-	 */
-	private function tryExtractShardKeys($predicate, string $column): array {
-		if ($predicate instanceof CompositeExpression) {
-			$values = [];
-			foreach ($predicate->getParts() as $part) {
-				$partValues = $this->tryExtractShardKeys($part, $column);
-				// for OR expressions, we can only rely on the predicate if all parts contain the comparison
-				if ($predicate->getType() === CompositeExpression::TYPE_OR && !$partValues) {
-					return [];
-				}
-				$values = array_merge($values, $partValues);
-			}
-			return $values;
-		}
-		$predicate = (string)$predicate;
-		// expect a condition in the form of 'alias1.column1 = placeholder' or 'alias1.column1 in placeholder'
-		if (substr_count($predicate, ' ') > 2) {
-			return [];
-		}
-		if (str_contains($predicate, ' = ')) {
-			$parts = explode(' = ', $predicate);
-			if ($parts[0] === "`{$column}`" || str_ends_with($parts[0], "`.`{$column}`")) {
-				return [$parts[1]];
-			} else {
-				return [];
-			}
-		}
-
-		if (str_contains($predicate, ' IN ')) {
-			$parts = explode(' IN ', $predicate);
-			if ($parts[0] === "`{$column}`" || str_ends_with($parts[0], "`.`{$column}`")) {
-				return [trim(trim($parts[1], '('), ')')];
-			} else {
-				return [];
-			}
-		}
-
-		return [];
-	}
-
-	public function set($key, $value) {
-		if ($this->shardDefinition && $key === $this->shardDefinition->shardKey) {
-			$updateShardKey = $value;
-		}
-		return parent::set($key, $value);
-	}
-
-	public function setValue($column, $value) {
-		if ($this->shardDefinition) {
-			if ($this->shardDefinition->isKey($column)) {
-				$this->primaryKeys[] = $value;
-			}
-			if ($column === $this->shardDefinition->shardKey) {
-				$this->shardKeys[] = $value;
-			}
-		}
-		return parent::setValue($column, $value);
-	}
-
-	public function values(array $values) {
-		foreach ($values as $column => $value) {
-			$this->setValue($column, $value);
-		}
-		return $this;
-	}
-
-	private function actOnTable(string $table): void {
-		$this->mainTable = $table;
-		foreach ($this->shardDefinitions as $shardDefinition) {
-			if ($shardDefinition->hasTable($table)) {
-				$this->shardDefinition = $shardDefinition;
-			}
-		}
-	}
-
-	public function from($from, $alias = null) {
-		if (is_string($from) && $from) {
-			$this->actOnTable($from);
-		}
-		return parent::from($from, $alias);
-	}
-
-	public function update($update = null, $alias = null) {
-		if (is_string($update) && $update) {
-			$this->actOnTable($update);
-		}
-		return parent::update($update, $alias);
-	}
-
-	public function insert($insert = null) {
-		if (is_string($insert) && $insert) {
-			$this->insertTable = $insert;
-			$this->actOnTable($insert);
-		}
-		return parent::insert($insert);
-	}
-
-	public function delete($delete = null, $alias = null) {
-		if (is_string($delete) && $delete) {
-			$this->actOnTable($delete);
-		}
-		return parent::delete($delete, $alias);
-	}
-
-	private function checkJoin(string $table): void {
-		if ($this->shardDefinition) {
-			if ($table === $this->mainTable) {
-				throw new InvalidShardedQueryException("Sharded query on {$this->mainTable} isn't allowed to join on itself");
-			}
-			if (!$this->shardDefinition->hasTable($table)) {
-				// this generally shouldn't happen as the partitioning logic should prevent this
-				// but the check is here just in case
-				throw new InvalidShardedQueryException("Sharded query on {$this->shardDefinition->table} isn't allowed to join on $table");
-			}
-		}
-	}
-
-	public function innerJoin($fromAlias, $join, $alias, $condition = null) {
-		if (is_string($join)) {
-			$this->checkJoin($join);
-		}
-		return parent::innerJoin($fromAlias, $join, $alias, $condition);
-	}
-
-	public function leftJoin($fromAlias, $join, $alias, $condition = null) {
-		if (is_string($join)) {
-			$this->checkJoin($join);
-		}
-		return parent::leftJoin($fromAlias, $join, $alias, $condition);
-	}
-
-	public function rightJoin($fromAlias, $join, $alias, $condition = null) {
-		if ($this->shardDefinition) {
-			throw new InvalidShardedQueryException("Sharded query on {$this->shardDefinition->table} isn't allowed to right join");
-		}
-		return parent::rightJoin($fromAlias, $join, $alias, $condition);
-	}
-
-	public function join($fromAlias, $join, $alias, $condition = null) {
-		return $this->innerJoin($fromAlias, $join, $alias, $condition);
-	}
-
-	public function setMaxResults($maxResults) {
-		if ($maxResults > 0) {
-			$this->limit = (int)$maxResults;
-		}
-		return parent::setMaxResults($maxResults);
-	}
-
-	public function setFirstResult($firstResult) {
-		if ($firstResult > 0) {
-			$this->offset = (int)$firstResult;
-		}
-		if ($this->shardDefinition && count($this->shardDefinition->shards) > 1) {
-			// we have to emulate offset
-			return $this;
-		} else {
-			return parent::setFirstResult($firstResult);
-		}
-	}
-
-	public function addOrderBy($sort, $order = null) {
-		$this->registerOrder((string)$sort, (string)$order ?? 'ASC');
-		return parent::addOrderBy($sort, $order);
-	}
-
-	public function orderBy($sort, $order = null) {
-		$this->sortList = [];
-		$this->registerOrder((string)$sort, (string)$order ?? 'ASC');
-		return parent::orderBy($sort, $order);
-	}
-
-	private function registerOrder(string $column, string $order): void {
-		// handle `mime + 0` and similar by just sorting on the first part of the expression
-		[$column] = explode(' ', $column);
-		$column = trim($column, '`');
-		$this->sortList[] = [
-			'column' => $column,
-			'order' => strtoupper($order),
-		];
-	}
-
-	public function hintShardKey(string $column, mixed $value, bool $overwrite = false): self {
-		if ($overwrite) {
-			$this->primaryKeys = [];
-			$this->shardKeys = [];
-		}
-		if ($this->shardDefinition?->isKey($column)) {
-			$this->primaryKeys[] = $value;
-		}
-		if ($column === $this->shardDefinition?->shardKey) {
-			$this->shardKeys[] = $value;
-		}
-		return $this;
-	}
-
-	public function runAcrossAllShards(): self {
-		$this->allShards = true;
-		return $this;
-	}
-
-	/**
-	 * @throws InvalidShardedQueryException
-	 */
-	public function validate(): void {
-		if ($this->shardDefinition && $this->insertTable) {
-			if ($this->allShards) {
-				throw new InvalidShardedQueryException("Can't insert across all shards");
-			}
-			if (empty($this->getShardKeys())) {
-				throw new InvalidShardedQueryException("Can't insert without shard key");
-			}
-		}
-		if ($this->shardDefinition && !$this->allShards) {
-			if (empty($this->getShardKeys()) && empty($this->getPrimaryKeys())) {
-				throw new InvalidShardedQueryException('No shard key or primary key set for query');
-			}
-		}
-		if ($this->shardDefinition && $this->updateShardKey) {
-			$newShardKey = $this->getKeyValue($this->updateShardKey);
-			$oldShardKeys = $this->getShardKeys();
-			if (count($newShardKey) !== 1) {
-				throw new InvalidShardedQueryException("Can't set shard key to an array");
-			}
-			$newShardKey = current($newShardKey);
-			if (empty($oldShardKeys)) {
-				throw new InvalidShardedQueryException("Can't update without shard key");
-			}
-			$oldShards = array_values(array_unique(array_map(function ($shardKey) {
-				return $this->shardDefinition->getShardForKey((int)$shardKey);
-			}, $oldShardKeys)));
-			$newShard = $this->shardDefinition->getShardForKey((int)$newShardKey);
-			if ($oldShards === [$newShard]) {
-				throw new InvalidShardedQueryException('Update statement would move rows to a different shard');
-			}
-		}
-	}
-
-	public function executeQuery(?IDBConnection $connection = null): IResult {
-		$this->validate();
-		if ($this->shardDefinition) {
-			$runner = new ShardQueryRunner($this->shardConnectionManager, $this->shardDefinition);
-			return $runner->executeQuery($this->builder, $this->allShards, $this->getShardKeys(), $this->getPrimaryKeys(), $this->sortList, $this->limit, $this->offset);
-		}
-		return parent::executeQuery($connection);
-	}
-
-	public function executeStatement(?IDBConnection $connection = null): int {
-		$this->validate();
-		if ($this->shardDefinition) {
-			$runner = new ShardQueryRunner($this->shardConnectionManager, $this->shardDefinition);
-			if ($this->insertTable) {
-				$shards = $runner->getShards($this->allShards, $this->getShardKeys());
-				if (!$shards) {
-					throw new InvalidShardedQueryException("Can't insert without shard key");
-				}
-				$count = 0;
-				foreach ($shards as $shard) {
-					$shardConnection = $this->shardConnectionManager->getConnection($this->shardDefinition, $shard);
-					if (!$this->primaryKeys && $this->shardDefinition->table === $this->insertTable) {
-						$id = $this->autoIncrementHandler->getNextPrimaryKey($this->shardDefinition, $shard);
-						parent::setValue($this->shardDefinition->primaryKey, $this->createParameter('__generated_primary_key'));
-						$this->setParameter('__generated_primary_key', $id, self::PARAM_INT);
-						$this->lastInsertId = $id;
-					}
-					$count += parent::executeStatement($shardConnection);
-
-					$this->lastInsertConnection = $shardConnection;
-				}
-				return $count;
-			} else {
-				return $runner->executeStatement($this->builder, $this->allShards, $this->getShardKeys(), $this->getPrimaryKeys());
-			}
-		}
-		return parent::executeStatement($connection);
-	}
-
-	public function getLastInsertId(): int {
-		if ($this->lastInsertId) {
-			return $this->lastInsertId;
-		}
-		if ($this->lastInsertConnection) {
-			$table = $this->builder->prefixTableName($this->insertTable);
-			return $this->lastInsertConnection->lastInsertId($table);
-		} else {
-			return parent::getLastInsertId();
-		}
-	}
+    private array $shardKeys = [];
+    private array $primaryKeys = [];
+    private ?ShardDefinition $shardDefinition = null;
+    /** @var bool Run the query across all shards */
+    private bool $allShards = false;
+    private ?string $insertTable = null;
+    private mixed $lastInsertId = null;
+    private ?IDBConnection $lastInsertConnection = null;
+    private ?int $updateShardKey = null;
+    private ?int $limit = null;
+    private ?int $offset = null;
+    /** @var array{column: string, order: string}[] */
+    private array $sortList = [];
+    private string $mainTable = '';
+
+    public function __construct(
+        IQueryBuilder $builder,
+        protected array $shardDefinitions,
+        protected ShardConnectionManager $shardConnectionManager,
+        protected AutoIncrementHandler $autoIncrementHandler,
+    ) {
+        parent::__construct($builder);
+    }
+
+    public function getShardKeys(): array {
+        return $this->getKeyValues($this->shardKeys);
+    }
+
+    public function getPrimaryKeys(): array {
+        return $this->getKeyValues($this->primaryKeys);
+    }
+
+    private function getKeyValues(array $keys): array {
+        $values = [];
+        foreach ($keys as $key) {
+            $values = array_merge($values, $this->getKeyValue($key));
+        }
+        return array_values(array_unique($values));
+    }
+
+    private function getKeyValue($value): array {
+        if ($value instanceof Parameter) {
+            $value = (string)$value;
+        }
+        if (is_string($value) && str_starts_with($value, ':')) {
+            $param = $this->getParameter(substr($value, 1));
+            if (is_array($param)) {
+                return $param;
+            } else {
+                return [$param];
+            }
+        } elseif ($value !== null) {
+            return [$value];
+        } else {
+            return [];
+        }
+    }
+
+    public function where(...$predicates) {
+        return $this->andWhere(...$predicates);
+    }
+
+    public function andWhere(...$where) {
+        if ($where) {
+            foreach ($where as $predicate) {
+                $this->tryLoadShardKey($predicate);
+            }
+            parent::andWhere(...$where);
+        }
+        return $this;
+    }
+
+    private function tryLoadShardKey($predicate): void {
+        if (!$this->shardDefinition) {
+            return;
+        }
+        if ($keys = $this->tryExtractShardKeys($predicate, $this->shardDefinition->shardKey)) {
+            $this->shardKeys += $keys;
+        }
+        if ($keys = $this->tryExtractShardKeys($predicate, $this->shardDefinition->primaryKey)) {
+            $this->primaryKeys += $keys;
+        }
+        foreach ($this->shardDefinition->companionKeys as $companionKey) {
+            if ($keys = $this->tryExtractShardKeys($predicate, $companionKey)) {
+                $this->primaryKeys += $keys;
+            }
+        }
+    }
+
+    /**
+     * @param $predicate
+     * @param string $column
+     * @return string[]
+     */
+    private function tryExtractShardKeys($predicate, string $column): array {
+        if ($predicate instanceof CompositeExpression) {
+            $values = [];
+            foreach ($predicate->getParts() as $part) {
+                $partValues = $this->tryExtractShardKeys($part, $column);
+                // for OR expressions, we can only rely on the predicate if all parts contain the comparison
+                if ($predicate->getType() === CompositeExpression::TYPE_OR && !$partValues) {
+                    return [];
+                }
+                $values = array_merge($values, $partValues);
+            }
+            return $values;
+        }
+        $predicate = (string)$predicate;
+        // expect a condition in the form of 'alias1.column1 = placeholder' or 'alias1.column1 in placeholder'
+        if (substr_count($predicate, ' ') > 2) {
+            return [];
+        }
+        if (str_contains($predicate, ' = ')) {
+            $parts = explode(' = ', $predicate);
+            if ($parts[0] === "`{$column}`" || str_ends_with($parts[0], "`.`{$column}`")) {
+                return [$parts[1]];
+            } else {
+                return [];
+            }
+        }
+
+        if (str_contains($predicate, ' IN ')) {
+            $parts = explode(' IN ', $predicate);
+            if ($parts[0] === "`{$column}`" || str_ends_with($parts[0], "`.`{$column}`")) {
+                return [trim(trim($parts[1], '('), ')')];
+            } else {
+                return [];
+            }
+        }
+
+        return [];
+    }
+
+    public function set($key, $value) {
+        if ($this->shardDefinition && $key === $this->shardDefinition->shardKey) {
+            $updateShardKey = $value;
+        }
+        return parent::set($key, $value);
+    }
+
+    public function setValue($column, $value) {
+        if ($this->shardDefinition) {
+            if ($this->shardDefinition->isKey($column)) {
+                $this->primaryKeys[] = $value;
+            }
+            if ($column === $this->shardDefinition->shardKey) {
+                $this->shardKeys[] = $value;
+            }
+        }
+        return parent::setValue($column, $value);
+    }
+
+    public function values(array $values) {
+        foreach ($values as $column => $value) {
+            $this->setValue($column, $value);
+        }
+        return $this;
+    }
+
+    private function actOnTable(string $table): void {
+        $this->mainTable = $table;
+        foreach ($this->shardDefinitions as $shardDefinition) {
+            if ($shardDefinition->hasTable($table)) {
+                $this->shardDefinition = $shardDefinition;
+            }
+        }
+    }
+
+    public function from($from, $alias = null) {
+        if (is_string($from) && $from) {
+            $this->actOnTable($from);
+        }
+        return parent::from($from, $alias);
+    }
+
+    public function update($update = null, $alias = null) {
+        if (is_string($update) && $update) {
+            $this->actOnTable($update);
+        }
+        return parent::update($update, $alias);
+    }
+
+    public function insert($insert = null) {
+        if (is_string($insert) && $insert) {
+            $this->insertTable = $insert;
+            $this->actOnTable($insert);
+        }
+        return parent::insert($insert);
+    }
+
+    public function delete($delete = null, $alias = null) {
+        if (is_string($delete) && $delete) {
+            $this->actOnTable($delete);
+        }
+        return parent::delete($delete, $alias);
+    }
+
+    private function checkJoin(string $table): void {
+        if ($this->shardDefinition) {
+            if ($table === $this->mainTable) {
+                throw new InvalidShardedQueryException("Sharded query on {$this->mainTable} isn't allowed to join on itself");
+            }
+            if (!$this->shardDefinition->hasTable($table)) {
+                // this generally shouldn't happen as the partitioning logic should prevent this
+                // but the check is here just in case
+                throw new InvalidShardedQueryException("Sharded query on {$this->shardDefinition->table} isn't allowed to join on $table");
+            }
+        }
+    }
+
+    public function innerJoin($fromAlias, $join, $alias, $condition = null) {
+        if (is_string($join)) {
+            $this->checkJoin($join);
+        }
+        return parent::innerJoin($fromAlias, $join, $alias, $condition);
+    }
+
+    public function leftJoin($fromAlias, $join, $alias, $condition = null) {
+        if (is_string($join)) {
+            $this->checkJoin($join);
+        }
+        return parent::leftJoin($fromAlias, $join, $alias, $condition);
+    }
+
+    public function rightJoin($fromAlias, $join, $alias, $condition = null) {
+        if ($this->shardDefinition) {
+            throw new InvalidShardedQueryException("Sharded query on {$this->shardDefinition->table} isn't allowed to right join");
+        }
+        return parent::rightJoin($fromAlias, $join, $alias, $condition);
+    }
+
+    public function join($fromAlias, $join, $alias, $condition = null) {
+        return $this->innerJoin($fromAlias, $join, $alias, $condition);
+    }
+
+    public function setMaxResults($maxResults) {
+        if ($maxResults > 0) {
+            $this->limit = (int)$maxResults;
+        }
+        return parent::setMaxResults($maxResults);
+    }
+
+    public function setFirstResult($firstResult) {
+        if ($firstResult > 0) {
+            $this->offset = (int)$firstResult;
+        }
+        if ($this->shardDefinition && count($this->shardDefinition->shards) > 1) {
+            // we have to emulate offset
+            return $this;
+        } else {
+            return parent::setFirstResult($firstResult);
+        }
+    }
+
+    public function addOrderBy($sort, $order = null) {
+        $this->registerOrder((string)$sort, (string)$order ?? 'ASC');
+        return parent::addOrderBy($sort, $order);
+    }
+
+    public function orderBy($sort, $order = null) {
+        $this->sortList = [];
+        $this->registerOrder((string)$sort, (string)$order ?? 'ASC');
+        return parent::orderBy($sort, $order);
+    }
+
+    private function registerOrder(string $column, string $order): void {
+        // handle `mime + 0` and similar by just sorting on the first part of the expression
+        [$column] = explode(' ', $column);
+        $column = trim($column, '`');
+        $this->sortList[] = [
+            'column' => $column,
+            'order' => strtoupper($order),
+        ];
+    }
+
+    public function hintShardKey(string $column, mixed $value, bool $overwrite = false): self {
+        if ($overwrite) {
+            $this->primaryKeys = [];
+            $this->shardKeys = [];
+        }
+        if ($this->shardDefinition?->isKey($column)) {
+            $this->primaryKeys[] = $value;
+        }
+        if ($column === $this->shardDefinition?->shardKey) {
+            $this->shardKeys[] = $value;
+        }
+        return $this;
+    }
+
+    public function runAcrossAllShards(): self {
+        $this->allShards = true;
+        return $this;
+    }
+
+    /**
+     * @throws InvalidShardedQueryException
+     */
+    public function validate(): void {
+        if ($this->shardDefinition && $this->insertTable) {
+            if ($this->allShards) {
+                throw new InvalidShardedQueryException("Can't insert across all shards");
+            }
+            if (empty($this->getShardKeys())) {
+                throw new InvalidShardedQueryException("Can't insert without shard key");
+            }
+        }
+        if ($this->shardDefinition && !$this->allShards) {
+            if (empty($this->getShardKeys()) && empty($this->getPrimaryKeys())) {
+                throw new InvalidShardedQueryException('No shard key or primary key set for query');
+            }
+        }
+        if ($this->shardDefinition && $this->updateShardKey) {
+            $newShardKey = $this->getKeyValue($this->updateShardKey);
+            $oldShardKeys = $this->getShardKeys();
+            if (count($newShardKey) !== 1) {
+                throw new InvalidShardedQueryException("Can't set shard key to an array");
+            }
+            $newShardKey = current($newShardKey);
+            if (empty($oldShardKeys)) {
+                throw new InvalidShardedQueryException("Can't update without shard key");
+            }
+            $oldShards = array_values(array_unique(array_map(function ($shardKey) {
+                return $this->shardDefinition->getShardForKey((int)$shardKey);
+            }, $oldShardKeys)));
+            $newShard = $this->shardDefinition->getShardForKey((int)$newShardKey);
+            if ($oldShards === [$newShard]) {
+                throw new InvalidShardedQueryException('Update statement would move rows to a different shard');
+            }
+        }
+    }
+
+    public function executeQuery(?IDBConnection $connection = null): IResult {
+        $this->validate();
+        if ($this->shardDefinition) {
+            $runner = new ShardQueryRunner($this->shardConnectionManager, $this->shardDefinition);
+            return $runner->executeQuery($this->builder, $this->allShards, $this->getShardKeys(), $this->getPrimaryKeys(), $this->sortList, $this->limit, $this->offset);
+        }
+        return parent::executeQuery($connection);
+    }
+
+    public function executeStatement(?IDBConnection $connection = null): int {
+        $this->validate();
+        if ($this->shardDefinition) {
+            $runner = new ShardQueryRunner($this->shardConnectionManager, $this->shardDefinition);
+            if ($this->insertTable) {
+                $shards = $runner->getShards($this->allShards, $this->getShardKeys());
+                if (!$shards) {
+                    throw new InvalidShardedQueryException("Can't insert without shard key");
+                }
+                $count = 0;
+                foreach ($shards as $shard) {
+                    $shardConnection = $this->shardConnectionManager->getConnection($this->shardDefinition, $shard);
+                    if (!$this->primaryKeys && $this->shardDefinition->table === $this->insertTable) {
+                        $id = $this->autoIncrementHandler->getNextPrimaryKey($this->shardDefinition, $shard);
+                        parent::setValue($this->shardDefinition->primaryKey, $this->createParameter('__generated_primary_key'));
+                        $this->setParameter('__generated_primary_key', $id, self::PARAM_INT);
+                        $this->lastInsertId = $id;
+                    }
+                    $count += parent::executeStatement($shardConnection);
+
+                    $this->lastInsertConnection = $shardConnection;
+                }
+                return $count;
+            } else {
+                return $runner->executeStatement($this->builder, $this->allShards, $this->getShardKeys(), $this->getPrimaryKeys());
+            }
+        }
+        return parent::executeStatement($connection);
+    }
+
+    public function getLastInsertId(): int {
+        if ($this->lastInsertId) {
+            return $this->lastInsertId;
+        }
+        if ($this->lastInsertConnection) {
+            $table = $this->builder->prefixTableName($this->insertTable);
+            return $this->lastInsertConnection->lastInsertId($table);
+        } else {
+            return parent::getLastInsertId();
+        }
+    }
 
 
 }

lib/private/DB/QueryBuilder/Partitioned/PartitionedQueryBuilder.php

Indentation +431 added lines, -431 removed lines

@@ -36,435 +36,435 @@
  * [1]: A set of tables which can't be queried together with the rest of the tables, such as when sharding is used.
  */
 class PartitionedQueryBuilder extends ShardedQueryBuilder {
-	/** @var array<string, PartitionQuery> $splitQueries */
-	private array $splitQueries = [];
-	/** @var list<PartitionSplit> */
-	private array $partitions = [];
-
-	/** @var array{'select': string|array, 'alias': ?string}[] */
-	private array $selects = [];
-	private ?PartitionSplit $mainPartition = null;
-	private bool $hasPositionalParameter = false;
-	private QuoteHelper $quoteHelper;
-	private ?int $limit = null;
-	private ?int $offset = null;
-
-	public function __construct(
-		IQueryBuilder $builder,
-		array $shardDefinitions,
-		ShardConnectionManager $shardConnectionManager,
-		AutoIncrementHandler $autoIncrementHandler,
-	) {
-		parent::__construct($builder, $shardDefinitions, $shardConnectionManager, $autoIncrementHandler);
-		$this->quoteHelper = new QuoteHelper();
-	}
-
-	private function newQuery(): IQueryBuilder {
-		// get a fresh, non-partitioning query builder
-		$builder = $this->builder->getConnection()->getQueryBuilder();
-		if ($builder instanceof PartitionedQueryBuilder) {
-			$builder = $builder->builder;
-		}
-
-		return new ShardedQueryBuilder(
-			$builder,
-			$this->shardDefinitions,
-			$this->shardConnectionManager,
-			$this->autoIncrementHandler,
-		);
-	}
-
-	// we need to save selects until we know all the table aliases
-	public function select(...$selects) {
-		if (count($selects) === 1 && is_array($selects[0])) {
-			$selects = $selects[0];
-		}
-		$this->selects = [];
-		$this->addSelect(...$selects);
-		return $this;
-	}
-
-	public function addSelect(...$select) {
-		$select = array_map(function ($select) {
-			return ['select' => $select, 'alias' => null];
-		}, $select);
-		$this->selects = array_merge($this->selects, $select);
-		return $this;
-	}
-
-	public function selectAlias($select, $alias) {
-		$this->selects[] = ['select' => $select, 'alias' => $alias];
-		return $this;
-	}
-
-	/**
-	 * Ensure that a column is being selected by the query
-	 *
-	 * This is mainly used to ensure that the returned rows from both sides of a partition contains the columns of the join predicate
-	 *
-	 * @param string|IQueryFunction $column
-	 * @return void
-	 */
-	private function ensureSelect(string|IQueryFunction $column, ?string $alias = null): void {
-		$checkColumn = $alias ?: $column;
-		if (str_contains($checkColumn, '.')) {
-			[$table, $checkColumn] = explode('.', $checkColumn);
-			$partition = $this->getPartition($table);
-		} else {
-			$partition = null;
-		}
-		foreach ($this->selects as $select) {
-			$select = $select['select'];
-			if (!is_string($select)) {
-				continue;
-			}
-
-			if (str_contains($select, '.')) {
-				[$table, $select] = explode('.', $select);
-				$selectPartition = $this->getPartition($table);
-			} else {
-				$selectPartition = null;
-			}
-			if (
-				($select === $checkColumn || $select === '*')
-				&& $selectPartition === $partition
-			) {
-				return;
-			}
-		}
-		if ($alias) {
-			$this->selectAlias($column, $alias);
-		} else {
-			$this->addSelect($column);
-		}
-	}
-
-	/**
-	 * Distribute the select statements to the correct partition
-	 *
-	 * This is done at the end instead of when the `select` call is made, because the `select` calls are generally done
-	 * before we know what tables are involved in the query
-	 *
-	 * @return void
-	 */
-	private function applySelects(): void {
-		foreach ($this->selects as $select) {
-			foreach ($this->partitions as $partition) {
-				if (is_string($select['select']) && (
-					$select['select'] === '*'
-					|| $partition->isColumnInPartition($select['select']))
-				) {
-					if (isset($this->splitQueries[$partition->name])) {
-						if ($select['alias']) {
-							$this->splitQueries[$partition->name]->query->selectAlias($select['select'], $select['alias']);
-						} else {
-							$this->splitQueries[$partition->name]->query->addSelect($select['select']);
-						}
-						if ($select['select'] !== '*') {
-							continue 2;
-						}
-					}
-				}
-			}
-
-			if ($select['alias']) {
-				parent::selectAlias($select['select'], $select['alias']);
-			} else {
-				parent::addSelect($select['select']);
-			}
-		}
-		$this->selects = [];
-	}
-
-
-	public function addPartition(PartitionSplit $partition): void {
-		$this->partitions[] = $partition;
-	}
-
-	private function getPartition(string $table): ?PartitionSplit {
-		foreach ($this->partitions as $partition) {
-			if ($partition->containsTable($table) || $partition->containsAlias($table)) {
-				return $partition;
-			}
-		}
-		return null;
-	}
-
-	public function from($from, $alias = null) {
-		if (is_string($from) && $partition = $this->getPartition($from)) {
-			$this->mainPartition = $partition;
-			if ($alias) {
-				$this->mainPartition->addAlias($from, $alias);
-			}
-		}
-		return parent::from($from, $alias);
-	}
-
-	public function innerJoin($fromAlias, $join, $alias, $condition = null): self {
-		return $this->join($fromAlias, $join, $alias, $condition);
-	}
-
-	public function leftJoin($fromAlias, $join, $alias, $condition = null): self {
-		return $this->join($fromAlias, $join, $alias, $condition, PartitionQuery::JOIN_MODE_LEFT);
-	}
-
-	public function join($fromAlias, $join, $alias, $condition = null, $joinMode = PartitionQuery::JOIN_MODE_INNER): self {
-		if ($join instanceof IQueryFunction) {
-			$partition = null;
-			$fromPartition = null;
-		} else {
-			$partition = $this->getPartition($join);
-			$fromPartition = $this->getPartition($fromAlias);
-		}
-
-		if ($partition && $partition !== $this->mainPartition) {
-			/** @var string $join */
-			// join from the main db to a partition
-
-			$joinCondition = JoinCondition::parse($condition, $join, $alias, $fromAlias);
-			$partition->addAlias($join, $alias);
-
-			if (!isset($this->splitQueries[$partition->name])) {
-				$this->splitQueries[$partition->name] = new PartitionQuery(
-					$this->newQuery(),
-					$joinCondition->fromAlias ?? $joinCondition->fromColumn, $joinCondition->toAlias ?? $joinCondition->toColumn,
-					$joinMode
-				);
-				$this->splitQueries[$partition->name]->query->from($join, $alias);
-				$this->ensureSelect($joinCondition->fromColumn, $joinCondition->fromAlias);
-				$this->ensureSelect($joinCondition->toColumn, $joinCondition->toAlias);
-			} else {
-				$query = $this->splitQueries[$partition->name]->query;
-				if ($partition->containsAlias($fromAlias)) {
-					$query->innerJoin($fromAlias, $join, $alias, $condition);
-				} else {
-					throw new InvalidPartitionedQueryException("Can't join across partition boundaries more than once");
-				}
-			}
-			$this->splitQueries[$partition->name]->query->andWhere(...$joinCondition->toConditions);
-			parent::andWhere(...$joinCondition->fromConditions);
-			return $this;
-		} elseif ($fromPartition && $fromPartition !== $partition) {
-			/** @var string $join */
-			// join from partition, to the main db
-
-			$joinCondition = JoinCondition::parse($condition, $join, $alias, $fromAlias);
-			if (str_starts_with($fromPartition->name, 'from_')) {
-				$partitionName = $fromPartition->name;
-			} else {
-				$partitionName = 'from_' . $fromPartition->name;
-			}
-
-			if (!isset($this->splitQueries[$partitionName])) {
-				$newPartition = new PartitionSplit($partitionName, [$join]);
-				$newPartition->addAlias($join, $alias);
-				$this->partitions[] = $newPartition;
-
-				$this->splitQueries[$partitionName] = new PartitionQuery(
-					$this->newQuery(),
-					$joinCondition->fromAlias ?? $joinCondition->fromColumn, $joinCondition->toAlias ?? $joinCondition->toColumn,
-					$joinMode
-				);
-				$this->ensureSelect($joinCondition->fromColumn, $joinCondition->fromAlias);
-				$this->ensureSelect($joinCondition->toColumn, $joinCondition->toAlias);
-				$this->splitQueries[$partitionName]->query->from($join, $alias);
-				$this->splitQueries[$partitionName]->query->andWhere(...$joinCondition->toConditions);
-				parent::andWhere(...$joinCondition->fromConditions);
-			} else {
-				$fromPartition->addTable($join);
-				$fromPartition->addAlias($join, $alias);
-
-				$query = $this->splitQueries[$partitionName]->query;
-				$query->innerJoin($fromAlias, $join, $alias, $condition);
-			}
-			return $this;
-		} else {
-			// join within the main db or a partition
-			if ($joinMode === PartitionQuery::JOIN_MODE_INNER) {
-				return parent::innerJoin($fromAlias, $join, $alias, $condition);
-			} elseif ($joinMode === PartitionQuery::JOIN_MODE_LEFT) {
-				return parent::leftJoin($fromAlias, $join, $alias, $condition);
-			} elseif ($joinMode === PartitionQuery::JOIN_MODE_RIGHT) {
-				return parent::rightJoin($fromAlias, $join, $alias, $condition);
-			} else {
-				throw new \InvalidArgumentException("Invalid join mode: $joinMode");
-			}
-		}
-	}
-
-	/**
-	 * Flatten a list of predicates by merging the parts of any "AND" expression into the list of predicates
-	 *
-	 * @param array $predicates
-	 * @return array
-	 */
-	private function flattenPredicates(array $predicates): array {
-		$result = [];
-		foreach ($predicates as $predicate) {
-			if ($predicate instanceof CompositeExpression && $predicate->getType() === CompositeExpression::TYPE_AND) {
-				$result = array_merge($result, $this->flattenPredicates($predicate->getParts()));
-			} else {
-				$result[] = $predicate;
-			}
-		}
-		return $result;
-	}
-
-	/**
-	 * Split an array of predicates (WHERE query parts) by the partition they reference
-	 *
-	 * @param array $predicates
-	 * @return array<string, array>
-	 */
-	private function splitPredicatesByParts(array $predicates): array {
-		$predicates = $this->flattenPredicates($predicates);
-
-		$partitionPredicates = [];
-		foreach ($predicates as $predicate) {
-			$partition = $this->getPartitionForPredicate((string)$predicate);
-			if ($this->mainPartition === $partition) {
-				$partitionPredicates[''][] = $predicate;
-			} elseif ($partition) {
-				$partitionPredicates[$partition->name][] = $predicate;
-			} else {
-				$partitionPredicates[''][] = $predicate;
-			}
-		}
-		return $partitionPredicates;
-	}
-
-	public function where(...$predicates) {
-		return $this->andWhere(...$predicates);
-	}
-
-	public function andWhere(...$where) {
-		if ($where) {
-			foreach ($this->splitPredicatesByParts($where) as $alias => $predicates) {
-				if (isset($this->splitQueries[$alias])) {
-					// when there is a condition on a table being left-joined it starts to behave as if it's an inner join
-					// since any joined column that doesn't have the left part will not match the condition
-					// when there the condition is `$joinToColumn IS NULL` we instead mark the query as excluding the left half
-					if ($this->splitQueries[$alias]->joinMode === PartitionQuery::JOIN_MODE_LEFT) {
-						$this->splitQueries[$alias]->joinMode = PartitionQuery::JOIN_MODE_INNER;
-
-						$column = $this->quoteHelper->quoteColumnName($this->splitQueries[$alias]->joinToColumn);
-						foreach ($predicates as $predicate) {
-							if ((string)$predicate === "$column IS NULL") {
-								$this->splitQueries[$alias]->joinMode = PartitionQuery::JOIN_MODE_LEFT_NULL;
-							} else {
-								$this->splitQueries[$alias]->query->andWhere($predicate);
-							}
-						}
-					} else {
-						$this->splitQueries[$alias]->query->andWhere(...$predicates);
-					}
-				} else {
-					parent::andWhere(...$predicates);
-				}
-			}
-		}
-		return $this;
-	}
-
-
-	private function getPartitionForPredicate(string $predicate): ?PartitionSplit {
-		foreach ($this->partitions as $partition) {
-
-			if (str_contains($predicate, '?')) {
-				$this->hasPositionalParameter = true;
-			}
-			if ($partition->checkPredicateForTable($predicate)) {
-				return $partition;
-			}
-		}
-		return null;
-	}
-
-	public function update($update = null, $alias = null) {
-		return parent::update($update, $alias);
-	}
-
-	public function insert($insert = null) {
-		return parent::insert($insert);
-	}
-
-	public function delete($delete = null, $alias = null) {
-		return parent::delete($delete, $alias);
-	}
-
-	public function setMaxResults($maxResults) {
-		if ($maxResults > 0) {
-			$this->limit = (int)$maxResults;
-		}
-		return parent::setMaxResults($maxResults);
-	}
-
-	public function setFirstResult($firstResult) {
-		if ($firstResult > 0) {
-			$this->offset = (int)$firstResult;
-		}
-		return parent::setFirstResult($firstResult);
-	}
-
-	public function executeQuery(?IDBConnection $connection = null): IResult {
-		$this->applySelects();
-		if ($this->splitQueries && $this->hasPositionalParameter) {
-			throw new InvalidPartitionedQueryException("Partitioned queries aren't allowed to to positional arguments");
-		}
-		foreach ($this->splitQueries as $split) {
-			$split->query->setParameters($this->getParameters(), $this->getParameterTypes());
-		}
-		if (count($this->splitQueries) > 0) {
-			$hasNonLeftJoins = array_reduce($this->splitQueries, function (bool $hasNonLeftJoins, PartitionQuery $query) {
-				return $hasNonLeftJoins || $query->joinMode !== PartitionQuery::JOIN_MODE_LEFT;
-			}, false);
-			if ($hasNonLeftJoins) {
-				if (is_int($this->limit)) {
-					throw new InvalidPartitionedQueryException('Limit is not allowed in partitioned queries');
-				}
-				if (is_int($this->offset)) {
-					throw new InvalidPartitionedQueryException('Offset is not allowed in partitioned queries');
-				}
-			}
-		}
-
-		$s = $this->getSQL();
-		$result = parent::executeQuery($connection);
-		if (count($this->splitQueries) > 0) {
-			return new PartitionedResult($this->splitQueries, $result);
-		} else {
-			return $result;
-		}
-	}
-
-	public function executeStatement(?IDBConnection $connection = null): int {
-		if (count($this->splitQueries)) {
-			throw new InvalidPartitionedQueryException("Partitioning write queries isn't supported");
-		}
-		return parent::executeStatement($connection);
-	}
-
-	public function getSQL() {
-		$this->applySelects();
-		return parent::getSQL();
-	}
-
-	public function getPartitionCount(): int {
-		return count($this->splitQueries) + 1;
-	}
-
-	public function hintShardKey(string $column, mixed $value, bool $overwrite = false): self {
-		if (str_contains($column, '.')) {
-			[$alias, $column] = explode('.', $column);
-			$partition = $this->getPartition($alias);
-			if ($partition) {
-				$this->splitQueries[$partition->name]->query->hintShardKey($column, $value, $overwrite);
-			} else {
-				parent::hintShardKey($column, $value, $overwrite);
-			}
-		} else {
-			parent::hintShardKey($column, $value, $overwrite);
-		}
-		return $this;
-	}
+    /** @var array<string, PartitionQuery> $splitQueries */
+    private array $splitQueries = [];
+    /** @var list<PartitionSplit> */
+    private array $partitions = [];
+
+    /** @var array{'select': string|array, 'alias': ?string}[] */
+    private array $selects = [];
+    private ?PartitionSplit $mainPartition = null;
+    private bool $hasPositionalParameter = false;
+    private QuoteHelper $quoteHelper;
+    private ?int $limit = null;
+    private ?int $offset = null;
+
+    public function __construct(
+        IQueryBuilder $builder,
+        array $shardDefinitions,
+        ShardConnectionManager $shardConnectionManager,
+        AutoIncrementHandler $autoIncrementHandler,
+    ) {
+        parent::__construct($builder, $shardDefinitions, $shardConnectionManager, $autoIncrementHandler);
+        $this->quoteHelper = new QuoteHelper();
+    }
+
+    private function newQuery(): IQueryBuilder {
+        // get a fresh, non-partitioning query builder
+        $builder = $this->builder->getConnection()->getQueryBuilder();
+        if ($builder instanceof PartitionedQueryBuilder) {
+            $builder = $builder->builder;
+        }
+
+        return new ShardedQueryBuilder(
+            $builder,
+            $this->shardDefinitions,
+            $this->shardConnectionManager,
+            $this->autoIncrementHandler,
+        );
+    }
+
+    // we need to save selects until we know all the table aliases
+    public function select(...$selects) {
+        if (count($selects) === 1 && is_array($selects[0])) {
+            $selects = $selects[0];
+        }
+        $this->selects = [];
+        $this->addSelect(...$selects);
+        return $this;
+    }
+
+    public function addSelect(...$select) {
+        $select = array_map(function ($select) {
+            return ['select' => $select, 'alias' => null];
+        }, $select);
+        $this->selects = array_merge($this->selects, $select);
+        return $this;
+    }
+
+    public function selectAlias($select, $alias) {
+        $this->selects[] = ['select' => $select, 'alias' => $alias];
+        return $this;
+    }
+
+    /**
+     * Ensure that a column is being selected by the query
+     *
+     * This is mainly used to ensure that the returned rows from both sides of a partition contains the columns of the join predicate
+     *
+     * @param string|IQueryFunction $column
+     * @return void
+     */
+    private function ensureSelect(string|IQueryFunction $column, ?string $alias = null): void {
+        $checkColumn = $alias ?: $column;
+        if (str_contains($checkColumn, '.')) {
+            [$table, $checkColumn] = explode('.', $checkColumn);
+            $partition = $this->getPartition($table);
+        } else {
+            $partition = null;
+        }
+        foreach ($this->selects as $select) {
+            $select = $select['select'];
+            if (!is_string($select)) {
+                continue;
+            }
+
+            if (str_contains($select, '.')) {
+                [$table, $select] = explode('.', $select);
+                $selectPartition = $this->getPartition($table);
+            } else {
+                $selectPartition = null;
+            }
+            if (
+                ($select === $checkColumn || $select === '*')
+                && $selectPartition === $partition
+            ) {
+                return;
+            }
+        }
+        if ($alias) {
+            $this->selectAlias($column, $alias);
+        } else {
+            $this->addSelect($column);
+        }
+    }
+
+    /**
+     * Distribute the select statements to the correct partition
+     *
+     * This is done at the end instead of when the `select` call is made, because the `select` calls are generally done
+     * before we know what tables are involved in the query
+     *
+     * @return void
+     */
+    private function applySelects(): void {
+        foreach ($this->selects as $select) {
+            foreach ($this->partitions as $partition) {
+                if (is_string($select['select']) && (
+                    $select['select'] === '*'
+                    || $partition->isColumnInPartition($select['select']))
+                ) {
+                    if (isset($this->splitQueries[$partition->name])) {
+                        if ($select['alias']) {
+                            $this->splitQueries[$partition->name]->query->selectAlias($select['select'], $select['alias']);
+                        } else {
+                            $this->splitQueries[$partition->name]->query->addSelect($select['select']);
+                        }
+                        if ($select['select'] !== '*') {
+                            continue 2;
+                        }
+                    }
+                }
+            }
+
+            if ($select['alias']) {
+                parent::selectAlias($select['select'], $select['alias']);
+            } else {
+                parent::addSelect($select['select']);
+            }
+        }
+        $this->selects = [];
+    }
+
+
+    public function addPartition(PartitionSplit $partition): void {
+        $this->partitions[] = $partition;
+    }
+
+    private function getPartition(string $table): ?PartitionSplit {
+        foreach ($this->partitions as $partition) {
+            if ($partition->containsTable($table) || $partition->containsAlias($table)) {
+                return $partition;
+            }
+        }
+        return null;
+    }
+
+    public function from($from, $alias = null) {
+        if (is_string($from) && $partition = $this->getPartition($from)) {
+            $this->mainPartition = $partition;
+            if ($alias) {
+                $this->mainPartition->addAlias($from, $alias);
+            }
+        }
+        return parent::from($from, $alias);
+    }
+
+    public function innerJoin($fromAlias, $join, $alias, $condition = null): self {
+        return $this->join($fromAlias, $join, $alias, $condition);
+    }
+
+    public function leftJoin($fromAlias, $join, $alias, $condition = null): self {
+        return $this->join($fromAlias, $join, $alias, $condition, PartitionQuery::JOIN_MODE_LEFT);
+    }
+
+    public function join($fromAlias, $join, $alias, $condition = null, $joinMode = PartitionQuery::JOIN_MODE_INNER): self {
+        if ($join instanceof IQueryFunction) {
+            $partition = null;
+            $fromPartition = null;
+        } else {
+            $partition = $this->getPartition($join);
+            $fromPartition = $this->getPartition($fromAlias);
+        }
+
+        if ($partition && $partition !== $this->mainPartition) {
+            /** @var string $join */
+            // join from the main db to a partition
+
+            $joinCondition = JoinCondition::parse($condition, $join, $alias, $fromAlias);
+            $partition->addAlias($join, $alias);
+
+            if (!isset($this->splitQueries[$partition->name])) {
+                $this->splitQueries[$partition->name] = new PartitionQuery(
+                    $this->newQuery(),
+                    $joinCondition->fromAlias ?? $joinCondition->fromColumn, $joinCondition->toAlias ?? $joinCondition->toColumn,
+                    $joinMode
+                );
+                $this->splitQueries[$partition->name]->query->from($join, $alias);
+                $this->ensureSelect($joinCondition->fromColumn, $joinCondition->fromAlias);
+                $this->ensureSelect($joinCondition->toColumn, $joinCondition->toAlias);
+            } else {
+                $query = $this->splitQueries[$partition->name]->query;
+                if ($partition->containsAlias($fromAlias)) {
+                    $query->innerJoin($fromAlias, $join, $alias, $condition);
+                } else {
+                    throw new InvalidPartitionedQueryException("Can't join across partition boundaries more than once");
+                }
+            }
+            $this->splitQueries[$partition->name]->query->andWhere(...$joinCondition->toConditions);
+            parent::andWhere(...$joinCondition->fromConditions);
+            return $this;
+        } elseif ($fromPartition && $fromPartition !== $partition) {
+            /** @var string $join */
+            // join from partition, to the main db
+
+            $joinCondition = JoinCondition::parse($condition, $join, $alias, $fromAlias);
+            if (str_starts_with($fromPartition->name, 'from_')) {
+                $partitionName = $fromPartition->name;
+            } else {
+                $partitionName = 'from_' . $fromPartition->name;
+            }
+
+            if (!isset($this->splitQueries[$partitionName])) {
+                $newPartition = new PartitionSplit($partitionName, [$join]);
+                $newPartition->addAlias($join, $alias);
+                $this->partitions[] = $newPartition;
+
+                $this->splitQueries[$partitionName] = new PartitionQuery(
+                    $this->newQuery(),
+                    $joinCondition->fromAlias ?? $joinCondition->fromColumn, $joinCondition->toAlias ?? $joinCondition->toColumn,
+                    $joinMode
+                );
+                $this->ensureSelect($joinCondition->fromColumn, $joinCondition->fromAlias);
+                $this->ensureSelect($joinCondition->toColumn, $joinCondition->toAlias);
+                $this->splitQueries[$partitionName]->query->from($join, $alias);
+                $this->splitQueries[$partitionName]->query->andWhere(...$joinCondition->toConditions);
+                parent::andWhere(...$joinCondition->fromConditions);
+            } else {
+                $fromPartition->addTable($join);
+                $fromPartition->addAlias($join, $alias);
+
+                $query = $this->splitQueries[$partitionName]->query;
+                $query->innerJoin($fromAlias, $join, $alias, $condition);
+            }
+            return $this;
+        } else {
+            // join within the main db or a partition
+            if ($joinMode === PartitionQuery::JOIN_MODE_INNER) {
+                return parent::innerJoin($fromAlias, $join, $alias, $condition);
+            } elseif ($joinMode === PartitionQuery::JOIN_MODE_LEFT) {
+                return parent::leftJoin($fromAlias, $join, $alias, $condition);
+            } elseif ($joinMode === PartitionQuery::JOIN_MODE_RIGHT) {
+                return parent::rightJoin($fromAlias, $join, $alias, $condition);
+            } else {
+                throw new \InvalidArgumentException("Invalid join mode: $joinMode");
+            }
+        }
+    }
+
+    /**
+     * Flatten a list of predicates by merging the parts of any "AND" expression into the list of predicates
+     *
+     * @param array $predicates
+     * @return array
+     */
+    private function flattenPredicates(array $predicates): array {
+        $result = [];
+        foreach ($predicates as $predicate) {
+            if ($predicate instanceof CompositeExpression && $predicate->getType() === CompositeExpression::TYPE_AND) {
+                $result = array_merge($result, $this->flattenPredicates($predicate->getParts()));
+            } else {
+                $result[] = $predicate;
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * Split an array of predicates (WHERE query parts) by the partition they reference
+     *
+     * @param array $predicates
+     * @return array<string, array>
+     */
+    private function splitPredicatesByParts(array $predicates): array {
+        $predicates = $this->flattenPredicates($predicates);
+
+        $partitionPredicates = [];
+        foreach ($predicates as $predicate) {
+            $partition = $this->getPartitionForPredicate((string)$predicate);
+            if ($this->mainPartition === $partition) {
+                $partitionPredicates[''][] = $predicate;
+            } elseif ($partition) {
+                $partitionPredicates[$partition->name][] = $predicate;
+            } else {
+                $partitionPredicates[''][] = $predicate;
+            }
+        }
+        return $partitionPredicates;
+    }
+
+    public function where(...$predicates) {
+        return $this->andWhere(...$predicates);
+    }
+
+    public function andWhere(...$where) {
+        if ($where) {
+            foreach ($this->splitPredicatesByParts($where) as $alias => $predicates) {
+                if (isset($this->splitQueries[$alias])) {
+                    // when there is a condition on a table being left-joined it starts to behave as if it's an inner join
+                    // since any joined column that doesn't have the left part will not match the condition
+                    // when there the condition is `$joinToColumn IS NULL` we instead mark the query as excluding the left half
+                    if ($this->splitQueries[$alias]->joinMode === PartitionQuery::JOIN_MODE_LEFT) {
+                        $this->splitQueries[$alias]->joinMode = PartitionQuery::JOIN_MODE_INNER;
+
+                        $column = $this->quoteHelper->quoteColumnName($this->splitQueries[$alias]->joinToColumn);
+                        foreach ($predicates as $predicate) {
+                            if ((string)$predicate === "$column IS NULL") {
+                                $this->splitQueries[$alias]->joinMode = PartitionQuery::JOIN_MODE_LEFT_NULL;
+                            } else {
+                                $this->splitQueries[$alias]->query->andWhere($predicate);
+                            }
+                        }
+                    } else {
+                        $this->splitQueries[$alias]->query->andWhere(...$predicates);
+                    }
+                } else {
+                    parent::andWhere(...$predicates);
+                }
+            }
+        }
+        return $this;
+    }
+
+
+    private function getPartitionForPredicate(string $predicate): ?PartitionSplit {
+        foreach ($this->partitions as $partition) {
+
+            if (str_contains($predicate, '?')) {
+                $this->hasPositionalParameter = true;
+            }
+            if ($partition->checkPredicateForTable($predicate)) {
+                return $partition;
+            }
+        }
+        return null;
+    }
+
+    public function update($update = null, $alias = null) {
+        return parent::update($update, $alias);
+    }
+
+    public function insert($insert = null) {
+        return parent::insert($insert);
+    }
+
+    public function delete($delete = null, $alias = null) {
+        return parent::delete($delete, $alias);
+    }
+
+    public function setMaxResults($maxResults) {
+        if ($maxResults > 0) {
+            $this->limit = (int)$maxResults;
+        }
+        return parent::setMaxResults($maxResults);
+    }
+
+    public function setFirstResult($firstResult) {
+        if ($firstResult > 0) {
+            $this->offset = (int)$firstResult;
+        }
+        return parent::setFirstResult($firstResult);
+    }
+
+    public function executeQuery(?IDBConnection $connection = null): IResult {
+        $this->applySelects();
+        if ($this->splitQueries && $this->hasPositionalParameter) {
+            throw new InvalidPartitionedQueryException("Partitioned queries aren't allowed to to positional arguments");
+        }
+        foreach ($this->splitQueries as $split) {
+            $split->query->setParameters($this->getParameters(), $this->getParameterTypes());
+        }
+        if (count($this->splitQueries) > 0) {
+            $hasNonLeftJoins = array_reduce($this->splitQueries, function (bool $hasNonLeftJoins, PartitionQuery $query) {
+                return $hasNonLeftJoins || $query->joinMode !== PartitionQuery::JOIN_MODE_LEFT;
+            }, false);
+            if ($hasNonLeftJoins) {
+                if (is_int($this->limit)) {
+                    throw new InvalidPartitionedQueryException('Limit is not allowed in partitioned queries');
+                }
+                if (is_int($this->offset)) {
+                    throw new InvalidPartitionedQueryException('Offset is not allowed in partitioned queries');
+                }
+            }
+        }
+
+        $s = $this->getSQL();
+        $result = parent::executeQuery($connection);
+        if (count($this->splitQueries) > 0) {
+            return new PartitionedResult($this->splitQueries, $result);
+        } else {
+            return $result;
+        }
+    }
+
+    public function executeStatement(?IDBConnection $connection = null): int {
+        if (count($this->splitQueries)) {
+            throw new InvalidPartitionedQueryException("Partitioning write queries isn't supported");
+        }
+        return parent::executeStatement($connection);
+    }
+
+    public function getSQL() {
+        $this->applySelects();
+        return parent::getSQL();
+    }
+
+    public function getPartitionCount(): int {
+        return count($this->splitQueries) + 1;
+    }
+
+    public function hintShardKey(string $column, mixed $value, bool $overwrite = false): self {
+        if (str_contains($column, '.')) {
+            [$alias, $column] = explode('.', $column);
+            $partition = $this->getPartition($alias);
+            if ($partition) {
+                $this->splitQueries[$partition->name]->query->hintShardKey($column, $value, $overwrite);
+            } else {
+                parent::hintShardKey($column, $value, $overwrite);
+            }
+        } else {
+            parent::hintShardKey($column, $value, $overwrite);
+        }
+        return $this;
+    }
 }

Spacing +8 added lines, -8 removed lines

@@ -85,7 +85,7 @@ 
 	}
 
 	public function addSelect(...$select) {
-		$select = array_map(function ($select) {
+		$select = array_map(function($select) {
 			return ['select' => $select, 'alias' => null];
 		}, $select);
 		$this->selects = array_merge($this->selects, $select);
@@ -105,7 +105,7 @@ 
 	 * @param string|IQueryFunction $column
 	 * @return void
 	 */
-	private function ensureSelect(string|IQueryFunction $column, ?string $alias = null): void {
+	private function ensureSelect(string | IQueryFunction $column, ?string $alias = null): void {
 		$checkColumn = $alias ?: $column;
 		if (str_contains($checkColumn, '.')) {
 			[$table, $checkColumn] = explode('.', $checkColumn);
@@ -252,7 +252,7 @@ 
 			if (str_starts_with($fromPartition->name, 'from_')) {
 				$partitionName = $fromPartition->name;
 			} else {
-				$partitionName = 'from_' . $fromPartition->name;
+				$partitionName = 'from_'.$fromPartition->name;
 			}
 
 			if (!isset($this->splitQueries[$partitionName])) {
@@ -321,7 +321,7 @@ 
 
 		$partitionPredicates = [];
 		foreach ($predicates as $predicate) {
-			$partition = $this->getPartitionForPredicate((string)$predicate);
+			$partition = $this->getPartitionForPredicate((string) $predicate);
 			if ($this->mainPartition === $partition) {
 				$partitionPredicates[''][] = $predicate;
 			} elseif ($partition) {
@@ -349,7 +349,7 @@ 
 
 						$column = $this->quoteHelper->quoteColumnName($this->splitQueries[$alias]->joinToColumn);
 						foreach ($predicates as $predicate) {
-							if ((string)$predicate === "$column IS NULL") {
+							if ((string) $predicate === "$column IS NULL") {
 								$this->splitQueries[$alias]->joinMode = PartitionQuery::JOIN_MODE_LEFT_NULL;
 							} else {
 								$this->splitQueries[$alias]->query->andWhere($predicate);
@@ -394,14 +394,14 @@ 
 
 	public function setMaxResults($maxResults) {
 		if ($maxResults > 0) {
-			$this->limit = (int)$maxResults;
+			$this->limit = (int) $maxResults;
 		}
 		return parent::setMaxResults($maxResults);
 	}
 
 	public function setFirstResult($firstResult) {
 		if ($firstResult > 0) {
-			$this->offset = (int)$firstResult;
+			$this->offset = (int) $firstResult;
 		}
 		return parent::setFirstResult($firstResult);
 	}
@@ -415,7 +415,7 @@ 
 			$split->query->setParameters($this->getParameters(), $this->getParameterTypes());
 		}
 		if (count($this->splitQueries) > 0) {
-			$hasNonLeftJoins = array_reduce($this->splitQueries, function (bool $hasNonLeftJoins, PartitionQuery $query) {
+			$hasNonLeftJoins = array_reduce($this->splitQueries, function(bool $hasNonLeftJoins, PartitionQuery $query) {
 				return $hasNonLeftJoins || $query->joinMode !== PartitionQuery::JOIN_MODE_LEFT;
 			}, false);
 			if ($hasNonLeftJoins) {