Chunk write

composer.json

@@ -13,11 +13,14 @@
     ],
     "require": {
         "php": ">=8.1",
+        "h4kuna/serialize-polyfill": "^0.2.4",
         "laravel/framework": "^9",
         "psr/log": "^2 | ^3",
         "psr/simple-cache": "^3.0"
     },
     "require-dev": {
+        "ext-pdo": "*",
+        "ext-sqlite3": "*",
         "mockery/mockery": "^1.5.0",
         "nette/php-generator": "v4.0.5",
         "nikic/php-parser": "v4.15.2",

phpstan-baseline.neon

@@ -25,6 +25,23 @@ parameters:
 			count: 1
 			path: src/Testing/Actions/ParsePhpDocAction.php
 
+		# forward compatibility
+		-
+			message: "#^Attribute class PHPUnit\\\\Framework\\\\Attributes\\\\Before does not exist\\.$#"
+			count: 1
+			path: src/Testing/Assert/AssertExpectationTestCase.php
+
+		-
+			message: "#^Attribute class PHPUnit\\\\Framework\\\\Attributes\\\\PostCondition does not exist\\.$#"
+			count: 1
+			path: src/Testing/Assert/AssertExpectationTestCase.php
+
+		-
+			message: "#^Method LaraStrict\\\\Testing\\\\Assert\\\\AssertExpectationTestCase\\:\\:beforeStartAssertExpectationManager\\(\\) has no return type specified\\.$#"
+			count: 1
+			path: src/Testing/Assert/AssertExpectationTestCase.php
+		# forward compatibility
+
 		-
 			message: "#^Call to method PHPUnit\\\\Framework\\\\Assert\\:\\:assertTrue\\(\\) with false and 'Hook should be…' will always evaluate to false\\.$#"
 			count: 1

src/Console/Jobs/CommandInQueueJob.php

@@ -4,6 +4,7 @@
 
 namespace LaraStrict\Console\Jobs;
 
+use h4kuna\Serialize\Serialize;
 use Illuminate\Contracts\Console\Kernel;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Psr\Log\LoggerInterface;
@@ -31,7 +32,7 @@ public function __construct(
         }
 
         ksort($parameters);
-        $this->parametersKey = md5(serialize($parameters));
+        $this->parametersKey = md5(Serialize::encode($parameters));
     }
 
     public function handle(Kernel $kernel, ConsoleOutput $consoleOutput, LoggerInterface $logger): void

src/Database/Contracts/ChunkWriteServiceContract.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaraStrict\Database\Contracts;
+
+use Closure;
+use Generator;
+use Illuminate\Database\Eloquent\Model;
+use LaraStrict\Database\Entities\ChunkWriteStateEntity;
+
+interface ChunkWriteServiceContract
+{
+    /**
+     * @param Closure(): Generator<int, Model> $closure
+     */
+    public function write(Closure $closure): ChunkWriteStateEntity;
+}

src/Database/Entities/ChunkWriteStateEntity.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaraStrict\Database\Entities;
+
+use Illuminate\Database\Eloquent\Model;
+
+class ChunkWriteStateEntity
+{
+    /**
+     * @param class-string<Model>|null $modelClass
+     * @param array<array<string, string|int|bool|float>> $toWrite
+     */
+    public function __construct(
+        public int $batchSize = 0,
+        public ?string $modelClass = null,
+        public int $insertedCount = 0,
+        public int $attributesCount = 0,
+        public array $toWrite = [],
+    ) {
+    }
+}

src/Database/Services/ChunkWriteService.php

@@ -0,0 +1,82 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaraStrict\Database\Services;
+
+use Closure;
+use Illuminate\Database\Eloquent\Model;
+use LaraStrict\Database\Contracts\ChunkWriteServiceContract;
+use LaraStrict\Database\Entities\ChunkWriteStateEntity;
+use LogicException;
+
+final class ChunkWriteService implements ChunkWriteServiceContract
+{
+    public function write(Closure $closure, int $batchSize = 0): ChunkWriteStateEntity
+    {
+        $writeState = new ChunkWriteStateEntity(batchSize: $batchSize);
+
+        foreach ($closure() as $model) {
+            $this->add($model, $writeState);
+        }
+
+        $this->finish($writeState);
+
+        return $writeState;
+    }
+
+    private function add(Model $model, ChunkWriteStateEntity $state): void
+    {
+        if ($model->usesTimestamps()) {
+            $model->updateTimestamps();
+        }
+
+        /** @var array<string, string|int|bool|float> $attributes */
+        $attributes = $model->getAttributes();
+        $attributesCount = count($attributes);
+
+        $modelClass = $model::class;
+
+        if ($state->modelClass === null) {
+            $state->modelClass = $modelClass;
+        } elseif ($state->modelClass !== $modelClass) {
+            throw new LogicException(sprintf(
+                'Batch insert must contain items with same class <%s> got <%s>',
+                $state->modelClass,
+                $modelClass
+            ));
+        }
+
+        // We need to prevent insert max statements by limiting number of insert
+        if ($state->batchSize === 0) {
+            $state->batchSize = (int) (65536 / $attributesCount);
+        }
+
+        if ($state->attributesCount !== 0 && $state->attributesCount !== $attributesCount) {
+            throw new LogicException('Batch insert must contain items with same attributes count' . print_r(
+                $attributes,
+                true
+            ));
+        }
+
+        $state->toWrite[] = $attributes;
+        $state->attributesCount = $attributesCount;
+
+        if ($state->batchSize === count($state->toWrite)) {
+            $this->finish($state);
+        }
+    }
+
+    private function finish(ChunkWriteStateEntity $state): void
+    {
+        if ($state->toWrite === [] || $state->modelClass === null) {
+            return;
+        }
+
+        // Do not fail on duplicated entries.
+        $count = $state->modelClass::insertOrIgnore($state->toWrite);
+
+        $state->insertedCount += $count;
+        $state->toWrite = [];
+    }
+}

src/Testing/Assert/AssertExpectationManager.php

@@ -18,11 +18,7 @@ final class AssertExpectationManager
 
     public static function getInstance(): self
     {
-        if (self::$singleton === null) {
-            self::$singleton = new self();
-        }
-
-        return self::$singleton;
+        return self::$singleton ??= new self();
     }
 
     public static function resetSingleton(): void

src/Testing/Assert/Traits/AssertExpectationManagerTrait.php

@@ -5,32 +5,31 @@
 namespace LaraStrict\Testing\Assert\Traits;
 
 use LaraStrict\Testing\Assert\AssertExpectationManager;
+use PHPUnit\Framework\Attributes\Before;
+use PHPUnit\Framework\Attributes\PostCondition;
 
 trait AssertExpectationManagerTrait
 {
-    protected function setUp(): void
+    /**
+     * @before
+     */
+    #[Before]
+    protected function beforeStartAssertExpectationManager()
     {
-        parent::setUp();
-
         AssertExpectationManager::getInstance()->reset();
     }
 
-    protected function assertPostConditions(): void
+    /**
+     * @postCondition
+     */
+    #[PostCondition]
+    protected function postConditionStartAssertExpectationManager(): void
     {
         $manager = AssertExpectationManager::getInstance();
 
         if ($manager->hasExpectations()) {
             $this->addToAssertionCount(1);
             $manager->assertCalled();
         }
-
-        parent::assertPostConditions();
-    }
-
-    protected function tearDown(): void
-    {
-        AssertExpectationManager::getInstance()->reset();
-
-        parent::tearDown();
     }
 }

src/Tests/Traits/SqlTestEnable.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaraStrict\Tests\Traits;
+
+use Illuminate\Contracts\Database\Query\Builder;
+use Illuminate\Database\ConnectionResolver;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\SQLiteConnection;
+use PDO;
+use PHPUnit\Framework\Assert;
+
+trait SqlTestEnable
+{
+    /**
+     * @beforeClass
+     */
+    final public static function beforeClassSqlTestEnable(): void
+    {
+        $resolver = new ConnectionResolver([
+            'default' => new SQLiteConnection(new PDO('sqlite::memory:')),
+        ]);
+        $resolver->setDefaultConnection('default');
+        Model::setConnectionResolver($resolver);
+    }
+
+    final protected static function assertQuerySql(
+        string $expectedSql,
+        array $expectedBindings,
+        Builder $query,
+    ): void {
+        Assert::assertSame(trim($expectedSql), $query->toSql());
+        Assert::assertSame($expectedBindings, $query->getBindings());
+    }
+}

tests/Unit/Database/Services/ChunkWriteServiceTest.php

@@ -0,0 +1,58 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\LaraStrict\Unit\Database\Services;
+
+use Closure;
+use LaraStrict\Database\Entities\ChunkWriteStateEntity;
+use LaraStrict\Database\Services\ChunkWriteService;
+use LaraStrict\Tests\Traits\SqlTestEnable;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+
+final class ChunkWriteServiceTest extends TestCase
+{
+    use SqlTestEnable;
+
+    /**
+     * @return array<string|int, array{0: Closure(static):void}>
+     */
+    public static function data(): array
+    {
+        return [
+            [
+                'empty' => static function (self $self) {
+                    $self->assert(new ChunkWriteStateEntity(), static function () {
+                        yield from [];
+                    },);
+                },
+            ],
+            [
+                static function (self $self) {
+                    $self->assert(
+                        new ChunkWriteStateEntity(32768, TestModel::class, 3, 2),
+                        static function () {
+                            yield from [new TestModel(), new TestModel(), new TestModel()];
+                        },
+                    );
+                },
+            ],
+        ];
+    }
+
+    /**
+     * @param Closure(static):void $assert
+     * @dataProvider data
+     */
+    public function test(Closure $assert): void
+    {
+        $assert($this);
+    }
+
+    public function assert(ChunkWriteStateEntity $expected, Closure $data): void
+    {
+        $state = (new ChunkWriteService())->write($data);
+        Assert::assertEquals($expected, $state);
+    }
+}

tests/Unit/Database/Services/TestModel.php

@@ -0,0 +1,15 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\LaraStrict\Unit\Database\Services;
+
+use Illuminate\Database\Eloquent\Model;
+
+final class TestModel extends Model
+{
+    public static function insertOrIgnore(array $data): int
+    {
+        return count($data);
+    }
+}