EagerLoadedDataList::createDataObject() - Code Metrics - Inspection of "Merge pull request #9 from rasstislav/patch-2" - gurucomkz/silverstripe-eagerloading - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 980dfc...5e8552 )

by Sergey

created 2023-03-18 08:48 UTC

EagerLoadedDataList::createDataObject() A

↳ Parent: EagerLoadedDataList

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	4
c	1
b	0
f	0
dl	0
loc	7
ccs	5
cts	5
cp	1
rs	10
cc	1
nc	1
nop	1
crap	1

<?php
namespace Gurucomkz\EagerLoading;

use Exception;
use SilverStripe\Core\Config\Config;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\Queries\SQLSelect;

/**
 * Replaces DataList when EagerLoading is used. Fetches data when the main query is actually executed.
 * Appends related objects when a DataObject is actually created.
 */
class EagerLoadedDataList extends DataList
{

    const ID_LIMIT = 5000;
    public $withList = [];
    public $withListOriginal = [];
    public $eagerLoadingRelatedMaps = [
        'has_one' => [],
        'has_many' => [],
        'many_many' => [],
    ];

    public function __construct($classOrList)
    {
        if (is_string($classOrList)) {
            parent::__construct($classOrList);
        } else {
            parent::__construct($classOrList->dataClass());
            $this->dataQuery = $classOrList->dataQuery();
        }
    }

    public $eagerLoadingRelatedCache = [];
    public static function cloneFrom(DataList $list)
    {
        $clone = new EagerLoadedDataList($list);

        $clone->withList = $list->withList;
        $clone->withListOriginal = $list->withListOriginal;
        $clone->eagerLoadingRelatedCache = $list->eagerLoadingRelatedCache;
        return $clone;
    }

    /**
     * Create a DataObject from the given SQL row
     *
     * @param array $row
     * @return DataObject
     */
    public function createDataObject($row)
    {
        $this->prepareEagerRelations();
        $item = parent::createDataObject($row);

        $this->fulfillEagerRelations($item);
        return $item;
    }

    private $relationsPrepared = false;

    private function filterWithList($list)
    {
        return array_filter(
            $this->withList,
            function ($dep) use ($list) {
                return array_key_exists($dep[0], $list);
            }
        );
    }

    public function prepareEagerRelations()
    {
        if ($this->relationsPrepared) {
            return;
        }
        $this->relationsPrepared = true;
        $localClass = $this->dataClass();
        $config = Config::forClass($localClass);
        $hasOnes = (array) $config->get('has_one');
        $hasManys = (array) $config->get('has_many');
        $manyManys = (array) $config->get('many_many');
        $belongsManyManys = (array) $config->get('belongs_many_many');

        //collect has_ones
        $withHasOnes = $this->filterWithList($hasOnes);
        $withHasManys = $this->filterWithList($hasManys);
        $withManyManys = $this->filterWithList($manyManys);
        $withBelongsManyManys = $this->filterWithList($belongsManyManys);

        if (!count($withHasOnes) && !count($withHasManys) && !count($withManyManys) && !count($withBelongsManyManys)) {
            // Injector::inst()->get(LoggerInterface::class)
            // ->debug("Invalid names supplied for ->with(" . implode(', ', $this->withListOriginal) . ")");
            return;
        }

        $data = $this->column('ID');
        if (count($withHasOnes)) {
            $this->eagerLoadingPrepareCache($hasOnes, $withHasOnes);
            $this->eagerLoadHasOne($data, $hasOnes, $withHasOnes);
        }
        if (count($withHasManys)) {
            $this->eagerLoadingPrepareCache($hasManys, $withHasManys);
            $this->eagerLoadHasMany($data, $hasManys, $withHasManys);
        }
        if (count($withManyManys)) {
            $this->eagerLoadingPrepareCache($manyManys, $withManyManys);
            $this->eagerLoadManyMany($data, $manyManys, $withManyManys);
        }
        if (count($withBelongsManyManys)) {
            $this->eagerLoadingPrepareCache($belongsManyManys, $withBelongsManyManys);
            $this->eagerLoadManyMany($data, $belongsManyManys, $withBelongsManyManys);
        }
    }

    public function eagerLoadHasOne(&$ids, $hasOnes, $withHasOnes)
    {
        //collect required IDS
        $fields = ['ID'];
        foreach ($withHasOnes as $depSeq) {
            $dep = $depSeq[0];
            $fields[] = "\"{$dep}ID\"";
        }
        $table = DataObject::getSchema()->tableName($this->dataClass);
        $data = new SQLSelect($fields, '"' . $table . '"', ['"ID" IN (' . implode(',', $ids) . ')']);
        $data = Utils::EnsureArray($data->execute(), 'ID');

        foreach ($withHasOnes as $depSeq) {
            $dep = $depSeq[0];
            $depClass = $hasOnes[$dep];

            $descriptor = [
                'class' => $depClass,
                'localField' => "{$dep}ID",
                'map' => [],
            ];

            $descriptor['map'] = Utils::extractField($data, $descriptor['localField']);
            $uniqueIDs = array_unique($descriptor['map']);
            while (count($uniqueIDs)) {
                $IDsubset = array_splice($uniqueIDs, 0, self::ID_LIMIT);
                $result = DataObject::get($depClass)->filter('ID', $IDsubset);
                if (count($depSeq)>1) {
                    $result = $result
                        ->with(implode('.', array_slice($depSeq, 1)));
                }

                foreach ($result as $depRecord) {
                    $this->eagerLoadingRelatedCache[$depClass][$depRecord->ID] = $depRecord;
                }
            }

            $this->eagerLoadingRelatedMaps['has_one'][$dep] = $descriptor;
        }
    }

    public function eagerLoadHasMany($data, $hasManys, $withHasManys)
    {
        $localClass = $this->dataClass();
        $localClassTail = basename(str_replace('\\', '/', $localClass));

        foreach ($withHasManys as $depSeq) {
            $dep = $depSeq[0];
            $depClass = $hasManys[$dep];
            if (false !== strpos($depClass, '.')) {
                $dcSplit = explode('.', $depClass, 2);
                $depClass = $dcSplit[0];
                $localNameInDep = $dcSplit[1];
            } else {
                $localNameInDep = $localClassTail;
            }
            $depKey = "{$localNameInDep}ID";
            $descriptor = [
                'class' => $depClass,
                'remoteRelation' => $localNameInDep,
                'remoteField' => $depKey,
                'map' => [],
            ];
            $result = DataObject::get($depClass)->filter($depKey, $data);
            if (count($depSeq)>1) {
                $result = $result
                    ->with(implode('.', array_slice($depSeq, 1)));
            }

            $collection = [];

            foreach ($data as $localRecordID) {
                $collection[$localRecordID] = [];
            }
            foreach ($result as $depRecord) {
                $this->eagerLoadingRelatedCache[$depClass][$depRecord->ID] = $depRecord;
                $collection[$depRecord->$depKey][] = $depRecord->ID;
            }
            $descriptor['map'] = $collection;
            $this->eagerLoadingRelatedMaps['has_many'][$dep] = $descriptor;
        }
    }

    public function eagerLoadManyMany(&$data, $manyManys, $withManyManys)
    {
        $localClass = $this->dataClass();
        $schema = DataObject::getSchema();

        foreach ($withManyManys as $depSeq) {
            $dep = $depSeq[0];
            $depData = $manyManys[$dep];

            if (is_array($depData)) {
                if (!isset($depData['from']) || !isset($depData['to']) || !isset($depData['through'])) {
                    throw new Exception(sprintf('Incompatible "many_many through" configuration for %s.%s', $localClass, $dep));
                }
                $throughClass = $depData['through'];
                // determine the target data object
                $depClass = $schema->hasOneComponent($depData['through'], $depData['to']);
                if (!$depClass) {
                    throw new Exception(sprintf('Class %s does not have a $has_one component named', $depData['through'], $depData['to']));
                }

                $table = DataObject::getSchema()->tableName($throughClass);

                $childField = $depData['to']. 'ID';
                $parentField = $depData['from']. 'ID';
            } else {
                $depClass = $depData;
                $component = $schema->manyManyComponent($localClass, $dep);

                $table = $component['join'];
                $childField = $component['childField'];
                $parentField = $component['parentField'];
            }

            $descriptor = [
                'class' => $depClass,
                'map' => [],
            ];

            $idsQuery = SQLSelect::create(
                [
                    '"' . $childField . '"',
                    '"' . $parentField . '"',
                ],
                '"' . $table . '"',
                [
                    '"' . $parentField . '" IN (' . implode(',', $data) . ')'
                ]
            )->execute();

            $collection = [];
            $relListReverted = [];
            foreach ($idsQuery as $row) {
                $relID = $row[$childField];
                $localID = $row[$parentField];
                if (!isset($collection[$localID])) {
                    $collection[$localID] = [];
                }
                $collection[$localID][] = $relID;
                $relListReverted[$relID] = 1; //use ids as keys to avoid
            }

            if (count($relListReverted)) {
                $result = DataObject::get($depClass)->filter('ID', array_keys($relListReverted));
                if (count($depSeq)>1) {
                    $result = $result
                        ->with(implode('.', array_slice($depSeq, 1)));
                }

                foreach ($result as $depRecord) {
                    $this->eagerLoadingRelatedCache[$depClass][$depRecord->ID] = $depRecord;
                }
            }

            $descriptor['map'] = $collection;
            $this->eagerLoadingRelatedMaps['many_many'][$dep] = $descriptor;
        }
    }

    public function fulfillEagerRelations(DataObject $item)
    {
        foreach ($this->eagerLoadingRelatedMaps['has_one'] as $dep => $depInfo) {
            $depClass = $depInfo['class'];
            if (isset($depInfo['map'][$item->ID])) {
                $depID = $depInfo['map'][$item->ID];
                if (isset($this->eagerLoadingRelatedCache[$depClass][$depID])) {
                    $depRecord = $this->eagerLoadingRelatedCache[$depClass][$depID];
                    $item->setComponent($dep, $depRecord);
                }
            }
        }

        foreach ($this->eagerLoadingRelatedMaps['has_many'] as $dep => $depInfo) {
            $depClass = $depInfo['class'];
            $collection = [];
            if (isset($depInfo['map'][$item->ID])) {
                foreach ($depInfo['map'][$item->ID] as $depID) {
                    if (isset($this->eagerLoadingRelatedCache[$depClass][$depID])) {
                        $depRecord = $this->eagerLoadingRelatedCache[$depClass][$depID];
                        $collection[] = $depRecord;
                    }
                }
            }
            if (!method_exists($item, 'addEagerRelation')) {
                throw new EagerLoadingException(
                    "Model {$item->ClassName} must include " .
                    EagerLoaderMultiAccessor::class .
                    " trait to use eager loading for \$has_many"
                );
            }
            $item->addEagerRelation($dep, $collection);
        }

        foreach ($this->eagerLoadingRelatedMaps['many_many'] as $dep => $depInfo) {
            $depClass = $depInfo['class'];
            $collection = [];
            if (isset($depInfo['map'][$item->ID])) {
                foreach ($depInfo['map'][$item->ID] as $depID) {
                    // foreach ($depIDlist as $depID) {
                        if (isset($this->eagerLoadingRelatedCache[$depClass][$depID])) {
                            $depRecord = $this->eagerLoadingRelatedCache[$depClass][$depID];
                            $collection[] = $depRecord;
                        }
                    // }
                }
            }
            if (!method_exists($item, 'addEagerRelation')) {
                throw new EagerLoadingException(
                    "Model {$item->ClassName} must include " .
                    EagerLoaderMultiAccessor::class .
                    " trait to use eager loading for \$many_many"
                );
            }
            $item->addEagerRelation($dep, $collection);
        }
    }
    /**
     * Returns a generator for this DataList
     *
     * @return \Generator&DataObject[]
     */
    public function getGenerator()
    {
        $query = $this->dataQuery()->execute();

        while ($row = $query->record()) {
            yield $this->createDataObject($row);
        }
    }

    private function eagerLoadingPrepareCache($all, $selected)
    {
        foreach ($selected as $depSeq) {
            $dep = $depSeq[0];
            $depClass = $all[$dep];
            $depClass = $depClass['through'] ?? $depClass;
            if (!isset($this->eagerLoadingRelatedCache[$depClass])) {
                $this->eagerLoadingRelatedCache[$depClass] = [];
            }
        }
    }
}


1		<?php
2		namespace Gurucomkz\EagerLoading;
3
4		use Exception;
5		use SilverStripe\Core\Config\Config;
6		use SilverStripe\ORM\DataList;
7		use SilverStripe\ORM\DataObject;
8		use SilverStripe\ORM\Queries\SQLSelect;
9
10		/**
11		* Replaces DataList when EagerLoading is used. Fetches data when the main query is actually executed.
12		* Appends related objects when a DataObject is actually created.
13		*/
14		class EagerLoadedDataList extends DataList
15		{
16
17		const ID_LIMIT = 5000;
18		public $withList = [];
19		public $withListOriginal = [];
20		public $eagerLoadingRelatedMaps = [
21		'has_one' => [],
22		'has_many' => [],
23		'many_many' => [],
24		];
25
26	12	public function __construct($classOrList)
27		{
28	12	if (is_string($classOrList)) {
29		parent::__construct($classOrList);
30		} else {
31	12	parent::__construct($classOrList->dataClass());
32	12	$this->dataQuery = $classOrList->dataQuery();
33		}
34		}
35
36		public $eagerLoadingRelatedCache = [];
37	12	public static function cloneFrom(DataList $list)
38		{
39	12	$clone = new EagerLoadedDataList($list);
40
41	12	$clone->withList = $list->withList;
42	12	$clone->withListOriginal = $list->withListOriginal;
43	12	$clone->eagerLoadingRelatedCache = $list->eagerLoadingRelatedCache;
44	12	return $clone;
45		}
46
47		/**
48		* Create a DataObject from the given SQL row
49		*
50		* @param array $row
51		* @return DataObject
52		*/
53	12	public function createDataObject($row)
54		{
55	12	$this->prepareEagerRelations();
56	12	$item = parent::createDataObject($row);
57
58	12	$this->fulfillEagerRelations($item);
59	11	return $item;
60		}
61
62		private $relationsPrepared = false;
63
64	12	private function filterWithList($list)
65		{
66	12	return array_filter(
67	12	$this->withList,
68	12	function ($dep) use ($list) {
69	12	return array_key_exists($dep[0], $list);
70	12	}
71	12	);
72		}
73
74	12	public function prepareEagerRelations()
75		{
76	12	if ($this->relationsPrepared) {
77	10	return;
78		}
79	12	$this->relationsPrepared = true;
80	12	$localClass = $this->dataClass();
81	12	$config = Config::forClass($localClass);
82	12	$hasOnes = (array) $config->get('has_one');
83	12	$hasManys = (array) $config->get('has_many');
84	12	$manyManys = (array) $config->get('many_many');
85	12	$belongsManyManys = (array) $config->get('belongs_many_many');
86
87		//collect has_ones
88	12	$withHasOnes = $this->filterWithList($hasOnes);
89	12	$withHasManys = $this->filterWithList($hasManys);
90	12	$withManyManys = $this->filterWithList($manyManys);
91	12	$withBelongsManyManys = $this->filterWithList($belongsManyManys);
92
93	12	if (!count($withHasOnes) && !count($withHasManys) && !count($withManyManys) && !count($withBelongsManyManys)) {
94		// Injector::inst()->get(LoggerInterface::class)
95		// ->debug("Invalid names supplied for ->with(" . implode(', ', $this->withListOriginal) . ")");
96	1	return;
97		}
98
99	11	$data = $this->column('ID');
100	11	if (count($withHasOnes)) {
101	6	$this->eagerLoadingPrepareCache($hasOnes, $withHasOnes);
102	6	$this->eagerLoadHasOne($data, $hasOnes, $withHasOnes);
103		}
104	11	if (count($withHasManys)) {
105	3	$this->eagerLoadingPrepareCache($hasManys, $withHasManys);
106	3	$this->eagerLoadHasMany($data, $hasManys, $withHasManys);
107		}
108	11	if (count($withManyManys)) {
109	4	$this->eagerLoadingPrepareCache($manyManys, $withManyManys);
110	4	$this->eagerLoadManyMany($data, $manyManys, $withManyManys);
111		}
112	11	if (count($withBelongsManyManys)) {
113	1	$this->eagerLoadingPrepareCache($belongsManyManys, $withBelongsManyManys);
114	1	$this->eagerLoadManyMany($data, $belongsManyManys, $withBelongsManyManys);
115		}
116		}
117
118	6	public function eagerLoadHasOne(&$ids, $hasOnes, $withHasOnes)
119		{
120		//collect required IDS
121	6	$fields = ['ID'];
122	6	foreach ($withHasOnes as $depSeq) {
123	6	$dep = $depSeq[0];
124	6	$fields[] = "\"{$dep}ID\"";
125		}
126	6	$table = DataObject::getSchema()->tableName($this->dataClass);
127	6	$data = new SQLSelect($fields, '"' . $table . '"', ['"ID" IN (' . implode(',', $ids) . ')']);
128	6	$data = Utils::EnsureArray($data->execute(), 'ID');
129
130	6	foreach ($withHasOnes as $depSeq) {
131	6	$dep = $depSeq[0];
132	6	$depClass = $hasOnes[$dep];
133
134	6	$descriptor = [
135	6	'class' => $depClass,
136	6	'localField' => "{$dep}ID",
137	6	'map' => [],
138	6	];
139
140	6	$descriptor['map'] = Utils::extractField($data, $descriptor['localField']);
141	6	$uniqueIDs = array_unique($descriptor['map']);
142	6	while (count($uniqueIDs)) {
143	6	$IDsubset = array_splice($uniqueIDs, 0, self::ID_LIMIT);
144	6	$result = DataObject::get($depClass)->filter('ID', $IDsubset);
145	6	if (count($depSeq)>1) {
146	2	$result = $result
147	2	->with(implode('.', array_slice($depSeq, 1)));
148		}
149
150	6	foreach ($result as $depRecord) {
151	6	$this->eagerLoadingRelatedCache[$depClass][$depRecord->ID] = $depRecord;
152		}
153		}
154
155	6	$this->eagerLoadingRelatedMaps['has_one'][$dep] = $descriptor;
156		}
157		}
158
159	3	public function eagerLoadHasMany($data, $hasManys, $withHasManys)
160		{
161	3	$localClass = $this->dataClass();
162	3	$localClassTail = basename(str_replace('\\', '/', $localClass));
163
164	3	foreach ($withHasManys as $depSeq) {
165	3	$dep = $depSeq[0];
166	3	$depClass = $hasManys[$dep];
167	3	if (false !== strpos($depClass, '.')) {
168		$dcSplit = explode('.', $depClass, 2);
169		$depClass = $dcSplit[0];
170		$localNameInDep = $dcSplit[1];
171		} else {
172	3	$localNameInDep = $localClassTail;
173		}
174	3	$depKey = "{$localNameInDep}ID";
175	3	$descriptor = [
176	3	'class' => $depClass,
177	3	'remoteRelation' => $localNameInDep,
178	3	'remoteField' => $depKey,
179	3	'map' => [],
180	3	];
181	3	$result = DataObject::get($depClass)->filter($depKey, $data);
182	3	if (count($depSeq)>1) {
183		$result = $result
184		->with(implode('.', array_slice($depSeq, 1)));
185		}
186
187	3	$collection = [];
188
189	3	foreach ($data as $localRecordID) {
190	3	$collection[$localRecordID] = [];
191		}
192	3	foreach ($result as $depRecord) {
193	3	$this->eagerLoadingRelatedCache[$depClass][$depRecord->ID] = $depRecord;
194	3	$collection[$depRecord->$depKey][] = $depRecord->ID;
195		}
196	3	$descriptor['map'] = $collection;
197	3	$this->eagerLoadingRelatedMaps['has_many'][$dep] = $descriptor;
198		}
199		}
200
201	5	public function eagerLoadManyMany(&$data, $manyManys, $withManyManys)
202		{
203	5	$localClass = $this->dataClass();
204	5	$schema = DataObject::getSchema();
205
206	5	foreach ($withManyManys as $depSeq) {
207	5	$dep = $depSeq[0];
208	5	$depData = $manyManys[$dep];
209
210	5	if (is_array($depData)) {
211	1	if (!isset($depData['from']) \|\| !isset($depData['to']) \|\| !isset($depData['through'])) {
212		throw new Exception(sprintf('Incompatible "many_many through" configuration for %s.%s', $localClass, $dep));
213		}
214	1	$throughClass = $depData['through'];
215		// determine the target data object
216	1	$depClass = $schema->hasOneComponent($depData['through'], $depData['to']);
217	1	if (!$depClass) {
218		throw new Exception(sprintf('Class %s does not have a $has_one component named', $depData['through'], $depData['to']));
219		}
220
221	1	$table = DataObject::getSchema()->tableName($throughClass);
222
223	1	$childField = $depData['to']. 'ID';
224	1	$parentField = $depData['from']. 'ID';
225		} else {
226	4	$depClass = $depData;
227	4	$component = $schema->manyManyComponent($localClass, $dep);
228
229	4	$table = $component['join'];
230	4	$childField = $component['childField'];
231	4	$parentField = $component['parentField'];
232		}
233
234	5	$descriptor = [
235	5	'class' => $depClass,
236	5	'map' => [],
237	5	];
238
239	5	$idsQuery = SQLSelect::create(
240	5	[
241	5	'"' . $childField . '"',
242	5	'"' . $parentField . '"',
243	5	],
244	5	'"' . $table . '"',
245	5	[
246	5	'"' . $parentField . '" IN (' . implode(',', $data) . ')'
247	5	]
248	5	)->execute();
249
250	5	$collection = [];
251	5	$relListReverted = [];
252	5	foreach ($idsQuery as $row) {
253	5	$relID = $row[$childField];
254	5	$localID = $row[$parentField];
255	5	if (!isset($collection[$localID])) {
256	5	$collection[$localID] = [];
257		}
258	5	$collection[$localID][] = $relID;
259	5	$relListReverted[$relID] = 1; //use ids as keys to avoid
260		}
261
262	5	if (count($relListReverted)) {
263	5	$result = DataObject::get($depClass)->filter('ID', array_keys($relListReverted));
264	5	if (count($depSeq)>1) {
265		$result = $result
266		->with(implode('.', array_slice($depSeq, 1)));
267		}
268
269	5	foreach ($result as $depRecord) {
270	5	$this->eagerLoadingRelatedCache[$depClass][$depRecord->ID] = $depRecord;
271		}
272		}
273
274	5	$descriptor['map'] = $collection;
275	5	$this->eagerLoadingRelatedMaps['many_many'][$dep] = $descriptor;
276		}
277		}
278
279	12	public function fulfillEagerRelations(DataObject $item)
280		{
281	12	foreach ($this->eagerLoadingRelatedMaps['has_one'] as $dep => $depInfo) {
282	6	$depClass = $depInfo['class'];
283	6	if (isset($depInfo['map'][$item->ID])) {
284	6	$depID = $depInfo['map'][$item->ID];
285	6	if (isset($this->eagerLoadingRelatedCache[$depClass][$depID])) {
286	6	$depRecord = $this->eagerLoadingRelatedCache[$depClass][$depID];
287	6	$item->setComponent($dep, $depRecord);
288		}
289		}
290		}
291
292	12	foreach ($this->eagerLoadingRelatedMaps['has_many'] as $dep => $depInfo) {
293	3	$depClass = $depInfo['class'];
294	3	$collection = [];
295	3	if (isset($depInfo['map'][$item->ID])) {
296	3	foreach ($depInfo['map'][$item->ID] as $depID) {
297	3	if (isset($this->eagerLoadingRelatedCache[$depClass][$depID])) {
298	3	$depRecord = $this->eagerLoadingRelatedCache[$depClass][$depID];
299	3	$collection[] = $depRecord;
300		}
301		}
302		}
303	3	if (!method_exists($item, 'addEagerRelation')) {
304	1	throw new EagerLoadingException(
305	1	"Model {$item->ClassName} must include " .
306	1	EagerLoaderMultiAccessor::class .
307	1	" trait to use eager loading for \$has_many"
308	1	);
309		}
310	2	$item->addEagerRelation($dep, $collection);
311		}
312
313	11	foreach ($this->eagerLoadingRelatedMaps['many_many'] as $dep => $depInfo) {
314	5	$depClass = $depInfo['class'];
315	5	$collection = [];
316	5	if (isset($depInfo['map'][$item->ID])) {
317	5	foreach ($depInfo['map'][$item->ID] as $depID) {
318		// foreach ($depIDlist as $depID) {
319	5	if (isset($this->eagerLoadingRelatedCache[$depClass][$depID])) {
320	5	$depRecord = $this->eagerLoadingRelatedCache[$depClass][$depID];
321	5	$collection[] = $depRecord;
322		}
323		// }
324		}
325		}
326	5	if (!method_exists($item, 'addEagerRelation')) {
327		throw new EagerLoadingException(
328		"Model {$item->ClassName} must include " .
329		EagerLoaderMultiAccessor::class .
330		" trait to use eager loading for \$many_many"
331		);
332		}
333	5	$item->addEagerRelation($dep, $collection);
334		}
335		}
336		/**
337		* Returns a generator for this DataList
338		*
339		* @return \Generator&DataObject[]
340		*/
341		public function getGenerator()
342		{
343		$query = $this->dataQuery()->execute();
344
345		while ($row = $query->record()) {
346		yield $this->createDataObject($row);
347		}
348		}
349
350	11	private function eagerLoadingPrepareCache($all, $selected)
351		{
352	11	foreach ($selected as $depSeq) {
353	11	$dep = $depSeq[0];
354	11	$depClass = $all[$dep];
355	11	$depClass = $depClass['through'] ?? $depClass;
356	11	if (!isset($this->eagerLoadingRelatedCache[$depClass])) {
357	11	$this->eagerLoadingRelatedCache[$depClass] = [];
358		}
359		}
360		}
361		}
362

gurucomkz / silverstripe-eagerloading

Push — master ( 980dfc...5e8552 )

EagerLoadedDataList::createDataObject() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like