Merge pull request #29 from BlueFeatherGroup/add-eager-loading

Add eager loading

Author: Smef

src/Database/Eloquent/FMEloquentBuilder.php

@@ -23,7 +23,17 @@ public function get($columns = ['*'])
     {
         $records = $this->tobase()->get();
         $models = $this->model->createModelsFromRecordSet($records);
-        return $models;
+
+        // If we actually found models we will also eager load any relationships that
+        // have been specified as needing to be eager loaded, which will solve the
+        // n+1 query issue for the developers to avoid running a lot of queries.
+        if (count($models) > 0) {
+            $models = $this->eagerLoadRelations($models->all());
+        } else {
+            $models = $models->all();
+        }
+
+        return $this->getModel()->newCollection($models);
     }
 
 
@@ -355,4 +365,4 @@ protected function getOnlyModifiedPortalFields($array1, $array2): array
     }
 
 
-}
+}

src/Database/Eloquent/Relations/BelongsTo.php

@@ -20,4 +20,48 @@ public function addConstraints()
             $this->query->where($this->ownerKey, '==', $this->child->{$this->foreignKey});
         }
     }
-}
+
+    /**
+     * Set the constraints for an eager load of the relation.
+     *
+     * @param  array  $models
+     * @return void
+     */
+    public function addEagerConstraints(array $models)
+    {
+        // We'll grab the primary key name of the related models since it could be set to
+        // a non-standard name and not "id". We will then construct the constraint for
+        // our eagerly loading query so it returns the proper models from execution.
+        $key = $this->ownerKey;
+
+        $whereIn = $this->whereInMethod($this->related, $this->ownerKey);
+
+        $this->query->{$whereIn}($key, $this->getEagerModelKeys($models));
+    }
+
+    /**
+     * Gather the keys from an array of related models.
+     *
+     * @param  array  $models
+     * @return array
+     */
+    protected function getEagerModelKeys(array $models)
+    {
+        $keys = [];
+
+        // First we need to gather all of the keys from the parent models so we know what
+        // to query for via the eager loading query. We will add them to an array then
+        // execute a "where in" statement to gather up all of those related records.
+        foreach ($models as $model) {
+            $value = $model->{$this->foreignKey};
+            // Unlike other DB Engines FM does not support nulls and uses an empty string instead.
+            if (! is_null($value) && $value !== '') {
+                $keys[] = $value;
+            }
+        }
+
+        sort($keys);
+
+        return array_values(array_unique($keys));
+    }
+}

src/Database/Query/FMBaseBuilder.php

@@ -4,11 +4,13 @@
 namespace BlueFeather\EloquentFileMaker\Database\Query;
 
 
+use _PHPStan_59fb0a3b2\Symfony\Component\String\Exception\RuntimeException;
 use BlueFeather\EloquentFileMaker\Exceptions\FileMakerDataApiException;
 use DateTimeInterface;
 use Illuminate\Database\Query\Builder;
 use Illuminate\Http\File;
 use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Arr;
 use Illuminate\Support\Collection;
 use InvalidArgumentException;
 
@@ -124,6 +126,8 @@ class FMBaseBuilder extends Builder
     public $containerFieldName;
     public $containerFile;
 
+    protected $whereIns = [];
+
 
     /**
      * Add a basic where clause to the query.
@@ -160,7 +164,7 @@ public function where($column, $operator = null, $value = null, $boolean = 'and'
         // Create a new find array if null
         $count = sizeof($this->wheres);
         if ($count == 0) {
-            $currentFind = collect([]);
+            $currentFind = [];
         } else {
             $currentFind = $this->wheres[sizeof($this->wheres) - 1];
         }
@@ -183,13 +187,13 @@ public function where($column, $operator = null, $value = null, $boolean = 'and'
     public function delete($id = null): int
     {
         // If an ID is passed to the method we will delete the record with this internal FileMaker record ID
-        if (! is_null($id)) {
+        if (!is_null($id)) {
             $this->where($this->defaultKeyName(), '=', $id);
         }
         $this->applyBeforeQueryCallbacks();
 
         // Check if we have a record ID to delete or if this is a query for a bulk delete
-        if ($this->getRecordId() === null){
+        if ($this->getRecordId() === null) {
             // There's no individual record ID to delete, so do a bulk delete
             return $this->bulkDeleteFromQuery();
         }
@@ -403,6 +407,8 @@ public function layoutResponse($name): FMBaseBuilder
      */
     public function get($columns = ['*'])
     {
+        $this->computeWhereIns();
+
         // Run the query and catch a 401 error if there are no records found - just return an empty collection
         try {
             $response = $this->connection->performFind($this);
@@ -492,6 +498,58 @@ public function omit($boolean = true): FMBaseBuilder
         return $this;
     }
 
+    public function whereIn($column, $values, $boolean = 'and', $not = false)
+    {
+        throw_if($boolean === 'or', new \RuntimeException('Eloquent FileMaker does not currently support or within a where in'));
+
+        $this->whereIns[] = [
+            'column' => $this->getMappedFieldName($column),
+            'values' => $values,
+            'boolean' => $boolean,
+            'not' => $not
+        ];
+
+        return $this;
+    }
+
+    protected function computeWhereIns()
+    {
+        // If no where in clauses return
+        if (empty($this->whereIns)) {
+            return;
+        }
+
+        $whereIns = array_map(function ($whereIn) {
+            $finds = [];
+
+            foreach ($whereIn['values'] as $value) {
+                $find = [
+                    $whereIn['column'] => $value,
+                ];
+
+                if ($whereIn['not']) {
+                    $find['omit'] = true;
+                }
+
+                $finds[] = $find;
+            }
+
+            return $finds;
+        }, $this->whereIns);
+
+        if (empty($this->wheres)) {
+            $this->wheres = Arr::flatten($whereIns, 1);
+            return;
+        }
+
+        $arr = Arr::crossJoin($this->wheres, ...$whereIns);
+        $function = function ($conditions) {
+            return array_merge(...array_values($conditions));
+        };
+
+        $this->wheres = array_map($function, $arr);
+    }
+
     /**
      * Retrieve the minimum value of a given column.
      *
@@ -621,6 +679,8 @@ public function update(array $values)
 
         $this->fieldData($values);
 
+        $this->computeWhereIns();
+
         return $this->connection->update($this);
     }