Optimise reference filling

Author: Riimu

src/Record.php

@@ -34,7 +34,13 @@ public function __construct(Schema $schema)
 
     public function getPrimaryKeys(): array
     {
-        return array_intersect_key($this->values, array_flip($this->schema->getPrimaryKeys()));
+        $primaryKey = [];
+
+        foreach ($this->schema->getPrimaryKeys() as $key) {
+            $primaryKey[$key] = $this->values[$key];
+        }
+
+        return $primaryKey;
     }
 
     public function isNew(): bool
@@ -93,6 +99,11 @@ public function fillReference(string $name, array $records): void
         $this->relations[$name] = array_values($records);
     }
 
+    public function isReferenceLoaded(string $name): bool
+    {
+        return isset($this->relations[$name]);
+    }
+
     private function isRelated(Reference $relation, Record $record): bool
     {
         if ($relation->getReferencedSchema() !== $record->getSchema()) {

src/ReferenceFiller.php

@@ -39,8 +39,7 @@ public function fill(array $records, array $references): void
                 throw new \InvalidArgumentException('The provided list of records did not share the same schema');
             }
 
-            $recordId = $this->getRecordId($schema, $record->getDatabaseValues());
-            $this->cache[$schemaId][$recordId] = $record;
+            $this->cacheRecord($schemaId, $record);
         }
 
         $this->fillReferences($records, $references);
@@ -65,21 +64,43 @@ private function fillReferences(array $records, array $references): void
                 throw new \RuntimeException('Filling references for composite foreign keys is not supported');
             }
 
+            $isPrimaryReference = $fields === $parent->getPrimaryKeys();
             $key = array_pop($keys);
             $field = array_pop($fields);
             $options = [];
+            $sorted = [];
 
             foreach ($records as $record) {
-                $options[] = $record[$key];
+                $value = $record[$key];
+
+                if ($record->isReferenceLoaded($name)) {
+                    $sorted[$value] = $record->getReference($name);
+
+                    foreach ($sorted[$value] as $referencedRecord) {
+                        $this->cacheRecord($schemaId, $referencedRecord);
+                    }
+
+                    continue;
+                }
+
+                if ($isPrimaryReference && isset($this->cache[$schemaId][$value])) {
+                    $sorted[$value] = [$this->cache[$schemaId][$value]];
+                    continue;
+                }
+
+                $options[$value] = true;
             }
 
-            $result = $this->connection->select($parent->getFields(), $parent->getTable(), [$field => $options]);
-            $result->setFetchMode(\PDO::FETCH_ASSOC);
-            $sorted = [];
+            $options = array_keys(array_diff_key($options, $sorted));
 
-            foreach ($result as $row) {
-                $record = $this->getCachedRecord($schemaId, $parent, $row);
-                $sorted[$record[$field]][] = $record;
+            if ($options) {
+                $result = $this->connection->select($parent->getFields(), $parent->getTable(), [$field => $options]);
+                $result->setFetchMode(\PDO::FETCH_ASSOC);
+
+                foreach ($result as $row) {
+                    $record = $this->getCachedRecord($schemaId, $parent, $row);
+                    $sorted[$record[$field]][] = $record;
+                }
             }
 
             foreach ($records as $record) {
@@ -111,9 +132,21 @@ private function parseReferences(array $references): array
         return $subReferences;
     }
 
+    private function cacheRecord(string $schemaId, Record $record): void
+    {
+        $recordId = implode('-', $record->getPrimaryKeys());
+        $this->cache[$schemaId][$recordId] = $record;
+    }
+
     private function getCachedRecord(string $schemaId, Schema $schema, array $row): Record
     {
-        $recordId = $this->getRecordId($schema, $row);
+        $primaryKey = [];
+
+        foreach ($schema->getPrimaryKeys() as $key) {
+            $primaryKey[] = $row[$key];
+        }
+
+        $recordId = implode('-', $primaryKey);
 
         if (isset($this->cache[$schemaId][$recordId])) {
             return $this->cache[$schemaId][$recordId];
@@ -128,19 +161,4 @@ private function getSchemaId(Schema $schema): string
     {
         return spl_object_hash($schema);
     }
-
-    private function getRecordId(Schema $schema, array $row)
-    {
-        $values = [];
-
-        foreach ($schema->getPrimaryKeys() as $key) {
-            if (!isset($row[$key])) {
-                throw new \RuntimeException('Cannot determine cache id for record');
-            }
-
-            $values[] = $row[$key];
-        }
-
-        return implode('-', $values);
-    }
 }