nextcloud / server

lib/public/DB/QueryBuilder/IExpressionBuilder.php

Indentation +382 added lines, -382 removed lines

@@ -36,409 +36,409 @@
  * @psalm-taint-specialize
  */
 interface IExpressionBuilder {
-	/**
-	 * @since 9.0.0
-	 */
-	public const EQ = ExpressionBuilder::EQ;
-	/**
-	 * @since 9.0.0
-	 */
-	public const NEQ = ExpressionBuilder::NEQ;
-	/**
-	 * @since 9.0.0
-	 */
-	public const LT = ExpressionBuilder::LT;
-	/**
-	 * @since 9.0.0
-	 */
-	public const LTE = ExpressionBuilder::LTE;
-	/**
-	 * @since 9.0.0
-	 */
-	public const GT = ExpressionBuilder::GT;
-	/**
-	 * @since 9.0.0
-	 */
-	public const GTE = ExpressionBuilder::GTE;
+    /**
+     * @since 9.0.0
+     */
+    public const EQ = ExpressionBuilder::EQ;
+    /**
+     * @since 9.0.0
+     */
+    public const NEQ = ExpressionBuilder::NEQ;
+    /**
+     * @since 9.0.0
+     */
+    public const LT = ExpressionBuilder::LT;
+    /**
+     * @since 9.0.0
+     */
+    public const LTE = ExpressionBuilder::LTE;
+    /**
+     * @since 9.0.0
+     */
+    public const GT = ExpressionBuilder::GT;
+    /**
+     * @since 9.0.0
+     */
+    public const GTE = ExpressionBuilder::GTE;
 
-	/**
-	 * Creates a conjunction of the given boolean expressions.
-	 *
-	 * Example:
-	 *
-	 *     [php]
-	 *     // (u.type = ?) AND (u.role = ?)
-	 *     $expr->andX('u.type = ?', 'u.role = ?'));
-	 *
-	 * @param mixed ...$x Optional clause. Defaults = null, but requires
-	 *                 at least one defined when converting to string.
-	 *
-	 * @return \OCP\DB\QueryBuilder\ICompositeExpression
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 */
-	public function andX(...$x): ICompositeExpression;
+    /**
+     * Creates a conjunction of the given boolean expressions.
+     *
+     * Example:
+     *
+     *     [php]
+     *     // (u.type = ?) AND (u.role = ?)
+     *     $expr->andX('u.type = ?', 'u.role = ?'));
+     *
+     * @param mixed ...$x Optional clause. Defaults = null, but requires
+     *                 at least one defined when converting to string.
+     *
+     * @return \OCP\DB\QueryBuilder\ICompositeExpression
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $x
+     */
+    public function andX(...$x): ICompositeExpression;
 
-	/**
-	 * Creates a disjunction of the given boolean expressions.
-	 *
-	 * Example:
-	 *
-	 *     [php]
-	 *     // (u.type = ?) OR (u.role = ?)
-	 *     $qb->where($qb->expr()->orX('u.type = ?', 'u.role = ?'));
-	 *
-	 * @param mixed ...$x Optional clause. Defaults = null, but requires
-	 *                 at least one defined when converting to string.
-	 *
-	 * @return \OCP\DB\QueryBuilder\ICompositeExpression
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 */
-	public function orX(...$x): ICompositeExpression;
+    /**
+     * Creates a disjunction of the given boolean expressions.
+     *
+     * Example:
+     *
+     *     [php]
+     *     // (u.type = ?) OR (u.role = ?)
+     *     $qb->where($qb->expr()->orX('u.type = ?', 'u.role = ?'));
+     *
+     * @param mixed ...$x Optional clause. Defaults = null, but requires
+     *                 at least one defined when converting to string.
+     *
+     * @return \OCP\DB\QueryBuilder\ICompositeExpression
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $x
+     */
+    public function orX(...$x): ICompositeExpression;
 
-	/**
-	 * Creates a comparison expression.
-	 *
-	 * @param mixed $x The left expression.
-	 * @param string $operator One of the IExpressionBuilder::* constants.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $operator
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function comparison($x, string $operator, $y, $type = null): string;
+    /**
+     * Creates a comparison expression.
+     *
+     * @param mixed $x The left expression.
+     * @param string $operator One of the IExpressionBuilder::* constants.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $operator
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function comparison($x, string $operator, $y, $type = null): string;
 
-	/**
-	 * Creates an equality comparison expression with the given arguments.
-	 *
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> = <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id = ?
-	 *     $expr->eq('u.id', '?');
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function eq($x, $y, $type = null): string;
+    /**
+     * Creates an equality comparison expression with the given arguments.
+     *
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> = <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id = ?
+     *     $expr->eq('u.id', '?');
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function eq($x, $y, $type = null): string;
 
-	/**
-	 * Creates a non equality comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> <> <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id <> 1
-	 *     $q->where($q->expr()->neq('u.id', '1'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function neq($x, $y, $type = null): string;
+    /**
+     * Creates a non equality comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> <> <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id <> 1
+     *     $q->where($q->expr()->neq('u.id', '1'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function neq($x, $y, $type = null): string;
 
-	/**
-	 * Creates a lower-than comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> < <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id < ?
-	 *     $q->where($q->expr()->lt('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function lt($x, $y, $type = null): string;
+    /**
+     * Creates a lower-than comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> < <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id < ?
+     *     $q->where($q->expr()->lt('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function lt($x, $y, $type = null): string;
 
-	/**
-	 * Creates a lower-than-equal comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> <= <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id <= ?
-	 *     $q->where($q->expr()->lte('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function lte($x, $y, $type = null): string;
+    /**
+     * Creates a lower-than-equal comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> <= <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id <= ?
+     *     $q->where($q->expr()->lte('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function lte($x, $y, $type = null): string;
 
-	/**
-	 * Creates a greater-than comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> > <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id > ?
-	 *     $q->where($q->expr()->gt('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function gt($x, $y, $type = null): string;
+    /**
+     * Creates a greater-than comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> > <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id > ?
+     *     $q->where($q->expr()->gt('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function gt($x, $y, $type = null): string;
 
-	/**
-	 * Creates a greater-than-equal comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> >= <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id >= ?
-	 *     $q->where($q->expr()->gte('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function gte($x, $y, $type = null): string;
+    /**
+     * Creates a greater-than-equal comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> >= <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id >= ?
+     *     $q->where($q->expr()->gte('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function gte($x, $y, $type = null): string;
 
-	/**
-	 * Creates an IS NULL expression with the given arguments.
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NULL.
-	 *
-	 * @return string
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 */
-	public function isNull($x): string;
+    /**
+     * Creates an IS NULL expression with the given arguments.
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NULL.
+     *
+     * @return string
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $x
+     */
+    public function isNull($x): string;
 
-	/**
-	 * Creates an IS NOT NULL expression with the given arguments.
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NOT NULL.
-	 *
-	 * @return string
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 */
-	public function isNotNull($x): string;
+    /**
+     * Creates an IS NOT NULL expression with the given arguments.
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NOT NULL.
+     *
+     * @return string
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $x
+     */
+    public function isNotNull($x): string;
 
-	/**
-	 * Creates a LIKE() comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by LIKE() comparison.
-	 * @param mixed $y Argument to be used in LIKE() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function like($x, $y, $type = null): string;
+    /**
+     * Creates a LIKE() comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by LIKE() comparison.
+     * @param mixed $y Argument to be used in LIKE() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function like($x, $y, $type = null): string;
 
-	/**
-	 * Creates a NOT LIKE() comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by NOT LIKE() comparison.
-	 * @param mixed $y Argument to be used in NOT LIKE() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function notLike($x, $y, $type = null): string;
+    /**
+     * Creates a NOT LIKE() comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by NOT LIKE() comparison.
+     * @param mixed $y Argument to be used in NOT LIKE() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function notLike($x, $y, $type = null): string;
 
-	/**
-	 * Creates a ILIKE() comparison expression with the given arguments.
-	 *
-	 * @param string $x Field in string format to be inspected by ILIKE() comparison.
-	 * @param mixed $y Argument to be used in ILIKE() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function iLike($x, $y, $type = null): string;
+    /**
+     * Creates a ILIKE() comparison expression with the given arguments.
+     *
+     * @param string $x Field in string format to be inspected by ILIKE() comparison.
+     * @param mixed $y Argument to be used in ILIKE() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function iLike($x, $y, $type = null): string;
 
-	/**
-	 * Creates a IN () comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by IN() comparison.
-	 * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by IN() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function in($x, $y, $type = null): string;
+    /**
+     * Creates a IN () comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by IN() comparison.
+     * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by IN() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function in($x, $y, $type = null): string;
 
-	/**
-	 * Creates a NOT IN () comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by NOT IN() comparison.
-	 * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by NOT IN() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 8.2.0 - Parameter $type was added in 9.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 * @psalm-taint-sink sql $type
-	 */
-	public function notIn($x, $y, $type = null): string;
+    /**
+     * Creates a NOT IN () comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by NOT IN() comparison.
+     * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by NOT IN() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 8.2.0 - Parameter $type was added in 9.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     * @psalm-taint-sink sql $type
+     */
+    public function notIn($x, $y, $type = null): string;
 
-	/**
-	 * Creates a $x = '' statement, because Oracle needs a different check
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
-	 * @return string
-	 * @since 13.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 */
-	public function emptyString($x): string;
+    /**
+     * Creates a $x = '' statement, because Oracle needs a different check
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
+     * @return string
+     * @since 13.0.0
+     *
+     * @psalm-taint-sink sql $x
+     */
+    public function emptyString($x): string;
 
-	/**
-	 * Creates a `$x <> ''` statement, because Oracle needs a different check
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
-	 * @return string
-	 * @since 13.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 */
-	public function nonEmptyString($x): string;
+    /**
+     * Creates a `$x <> ''` statement, because Oracle needs a different check
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
+     * @return string
+     * @since 13.0.0
+     *
+     * @psalm-taint-sink sql $x
+     */
+    public function nonEmptyString($x): string;
 
 
-	/**
-	 * Creates a bitwise AND comparison
-	 *
-	 * @param string|ILiteral $x The field or value to check
-	 * @param int $y Bitmap that must be set
-	 * @return IQueryFunction
-	 * @since 12.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 */
-	public function bitwiseAnd($x, int $y): IQueryFunction;
+    /**
+     * Creates a bitwise AND comparison
+     *
+     * @param string|ILiteral $x The field or value to check
+     * @param int $y Bitmap that must be set
+     * @return IQueryFunction
+     * @since 12.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     */
+    public function bitwiseAnd($x, int $y): IQueryFunction;
 
-	/**
-	 * Creates a bitwise OR comparison
-	 *
-	 * @param string|ILiteral $x The field or value to check
-	 * @param int $y Bitmap that must be set
-	 * @return IQueryFunction
-	 * @since 12.0.0
-	 *
-	 * @psalm-taint-sink sql $x
-	 * @psalm-taint-sink sql $y
-	 */
-	public function bitwiseOr($x, int $y): IQueryFunction;
+    /**
+     * Creates a bitwise OR comparison
+     *
+     * @param string|ILiteral $x The field or value to check
+     * @param int $y Bitmap that must be set
+     * @return IQueryFunction
+     * @since 12.0.0
+     *
+     * @psalm-taint-sink sql $x
+     * @psalm-taint-sink sql $y
+     */
+    public function bitwiseOr($x, int $y): IQueryFunction;
 
-	/**
-	 * Quotes a given input parameter.
-	 *
-	 * @param mixed $input The parameter to be quoted.
-	 * @param mixed|null $type One of the IQueryBuilder::PARAM_* constants
-	 *
-	 * @return ILiteral
-	 * @since 8.2.0
-	 *
-	 * @psalm-taint-sink sql $input
-	 * @psalm-taint-sink sql $type
-	 */
-	public function literal($input, $type = null): ILiteral;
+    /**
+     * Quotes a given input parameter.
+     *
+     * @param mixed $input The parameter to be quoted.
+     * @param mixed|null $type One of the IQueryBuilder::PARAM_* constants
+     *
+     * @return ILiteral
+     * @since 8.2.0
+     *
+     * @psalm-taint-sink sql $input
+     * @psalm-taint-sink sql $type
+     */
+    public function literal($input, $type = null): ILiteral;
 
-	/**
-	 * Returns a IQueryFunction that casts the column to the given type
-	 *
-	 * @param string $column
-	 * @param mixed $type One of IQueryBuilder::PARAM_*
-	 * @return IQueryFunction
-	 * @since 9.0.0
-	 *
-	 * @psalm-taint-sink sql $column
-	 * @psalm-taint-sink sql $type
-	 */
-	public function castColumn(string $column, $type): IQueryFunction;
+    /**
+     * Returns a IQueryFunction that casts the column to the given type
+     *
+     * @param string $column
+     * @param mixed $type One of IQueryBuilder::PARAM_*
+     * @return IQueryFunction
+     * @since 9.0.0
+     *
+     * @psalm-taint-sink sql $column
+     * @psalm-taint-sink sql $type
+     */
+    public function castColumn(string $column, $type): IQueryFunction;
 }

lib/private/DB/QueryBuilder/ExpressionBuilder/OCIExpressionBuilder.php

Indentation +159 added lines, -159 removed lines

@@ -32,163 +32,163 @@
 
 class OCIExpressionBuilder extends ExpressionBuilder {
 
-	/**
-	 * @param mixed $column
-	 * @param mixed|null $type
-	 * @return array|IQueryFunction|string
-	 */
-	protected function prepareColumn($column, $type) {
-		if ($type === IQueryBuilder::PARAM_STR && !is_array($column) && !($column instanceof IParameter) && !($column instanceof ILiteral)) {
-			$column = $this->castColumn($column, $type);
-		} else {
-			$column = $this->helper->quoteColumnNames($column);
-		}
-		return $column;
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function comparison($x, string $operator, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->comparison($x, $operator, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function eq($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->eq($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function neq($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->neq($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function lt($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->lt($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function lte($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->lte($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function gt($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->gt($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function gte($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->gte($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function in($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->in($x, $y);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function notIn($x, $y, $type = null): string {
-		$x = $this->prepareColumn($x, $type);
-		$y = $this->prepareColumn($y, $type);
-
-		return $this->expressionBuilder->notIn($x, $y);
-	}
-
-	/**
-	 * Creates a $x = '' statement, because Oracle needs a different check
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
-	 * @return string
-	 * @since 13.0.0
-	 */
-	public function emptyString($x): string {
-		return $this->isNull($x);
-	}
-
-	/**
-	 * Creates a `$x <> ''` statement, because Oracle needs a different check
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
-	 * @return string
-	 * @since 13.0.0
-	 */
-	public function nonEmptyString($x): string {
-		return $this->isNotNull($x);
-	}
-
-	/**
-	 * Returns a IQueryFunction that casts the column to the given type
-	 *
-	 * @param string $column
-	 * @param mixed $type One of IQueryBuilder::PARAM_*
-	 * @return IQueryFunction
-	 */
-	public function castColumn(string $column, $type): IQueryFunction {
-		if ($type === IQueryBuilder::PARAM_STR) {
-			$column = $this->helper->quoteColumnName($column);
-			return new QueryFunction('to_char(' . $column . ')');
-		}
-		if ($type === IQueryBuilder::PARAM_INT) {
-			$column = $this->helper->quoteColumnName($column);
-			return new QueryFunction('to_number(to_char(' . $column . '))');
-		}
-
-		return parent::castColumn($column, $type);
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function like($x, $y, $type = null): string {
-		return parent::like($x, $y, $type) . " ESCAPE '\\'";
-	}
-
-	/**
-	 * @inheritdoc
-	 */
-	public function iLike($x, $y, $type = null): string {
-		return $this->like($this->functionBuilder->lower($x), $this->functionBuilder->lower($y));
-	}
+    /**
+     * @param mixed $column
+     * @param mixed|null $type
+     * @return array|IQueryFunction|string
+     */
+    protected function prepareColumn($column, $type) {
+        if ($type === IQueryBuilder::PARAM_STR && !is_array($column) && !($column instanceof IParameter) && !($column instanceof ILiteral)) {
+            $column = $this->castColumn($column, $type);
+        } else {
+            $column = $this->helper->quoteColumnNames($column);
+        }
+        return $column;
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function comparison($x, string $operator, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->comparison($x, $operator, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function eq($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->eq($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function neq($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->neq($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function lt($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->lt($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function lte($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->lte($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function gt($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->gt($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function gte($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->gte($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function in($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->in($x, $y);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function notIn($x, $y, $type = null): string {
+        $x = $this->prepareColumn($x, $type);
+        $y = $this->prepareColumn($y, $type);
+
+        return $this->expressionBuilder->notIn($x, $y);
+    }
+
+    /**
+     * Creates a $x = '' statement, because Oracle needs a different check
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
+     * @return string
+     * @since 13.0.0
+     */
+    public function emptyString($x): string {
+        return $this->isNull($x);
+    }
+
+    /**
+     * Creates a `$x <> ''` statement, because Oracle needs a different check
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
+     * @return string
+     * @since 13.0.0
+     */
+    public function nonEmptyString($x): string {
+        return $this->isNotNull($x);
+    }
+
+    /**
+     * Returns a IQueryFunction that casts the column to the given type
+     *
+     * @param string $column
+     * @param mixed $type One of IQueryBuilder::PARAM_*
+     * @return IQueryFunction
+     */
+    public function castColumn(string $column, $type): IQueryFunction {
+        if ($type === IQueryBuilder::PARAM_STR) {
+            $column = $this->helper->quoteColumnName($column);
+            return new QueryFunction('to_char(' . $column . ')');
+        }
+        if ($type === IQueryBuilder::PARAM_INT) {
+            $column = $this->helper->quoteColumnName($column);
+            return new QueryFunction('to_number(to_char(' . $column . '))');
+        }
+
+        return parent::castColumn($column, $type);
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function like($x, $y, $type = null): string {
+        return parent::like($x, $y, $type) . " ESCAPE '\\'";
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function iLike($x, $y, $type = null): string {
+        return $this->like($this->functionBuilder->lower($x), $this->functionBuilder->lower($y));
+    }
 }

Spacing +3 added lines, -3 removed lines

@@ -168,11 +168,11 @@ 
 	public function castColumn(string $column, $type): IQueryFunction {
 		if ($type === IQueryBuilder::PARAM_STR) {
 			$column = $this->helper->quoteColumnName($column);
-			return new QueryFunction('to_char(' . $column . ')');
+			return new QueryFunction('to_char('.$column.')');
 		}
 		if ($type === IQueryBuilder::PARAM_INT) {
 			$column = $this->helper->quoteColumnName($column);
-			return new QueryFunction('to_number(to_char(' . $column . '))');
+			return new QueryFunction('to_number(to_char('.$column.'))');
 		}
 
 		return parent::castColumn($column, $type);
@@ -182,7 +182,7 @@ 
 	 * @inheritdoc
 	 */
 	public function like($x, $y, $type = null): string {
-		return parent::like($x, $y, $type) . " ESCAPE '\\'";
+		return parent::like($x, $y, $type)." ESCAPE '\\'";
 	}
 
 	/**

lib/private/DB/QueryBuilder/ExpressionBuilder/ExpressionBuilder.php

Indentation +366 added lines, -366 removed lines

@@ -42,396 +42,396 @@
 use OCP\IDBConnection;
 
 class ExpressionBuilder implements IExpressionBuilder {
-	/** @var \Doctrine\DBAL\Query\Expression\ExpressionBuilder */
-	protected $expressionBuilder;
+    /** @var \Doctrine\DBAL\Query\Expression\ExpressionBuilder */
+    protected $expressionBuilder;
 
-	/** @var QuoteHelper */
-	protected $helper;
+    /** @var QuoteHelper */
+    protected $helper;
 
-	/** @var IDBConnection */
-	protected $connection;
+    /** @var IDBConnection */
+    protected $connection;
 
-	/** @var FunctionBuilder */
-	protected $functionBuilder;
+    /** @var FunctionBuilder */
+    protected $functionBuilder;
 
-	/**
-	 * Initializes a new <tt>ExpressionBuilder</tt>.
-	 *
-	 * @param ConnectionAdapter $connection
-	 * @param IQueryBuilder $queryBuilder
-	 */
-	public function __construct(ConnectionAdapter $connection, IQueryBuilder $queryBuilder) {
-		$this->connection = $connection;
-		$this->helper = new QuoteHelper();
-		$this->expressionBuilder = new DoctrineExpressionBuilder($connection->getInner());
-		$this->functionBuilder = $queryBuilder->func();
-	}
+    /**
+     * Initializes a new <tt>ExpressionBuilder</tt>.
+     *
+     * @param ConnectionAdapter $connection
+     * @param IQueryBuilder $queryBuilder
+     */
+    public function __construct(ConnectionAdapter $connection, IQueryBuilder $queryBuilder) {
+        $this->connection = $connection;
+        $this->helper = new QuoteHelper();
+        $this->expressionBuilder = new DoctrineExpressionBuilder($connection->getInner());
+        $this->functionBuilder = $queryBuilder->func();
+    }
 
-	/**
-	 * Creates a conjunction of the given boolean expressions.
-	 *
-	 * Example:
-	 *
-	 *     [php]
-	 *     // (u.type = ?) AND (u.role = ?)
-	 *     $expr->andX('u.type = ?', 'u.role = ?'));
-	 *
-	 * @param mixed ...$x Optional clause. Defaults = null, but requires
-	 *                 at least one defined when converting to string.
-	 *
-	 * @return \OCP\DB\QueryBuilder\ICompositeExpression
-	 */
-	public function andX(...$x): ICompositeExpression {
-		$compositeExpression = call_user_func_array([$this->expressionBuilder, 'andX'], $x);
-		return new CompositeExpression($compositeExpression);
-	}
+    /**
+     * Creates a conjunction of the given boolean expressions.
+     *
+     * Example:
+     *
+     *     [php]
+     *     // (u.type = ?) AND (u.role = ?)
+     *     $expr->andX('u.type = ?', 'u.role = ?'));
+     *
+     * @param mixed ...$x Optional clause. Defaults = null, but requires
+     *                 at least one defined when converting to string.
+     *
+     * @return \OCP\DB\QueryBuilder\ICompositeExpression
+     */
+    public function andX(...$x): ICompositeExpression {
+        $compositeExpression = call_user_func_array([$this->expressionBuilder, 'andX'], $x);
+        return new CompositeExpression($compositeExpression);
+    }
 
-	/**
-	 * Creates a disjunction of the given boolean expressions.
-	 *
-	 * Example:
-	 *
-	 *     [php]
-	 *     // (u.type = ?) OR (u.role = ?)
-	 *     $qb->where($qb->expr()->orX('u.type = ?', 'u.role = ?'));
-	 *
-	 * @param mixed ...$x Optional clause. Defaults = null, but requires
-	 *                 at least one defined when converting to string.
-	 *
-	 * @return \OCP\DB\QueryBuilder\ICompositeExpression
-	 */
-	public function orX(...$x): ICompositeExpression {
-		$compositeExpression = call_user_func_array([$this->expressionBuilder, 'orX'], $x);
-		return new CompositeExpression($compositeExpression);
-	}
+    /**
+     * Creates a disjunction of the given boolean expressions.
+     *
+     * Example:
+     *
+     *     [php]
+     *     // (u.type = ?) OR (u.role = ?)
+     *     $qb->where($qb->expr()->orX('u.type = ?', 'u.role = ?'));
+     *
+     * @param mixed ...$x Optional clause. Defaults = null, but requires
+     *                 at least one defined when converting to string.
+     *
+     * @return \OCP\DB\QueryBuilder\ICompositeExpression
+     */
+    public function orX(...$x): ICompositeExpression {
+        $compositeExpression = call_user_func_array([$this->expressionBuilder, 'orX'], $x);
+        return new CompositeExpression($compositeExpression);
+    }
 
-	/**
-	 * Creates a comparison expression.
-	 *
-	 * @param mixed $x The left expression.
-	 * @param string $operator One of the IExpressionBuilder::* constants.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function comparison($x, string $operator, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->comparison($x, $operator, $y);
-	}
+    /**
+     * Creates a comparison expression.
+     *
+     * @param mixed $x The left expression.
+     * @param string $operator One of the IExpressionBuilder::* constants.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function comparison($x, string $operator, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->comparison($x, $operator, $y);
+    }
 
-	/**
-	 * Creates an equality comparison expression with the given arguments.
-	 *
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> = <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id = ?
-	 *     $expr->eq('u.id', '?');
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function eq($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->eq($x, $y);
-	}
+    /**
+     * Creates an equality comparison expression with the given arguments.
+     *
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> = <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id = ?
+     *     $expr->eq('u.id', '?');
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function eq($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->eq($x, $y);
+    }
 
-	/**
-	 * Creates a non equality comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> <> <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id <> 1
-	 *     $q->where($q->expr()->neq('u.id', '1'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function neq($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->neq($x, $y);
-	}
+    /**
+     * Creates a non equality comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> <> <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id <> 1
+     *     $q->where($q->expr()->neq('u.id', '1'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function neq($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->neq($x, $y);
+    }
 
-	/**
-	 * Creates a lower-than comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> < <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id < ?
-	 *     $q->where($q->expr()->lt('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function lt($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->lt($x, $y);
-	}
+    /**
+     * Creates a lower-than comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> < <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id < ?
+     *     $q->where($q->expr()->lt('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function lt($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->lt($x, $y);
+    }
 
-	/**
-	 * Creates a lower-than-equal comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> <= <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id <= ?
-	 *     $q->where($q->expr()->lte('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function lte($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->lte($x, $y);
-	}
+    /**
+     * Creates a lower-than-equal comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> <= <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id <= ?
+     *     $q->where($q->expr()->lte('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function lte($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->lte($x, $y);
+    }
 
-	/**
-	 * Creates a greater-than comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> > <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id > ?
-	 *     $q->where($q->expr()->gt('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function gt($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->gt($x, $y);
-	}
+    /**
+     * Creates a greater-than comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> > <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id > ?
+     *     $q->where($q->expr()->gt('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function gt($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->gt($x, $y);
+    }
 
-	/**
-	 * Creates a greater-than-equal comparison expression with the given arguments.
-	 * First argument is considered the left expression and the second is the right expression.
-	 * When converted to string, it will generated a <left expr> >= <right expr>. Example:
-	 *
-	 *     [php]
-	 *     // u.id >= ?
-	 *     $q->where($q->expr()->gte('u.id', '?'));
-	 *
-	 * @param mixed $x The left expression.
-	 * @param mixed $y The right expression.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function gte($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->gte($x, $y);
-	}
+    /**
+     * Creates a greater-than-equal comparison expression with the given arguments.
+     * First argument is considered the left expression and the second is the right expression.
+     * When converted to string, it will generated a <left expr> >= <right expr>. Example:
+     *
+     *     [php]
+     *     // u.id >= ?
+     *     $q->where($q->expr()->gte('u.id', '?'));
+     *
+     * @param mixed $x The left expression.
+     * @param mixed $y The right expression.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function gte($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->gte($x, $y);
+    }
 
-	/**
-	 * Creates an IS NULL expression with the given arguments.
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NULL.
-	 *
-	 * @return string
-	 */
-	public function isNull($x): string {
-		$x = $this->helper->quoteColumnName($x);
-		return $this->expressionBuilder->isNull($x);
-	}
+    /**
+     * Creates an IS NULL expression with the given arguments.
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NULL.
+     *
+     * @return string
+     */
+    public function isNull($x): string {
+        $x = $this->helper->quoteColumnName($x);
+        return $this->expressionBuilder->isNull($x);
+    }
 
-	/**
-	 * Creates an IS NOT NULL expression with the given arguments.
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NOT NULL.
-	 *
-	 * @return string
-	 */
-	public function isNotNull($x): string {
-		$x = $this->helper->quoteColumnName($x);
-		return $this->expressionBuilder->isNotNull($x);
-	}
+    /**
+     * Creates an IS NOT NULL expression with the given arguments.
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be restricted by IS NOT NULL.
+     *
+     * @return string
+     */
+    public function isNotNull($x): string {
+        $x = $this->helper->quoteColumnName($x);
+        return $this->expressionBuilder->isNotNull($x);
+    }
 
-	/**
-	 * Creates a LIKE() comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by LIKE() comparison.
-	 * @param mixed $y Argument to be used in LIKE() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function like($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->like($x, $y);
-	}
+    /**
+     * Creates a LIKE() comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by LIKE() comparison.
+     * @param mixed $y Argument to be used in LIKE() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function like($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->like($x, $y);
+    }
 
-	/**
-	 * Creates a ILIKE() comparison expression with the given arguments.
-	 *
-	 * @param string $x Field in string format to be inspected by ILIKE() comparison.
-	 * @param mixed $y Argument to be used in ILIKE() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 * @since 9.0.0
-	 */
-	public function iLike($x, $y, $type = null): string {
-		return $this->expressionBuilder->like($this->functionBuilder->lower($x), $this->functionBuilder->lower($y));
-	}
+    /**
+     * Creates a ILIKE() comparison expression with the given arguments.
+     *
+     * @param string $x Field in string format to be inspected by ILIKE() comparison.
+     * @param mixed $y Argument to be used in ILIKE() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     * @since 9.0.0
+     */
+    public function iLike($x, $y, $type = null): string {
+        return $this->expressionBuilder->like($this->functionBuilder->lower($x), $this->functionBuilder->lower($y));
+    }
 
-	/**
-	 * Creates a NOT LIKE() comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by NOT LIKE() comparison.
-	 * @param mixed $y Argument to be used in NOT LIKE() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function notLike($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->notLike($x, $y);
-	}
+    /**
+     * Creates a NOT LIKE() comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x Field in string format to be inspected by NOT LIKE() comparison.
+     * @param mixed $y Argument to be used in NOT LIKE() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function notLike($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->notLike($x, $y);
+    }
 
-	/**
-	 * Creates a IN () comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by IN() comparison.
-	 * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by IN() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function in($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnNames($y);
-		return $this->expressionBuilder->in($x, $y);
-	}
+    /**
+     * Creates a IN () comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by IN() comparison.
+     * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by IN() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function in($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnNames($y);
+        return $this->expressionBuilder->in($x, $y);
+    }
 
-	/**
-	 * Creates a NOT IN () comparison expression with the given arguments.
-	 *
-	 * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by NOT IN() comparison.
-	 * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by NOT IN() comparison.
-	 * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
-	 *                  required when comparing text fields for oci compatibility
-	 *
-	 * @return string
-	 */
-	public function notIn($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnNames($y);
-		return $this->expressionBuilder->notIn($x, $y);
-	}
+    /**
+     * Creates a NOT IN () comparison expression with the given arguments.
+     *
+     * @param ILiteral|IParameter|IQueryFunction|string $x The field in string format to be inspected by NOT IN() comparison.
+     * @param ILiteral|IParameter|IQueryFunction|string|array $y The placeholder or the array of values to be used by NOT IN() comparison.
+     * @param mixed|null $type one of the IQueryBuilder::PARAM_* constants
+     *                  required when comparing text fields for oci compatibility
+     *
+     * @return string
+     */
+    public function notIn($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnNames($y);
+        return $this->expressionBuilder->notIn($x, $y);
+    }
 
-	/**
-	 * Creates a $x = '' statement, because Oracle needs a different check
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
-	 * @return string
-	 * @since 13.0.0
-	 */
-	public function emptyString($x): string {
-		return $this->eq($x, $this->literal('', IQueryBuilder::PARAM_STR));
-	}
+    /**
+     * Creates a $x = '' statement, because Oracle needs a different check
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
+     * @return string
+     * @since 13.0.0
+     */
+    public function emptyString($x): string {
+        return $this->eq($x, $this->literal('', IQueryBuilder::PARAM_STR));
+    }
 
-	/**
-	 * Creates a `$x <> ''` statement, because Oracle needs a different check
-	 *
-	 * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
-	 * @return string
-	 * @since 13.0.0
-	 */
-	public function nonEmptyString($x): string {
-		return $this->neq($x, $this->literal('', IQueryBuilder::PARAM_STR));
-	}
+    /**
+     * Creates a `$x <> ''` statement, because Oracle needs a different check
+     *
+     * @param string|ILiteral|IParameter|IQueryFunction $x The field in string format to be inspected by the comparison.
+     * @return string
+     * @since 13.0.0
+     */
+    public function nonEmptyString($x): string {
+        return $this->neq($x, $this->literal('', IQueryBuilder::PARAM_STR));
+    }
 
-	/**
-	 * Binary AND Operator copies a bit to the result if it exists in both operands.
-	 *
-	 * @param string|ILiteral $x The field or value to check
-	 * @param int $y Bitmap that must be set
-	 * @return IQueryFunction
-	 * @since 12.0.0
-	 */
-	public function bitwiseAnd($x, int $y): IQueryFunction {
-		return new QueryFunction($this->connection->getDatabasePlatform()->getBitAndComparisonExpression(
-			$this->helper->quoteColumnName($x),
-			$y
-		));
-	}
+    /**
+     * Binary AND Operator copies a bit to the result if it exists in both operands.
+     *
+     * @param string|ILiteral $x The field or value to check
+     * @param int $y Bitmap that must be set
+     * @return IQueryFunction
+     * @since 12.0.0
+     */
+    public function bitwiseAnd($x, int $y): IQueryFunction {
+        return new QueryFunction($this->connection->getDatabasePlatform()->getBitAndComparisonExpression(
+            $this->helper->quoteColumnName($x),
+            $y
+        ));
+    }
 
-	/**
-	 * Binary OR Operator copies a bit if it exists in either operand.
-	 *
-	 * @param string|ILiteral $x The field or value to check
-	 * @param int $y Bitmap that must be set
-	 * @return IQueryFunction
-	 * @since 12.0.0
-	 */
-	public function bitwiseOr($x, int $y): IQueryFunction {
-		return new QueryFunction($this->connection->getDatabasePlatform()->getBitOrComparisonExpression(
-			$this->helper->quoteColumnName($x),
-			$y
-		));
-	}
+    /**
+     * Binary OR Operator copies a bit if it exists in either operand.
+     *
+     * @param string|ILiteral $x The field or value to check
+     * @param int $y Bitmap that must be set
+     * @return IQueryFunction
+     * @since 12.0.0
+     */
+    public function bitwiseOr($x, int $y): IQueryFunction {
+        return new QueryFunction($this->connection->getDatabasePlatform()->getBitOrComparisonExpression(
+            $this->helper->quoteColumnName($x),
+            $y
+        ));
+    }
 
-	/**
-	 * Quotes a given input parameter.
-	 *
-	 * @param mixed $input The parameter to be quoted.
-	 * @param mixed|null $type One of the IQueryBuilder::PARAM_* constants
-	 *
-	 * @return ILiteral
-	 */
-	public function literal($input, $type = null): ILiteral {
-		return new Literal($this->expressionBuilder->literal($input, $type));
-	}
+    /**
+     * Quotes a given input parameter.
+     *
+     * @param mixed $input The parameter to be quoted.
+     * @param mixed|null $type One of the IQueryBuilder::PARAM_* constants
+     *
+     * @return ILiteral
+     */
+    public function literal($input, $type = null): ILiteral {
+        return new Literal($this->expressionBuilder->literal($input, $type));
+    }
 
-	/**
-	 * Returns a IQueryFunction that casts the column to the given type
-	 *
-	 * @param string $column
-	 * @param mixed $type One of IQueryBuilder::PARAM_*
-	 * @return IQueryFunction
-	 */
-	public function castColumn(string $column, $type): IQueryFunction {
-		return new QueryFunction(
-			$this->helper->quoteColumnName($column)
-		);
-	}
+    /**
+     * Returns a IQueryFunction that casts the column to the given type
+     *
+     * @param string $column
+     * @param mixed $type One of IQueryBuilder::PARAM_*
+     * @return IQueryFunction
+     */
+    public function castColumn(string $column, $type): IQueryFunction {
+        return new QueryFunction(
+            $this->helper->quoteColumnName($column)
+        );
+    }
 }

lib/private/DB/QueryBuilder/ExpressionBuilder/SqliteExpressionBuilder.php

Indentation +9 added lines, -9 removed lines

@@ -24,14 +24,14 @@
 namespace OC\DB\QueryBuilder\ExpressionBuilder;
 
 class SqliteExpressionBuilder extends ExpressionBuilder {
-	/**
-	 * @inheritdoc
-	 */
-	public function like($x, $y, $type = null): string {
-		return parent::like($x, $y, $type) . " ESCAPE '\\'";
-	}
+    /**
+     * @inheritdoc
+     */
+    public function like($x, $y, $type = null): string {
+        return parent::like($x, $y, $type) . " ESCAPE '\\'";
+    }
 
-	public function iLike($x, $y, $type = null): string {
-		return $this->like($this->functionBuilder->lower($x), $this->functionBuilder->lower($y), $type);
-	}
+    public function iLike($x, $y, $type = null): string {
+        return $this->like($this->functionBuilder->lower($x), $this->functionBuilder->lower($y), $type);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -28,7 +28,7 @@
 	 * @inheritdoc
 	 */
 	public function like($x, $y, $type = null): string {
-		return parent::like($x, $y, $type) . " ESCAPE '\\'";
+		return parent::like($x, $y, $type)." ESCAPE '\\'";
 	}
 
 	public function iLike($x, $y, $type = null): string {

lib/private/DB/QueryBuilder/ExpressionBuilder/MySqlExpressionBuilder.php

Indentation +19 added lines, -19 removed lines

@@ -29,26 +29,26 @@
 
 class MySqlExpressionBuilder extends ExpressionBuilder {
 
-	/** @var string */
-	protected $charset;
+    /** @var string */
+    protected $charset;
 
-	/**
-	 * @param ConnectionAdapter $connection
-	 * @param IQueryBuilder $queryBuilder
-	 */
-	public function __construct(ConnectionAdapter $connection, IQueryBuilder $queryBuilder) {
-		parent::__construct($connection, $queryBuilder);
+    /**
+     * @param ConnectionAdapter $connection
+     * @param IQueryBuilder $queryBuilder
+     */
+    public function __construct(ConnectionAdapter $connection, IQueryBuilder $queryBuilder) {
+        parent::__construct($connection, $queryBuilder);
 
-		$params = $connection->getInner()->getParams();
-		$this->charset = isset($params['charset']) ? $params['charset'] : 'utf8';
-	}
+        $params = $connection->getInner()->getParams();
+        $this->charset = isset($params['charset']) ? $params['charset'] : 'utf8';
+    }
 
-	/**
-	 * @inheritdoc
-	 */
-	public function iLike($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->comparison($x, ' COLLATE ' . $this->charset . '_general_ci LIKE', $y);
-	}
+    /**
+     * @inheritdoc
+     */
+    public function iLike($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->comparison($x, ' COLLATE ' . $this->charset . '_general_ci LIKE', $y);
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -49,6 +49,6 @@
 	public function iLike($x, $y, $type = null): string {
 		$x = $this->helper->quoteColumnName($x);
 		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->comparison($x, ' COLLATE ' . $this->charset . '_general_ci LIKE', $y);
+		return $this->expressionBuilder->comparison($x, ' COLLATE '.$this->charset.'_general_ci LIKE', $y);
 	}
 }

lib/private/DB/QueryBuilder/ExpressionBuilder/PgSqlExpressionBuilder.php

Indentation +25 added lines, -25 removed lines

@@ -30,30 +30,30 @@
 
 class PgSqlExpressionBuilder extends ExpressionBuilder {
 
-	/**
-	 * Returns a IQueryFunction that casts the column to the given type
-	 *
-	 * @param string $column
-	 * @param mixed $type One of IQueryBuilder::PARAM_*
-	 * @return IQueryFunction
-	 */
-	public function castColumn($column, $type): IQueryFunction {
-		switch ($type) {
-			case IQueryBuilder::PARAM_INT:
-				return new QueryFunction('CAST(' . $this->helper->quoteColumnName($column) . ' AS INT)');
-			case IQueryBuilder::PARAM_STR:
-				return new QueryFunction('CAST(' . $this->helper->quoteColumnName($column) . ' AS TEXT)');
-			default:
-				return parent::castColumn($column, $type);
-		}
-	}
+    /**
+     * Returns a IQueryFunction that casts the column to the given type
+     *
+     * @param string $column
+     * @param mixed $type One of IQueryBuilder::PARAM_*
+     * @return IQueryFunction
+     */
+    public function castColumn($column, $type): IQueryFunction {
+        switch ($type) {
+            case IQueryBuilder::PARAM_INT:
+                return new QueryFunction('CAST(' . $this->helper->quoteColumnName($column) . ' AS INT)');
+            case IQueryBuilder::PARAM_STR:
+                return new QueryFunction('CAST(' . $this->helper->quoteColumnName($column) . ' AS TEXT)');
+            default:
+                return parent::castColumn($column, $type);
+        }
+    }
 
-	/**
-	 * @inheritdoc
-	 */
-	public function iLike($x, $y, $type = null): string {
-		$x = $this->helper->quoteColumnName($x);
-		$y = $this->helper->quoteColumnName($y);
-		return $this->expressionBuilder->comparison($x, 'ILIKE', $y);
-	}
+    /**
+     * @inheritdoc
+     */
+    public function iLike($x, $y, $type = null): string {
+        $x = $this->helper->quoteColumnName($x);
+        $y = $this->helper->quoteColumnName($y);
+        return $this->expressionBuilder->comparison($x, 'ILIKE', $y);
+    }
 }

Spacing +2 added lines, -2 removed lines

@@ -40,9 +40,9 @@
 	public function castColumn($column, $type): IQueryFunction {
 		switch ($type) {
 			case IQueryBuilder::PARAM_INT:
-				return new QueryFunction('CAST(' . $this->helper->quoteColumnName($column) . ' AS INT)');
+				return new QueryFunction('CAST('.$this->helper->quoteColumnName($column).' AS INT)');
 			case IQueryBuilder::PARAM_STR:
-				return new QueryFunction('CAST(' . $this->helper->quoteColumnName($column) . ' AS TEXT)');
+				return new QueryFunction('CAST('.$this->helper->quoteColumnName($column).' AS TEXT)');
 			default:
 				return parent::castColumn($column, $type);
 		}