Support insertOrIgnoreUsing to \Hyperf\Database\Query\Builder (#6783)

Author: zds-s

src/Model/Builder.php

@@ -94,7 +94,7 @@ class Builder
     protected $passthru = [
         'insert', 'insertGetId', 'getBindings', 'toSql', 'toRawSql', 'insertOrIgnore',
         'exists', 'doesntExist', 'count', 'min', 'max', 'avg', 'average', 'sum', 'getConnection',
-        'upsert', 'updateOrInsert',
+        'upsert', 'updateOrInsert', 'insertOrIgnoreUsing',
     ];
 
     /**

src/Query/Builder.php

@@ -2441,6 +2441,19 @@ public function insertUsing(array $columns, $query)
         return $this->connection->insert($this->grammar->compileInsertUsing($this, $columns, $sql), $this->cleanBindings($bindings));
     }
 
+    /**
+     * Insert new records into the table using a subquery while ignoring errors.
+     */
+    public function insertOrIgnoreUsing(array $columns, array|Builder|Closure|ModelBuilder|string $query): int
+    {
+        [$sql, $bindings] = $this->createSub($query);
+
+        return $this->connection->affectingStatement(
+            $this->grammar->compileInsertOrIgnoreUsing($this, $columns, $sql),
+            $this->cleanBindings($bindings)
+        );
+    }
+
     /**
      * Insert ignore a new record into the database.
      */

src/Query/Grammars/Grammar.php

@@ -163,7 +163,20 @@ public function compileInsertGetId(Builder $query, $values, $sequence): string
      */
     public function compileInsertUsing(Builder $query, array $columns, string $sql): string
     {
-        return "insert into {$this->wrapTable($query->from)} ({$this->columnize($columns)}) {$sql}";
+        $table = $this->wrapTable($query->from);
+        if (empty($columns) || $columns === ['*']) {
+            return "insert into {$table} {$sql}";
+        }
+
+        return "insert into {$table} ({$this->columnize($columns)}) {$sql}";
+    }
+
+    /**
+     * Compile an insert ignore statement using a subquery into SQL.
+     */
+    public function compileInsertOrIgnoreUsing(Builder $query, array $columns, string $sql): string
+    {
+        throw new RuntimeException('This database engine does not support inserting while ignoring errors.');
     }
 
     /**

src/Query/Grammars/MySqlGrammar.php

@@ -17,6 +17,7 @@
 use Hyperf\Database\Query\IndexHint;
 use Hyperf\Database\Query\JoinLateralClause;
 use Hyperf\Database\Query\JsonExpression;
+use Hyperf\Stringable\Str;
 
 use function Hyperf\Collection\collect;
 
@@ -71,6 +72,14 @@ public function compileInsertOrIgnore(Builder $query, array $values): string
         return substr_replace($this->compileInsert($query, $values), ' ignore', 6, 0);
     }
 
+    /**
+     * Compile an insert ignore statement using a subquery into SQL.
+     */
+    public function compileInsertOrIgnoreUsing(Builder $query, array $columns, string $sql): string
+    {
+        return Str::replaceFirst('insert', 'insert ignore', $this->compileInsertUsing($query, $columns, $sql));
+    }
+
     /**
      * Compile the random statement into SQL.
      *

tests/DatabaseQueryBuilderTest.php

@@ -13,6 +13,7 @@
 namespace HyperfTest\Database;
 
 use Hyperf\Context\ApplicationContext;
+use Hyperf\Database\Connection;
 use Hyperf\Database\ConnectionInterface;
 use Hyperf\Database\Exception\InvalidBindingException;
 use Hyperf\Database\Query\Builder;
@@ -21,11 +22,13 @@
 use Hyperf\Database\Query\Grammars\MySqlGrammar;
 use Hyperf\Database\Query\Processors\MySqlProcessor;
 use Hyperf\Database\Query\Processors\Processor;
+use InvalidArgumentException;
 use Mockery as m;
 use Mockery\MockInterface;
 use PHPUnit\Framework\Attributes\CoversNothing;
 use PHPUnit\Framework\TestCase;
 use Psr\Container\ContainerInterface;
+use RuntimeException;
 use TypeError;
 
 /**
@@ -889,6 +892,63 @@ public function testWhereAny()
         $this->assertEquals(['%Otwell%', '%Otwell%'], $builder->getBindings());
     }
 
+    public function testInsertOrIgnoreUsingMethod(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('does not support');
+        $builder = $this->getBuilder();
+        $builder->from('users')->insertOrIgnoreUsing(['email' => 'foo'], 'bar');
+    }
+
+    public function testMySqlInsertOrIgnoreUsingMethod(): void
+    {
+        $builder = $this->getMySqlBuilder();
+        $builder->getConnection()->shouldReceive('getDatabaseName');
+        $builder->getConnection()->shouldReceive('affectingStatement')->once()->with('insert ignore into `table1` (`foo`) select `bar` from `table2` where `foreign_id` = ?', [0 => 5])->andReturn(1);
+
+        $result = $builder->from('table1')->insertOrIgnoreUsing(
+            ['foo'],
+            function (Builder $query) {
+                $query->select(['bar'])->from('table2')->where('foreign_id', '=', 5);
+            }
+        );
+
+        $this->assertEquals(1, $result);
+    }
+
+    public function testMySqlInsertOrIgnoreUsingWithEmptyColumns(): void
+    {
+        $builder = $this->getMySqlBuilder();
+        /**
+         * @var Connection&MockInterface $connection
+         */
+        $connection = $builder->getConnection();
+        $connection->allows('getDatabaseName');
+        $connection->allows('affectingStatement')
+            ->once()
+            ->andReturnUsing(function ($sql, $bindings) {
+                $this->assertSame('insert ignore into `table1` select * from `table2` where `foreign_id` = ?', $sql);
+                $this->assertSame([0 => 5], $bindings);
+                return 1;
+            });
+
+        $result = $builder->from('table1')->insertOrIgnoreUsing(
+            [],
+            function (Builder $query) {
+                $query->from('table2')->where('foreign_id', '=', 5);
+            }
+        );
+
+        $this->assertEquals(1, $result);
+    }
+
+    public function testMySqlInsertOrIgnoreUsingInvalidSubquery(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $builder = $this->getMySqlBuilder();
+        $builder->from('table1')->insertOrIgnoreUsing(['foo'], ['bar']);
+    }
+
     public function testOrWhereAny()
     {
         $builder = $this->getBuilder();

tests/ModelBuilderTest.php

@@ -600,8 +600,11 @@ public function testQueryPassThru()
         $this->assertInstanceOf(Builder::class, $builder->foobar());
 
         $builder = $this->getBuilder();
-        $builder->getQuery()->shouldReceive('insert')->once()->with(['bar'])->andReturn('foo');
+        $builder->getQuery()->shouldReceive('insertOrIgnoreUsing')->once()->with(['bar'], 'baz')->andReturn(1);
+        $this->assertSame(1, $builder->insertOrIgnoreUsing(['bar'], 'baz'));
 
+        $builder = $this->getBuilder();
+        $builder->getQuery()->shouldReceive('insert')->once()->with(['bar'])->andReturn('foo');
         $this->assertEquals('foo', $builder->insert(['bar']));
     }