SilverStripe\ORM\Filters\ExactMatchFilter::manyFilter()

Complexity

Conditions	16
Paths	265

Size

Total Lines	85
Code Lines	52

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    protected function manyFilter(DataQuery $query, $inclusive)
    {
        $this->model = $query->applyRelation($this->relation);
        $caseSensitive = $this->getCaseSensitive();

        // Check values for null
        $field = $this->getDbName();
        $values = $this->getValue();
        if (empty($values)) {
            throw new \InvalidArgumentException("Cannot filter {$field} against an empty set");
        }
        $hasNull = in_array(null, $values, true);

It seems like $values can also be of type string; however, parameter $haystack of in_array() does only seem to accept array, maybe add an additional type check?

        if ($hasNull) {
            $values = array_filter($values, function ($value) {

It seems like $values can also be of type string; however, parameter $input of array_filter() does only seem to accept array, maybe add an additional type check?

                return $value !== null;
            });
        }

        $connective = '';
        if (empty($values)) {
            $predicate = '';
        } elseif ($caseSensitive === null) {
            // For queries using the default collation (no explicit case) we can use the WHERE .. NOT IN .. syntax,
            // providing simpler SQL than many WHERE .. AND .. fragments.
            $column = $this->getDbName();
            $placeholders = DB::placeholders($values);

It seems like $values can also be of type string; however, parameter $input of SilverStripe\ORM\DB::placeholders() does only seem to accept array|integer, maybe add an additional type check?

            if ($inclusive) {
                $predicate = "$column IN ($placeholders)";
            } else {
                $predicate = "$column NOT IN ($placeholders)";
            }
        } else {
            // Generate reusable comparison clause
            $comparisonClause = DB::get_conn()->comparisonClause(
                $this->getDbName(),
                null,
                true, // exact?
                !$inclusive, // negate?
                $this->getCaseSensitive(),
                true
            );
            $count = count($values);

It seems like $values can also be of type string; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

            if ($count > 1) {
                $connective = $inclusive ? ' OR ' : ' AND ';
                $conditions = array_fill(0, $count, $comparisonClause);
                $predicate = implode($connective, $conditions);
            } else {
                $predicate = $comparisonClause;
            }
        }

        // Always check for null when doing exclusive checks (either AND IS NOT NULL / OR IS NULL)
        // or when including the null value explicitly (OR IS NULL)
        if ($hasNull || !$inclusive) {
            // If excluding values which don't include null, or including
            // values which include null, we should do an `OR IS NULL`.
            // Otherwise we are excluding values that do include null, so `AND IS NOT NULL`.
            // Simplified from (!$inclusive && !$hasNull) || ($inclusive && $hasNull);
            $isNull = !$hasNull || $inclusive;
            $nullCondition = DB::get_conn()->nullCheckClause($field, $isNull);

            // Determine merge strategy
            if (empty($predicate)) {
                $predicate = $nullCondition;
            } else {
                // Merge null condition with predicate
                if ($isNull) {
                    $nullCondition = " OR {$nullCondition}";
                } else {
                    $nullCondition = " AND {$nullCondition}";
                }
                // If current predicate connective doesn't match the same as the null connective
                // make sure to group the prior condition
                if ($connective && (($connective === ' OR ') !== $isNull)) {
                    $predicate = "({$predicate})";
                }
                $predicate .= $nullCondition;
            }
        }

        $clause = [$predicate => $values];

        return $this->aggregate ?
            $this->applyAggregate($query, $clause) :

$clause of type array is incompatible with the type string expected by parameter $having of SilverStripe\ORM\Filters\SearchFilter::applyAggregate().

            $query->where($clause);
    }