AlgoWeb\PODataLaravel\Query\LaravelReadQuery::getResourceSet()

Complexity

Conditions	35
Paths	> 20000

Size

Total Lines	170
Code Lines	105

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function getResourceSet(
        QueryType $queryType,
        ResourceSet $resourceSet,
        $filterInfo = null,
        $orderBy = null,
        $top = null,
        $skip = null,
        $skipToken = null,
        array $eagerLoad = null,
        $sourceEntityInstance = null
    ) {
        if (null != $filterInfo && !($filterInfo instanceof FilterInfo)) {
            $msg = 'Filter info must be either null or instance of FilterInfo.';
            throw new InvalidArgumentException($msg);
        }
        if (null != $skipToken && !($skipToken instanceof SkipTokenInfo)) {
            $msg = 'Skip token must be either null or instance of SkipTokenInfo.';
            throw new InvalidArgumentException($msg);
        }
        $rawLoad = $this->processEagerLoadList($eagerLoad);
        $modelLoad = [];

        $this->checkSourceInstance($sourceEntityInstance);
        if (null == $sourceEntityInstance) {
            $sourceEntityInstance = $this->getSourceEntityInstance($resourceSet);
        }

        $keyName = null;
        if ($sourceEntityInstance instanceof Model) {
            $modelLoad = $sourceEntityInstance->getEagerLoad();
            $keyName = $sourceEntityInstance->getKeyName();
        } elseif ($sourceEntityInstance instanceof Relation) {
            $modelLoad = $sourceEntityInstance->getRelated()->getEagerLoad();
            $keyName = $sourceEntityInstance->getRelated()->getKeyName();
        }
        assert(isset($keyName));

The call to assert() has too few arguments starting with description.

        $rawLoad = array_values(array_unique(array_merge($rawLoad, $modelLoad)));

It seems like $modelLoad can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $array2 of array_merge() does only seem to accept null|array, maybe add an additional type check?

        $checkInstance = $sourceEntityInstance instanceof Model ? $sourceEntityInstance : null;
        $this->checkAuth($sourceEntityInstance, $checkInstance);

        $result          = new QueryResult();
        $result->results = null;
        $result->count   = null;

        if (null != $orderBy) {
            foreach ($orderBy->getOrderByInfo()->getOrderByPathSegments() as $order) {
                foreach ($order->getSubPathSegments() as $subOrder) {
                    $subName = $subOrder->getName();
                    $subName = (self::PK == $subName) ? $keyName : $subName;
                    $sourceEntityInstance = $sourceEntityInstance->orderBy(
                        $subName,
                        $order->isAscending() ? 'asc' : 'desc'
                    );
                }
            }
        }

        // throttle up for trench run
        if (null != $skipToken) {
            $parameters = [];
            $processed = [];
            $segments = $skipToken->getOrderByInfo()->getOrderByPathSegments();
            $values = $skipToken->getOrderByKeysInToken();
            $numValues = count($values);
            assert($numValues == count($segments));

            for ($i = 0; $i < $numValues; $i++) {
                $relation = $segments[$i]->isAscending() ? '>' : '<';
                $name = $segments[$i]->getSubPathSegments()[0]->getName();
                $name = (self::PK == $name) ? $keyName : $name;
                $parameters[$name] = ['direction' => $relation, 'value' => trim($values[$i][0], '\'')];
            }

            foreach ($parameters as $name => $line) {
                $processed[$name] = ['direction' => $line['direction'], 'value' => $line['value']];
                $sourceEntityInstance = $sourceEntityInstance
                    ->orWhere(
                        function ($query) use ($processed) {
                            foreach ($processed as $key => $proc) {
                                $query->where($key, $proc['direction'], $proc['value']);
                            }
                        }
                    );
                // now we've handled the later-in-order segment for this key, drop it back to equality in prep
                // for next key - same-in-order for processed keys and later-in-order for next
                $processed[$name]['direction'] = '=';
            }
        }

        if (!isset($skip)) {
            $skip = 0;
        }
        if (!isset($top)) {
            $top = PHP_INT_MAX;
        }

        $nullFilter = true;
        $isvalid = null;
        if (isset($filterInfo)) {
            $method = 'return ' . $filterInfo->getExpressionAsString() . ';';
            $clln = '$' . $resourceSet->getResourceType()->getName();
            $isvalid = create_function($clln, $method);

The use of create_function is highly discouraged, better use a closure.

            $nullFilter = false;
        }

        $bulkSetCount = $sourceEntityInstance->count();
        $bigSet = 20000 < $bulkSetCount;

        if ($nullFilter) {
            // default no-filter case, palm processing off to database engine - is a lot faster
            $resultSet = $sourceEntityInstance->skip($skip)->take($top)->with($rawLoad)->get();
            $resultCount = $bulkSetCount;
        } elseif ($bigSet) {
            assert(isset($isvalid), 'Filter closure not set');
            $resultSet = collect([]);
            $rawCount = 0;
            $rawTop = null === $top ? $bulkSetCount : $top;

            // loop thru, chunk by chunk, to reduce chances of exhausting memory
            $sourceEntityInstance->chunk(
                5000,
                function ($results) use ($isvalid, &$skip, &$resultSet, &$rawCount, $rawTop) {
                    // apply filter
                    $results = $results->filter($isvalid);
                    // need to iterate through full result set to find count of items matching filter,
                    // so we can't bail out early
                    $rawCount += $results->count();
                    // now bolt on filtrate to accumulating result set if we haven't accumulated enough bitz
                    if ($rawTop > $resultSet->count()+$skip) {
                        $resultSet = collect(array_merge($resultSet->all(), $results->all()));
                        $sliceAmount = min($skip, $resultSet->count());
                        $resultSet = $resultSet->slice($sliceAmount);
                        $skip -= $sliceAmount;
                    }
                }
            );

            // clean up residual to-be-skipped records
            $resultSet = $resultSet->slice($skip);
            $resultCount = $rawCount;
        } else {
            if ($sourceEntityInstance instanceof Model) {
                $sourceEntityInstance = $sourceEntityInstance->getQuery();
            }
            $resultSet = $sourceEntityInstance->with($rawLoad)->get();
            $resultSet = $resultSet->filter($isvalid);
            $resultCount = $resultSet->count();

            if (isset($skip)) {
                $resultSet = $resultSet->slice($skip);
            }
        }

        if (isset($top)) {
            $resultSet = $resultSet->take($top);
        }

        if (QueryType::ENTITIES() == $queryType || QueryType::ENTITIES_WITH_COUNT() == $queryType) {
            $result->results = [];
            foreach ($resultSet as $res) {
                $result->results[] = $res;
            }
        }
        if (QueryType::COUNT() == $queryType || QueryType::ENTITIES_WITH_COUNT() == $queryType) {
            $result->count = $resultCount;

It seems like $resultCount can also be of type Illuminate\Database\Query\Builder or Illuminate\Database\Eloquent\Relations\Relation&Illuminate\Database\Eloquent\Model or Illuminate\Database\Eloquent\Model or Illuminate\Database\Eloquent\Builder or Illuminate\Database\Eloquent\Relations\Relation. However, the property $count is declared as type null|integer. Maybe add an additional type check?

        }
        $hazMore = $bulkSetCount > $skip+count($resultSet);
        $result->hasMore = $hazMore;
        return $result;
    }