Merge branch 'master' into 3.2-merge

# Conflicts:
#	.github/workflows/test.yml
#	src/collection/tests/ArrTest.php
#	src/pipeline/composer.json
#	src/pipeline/tests/PipelineTest.php
#	src/support/src/Fluent.php
#	src/support/src/Traits/InteractsWithData.php
#	src/support/tests/FluentTest.php

Author: limingxinleo

src/Model/Builder.php

@@ -333,6 +333,18 @@ public function whereKeyNot($id)
         return $this->where($this->model->getQualifiedKeyName(), '!=', $id);
     }
 
+    /**
+     * Exclude the given models from the query results.
+     */
+    public function except(iterable|Model $models): static
+    {
+        return $this->whereKeyNot(
+            $models instanceof Model
+                ? $models->getKey()
+                : ModelCollection::wrap($models)->modelKeys()
+        );
+    }
+
     /**
      * Add a basic where clause to the query.
      *
@@ -592,6 +604,18 @@ public function updateOrCreate(array $attributes, array $values = [])
         });
     }
 
+    /**
+     * Create a record matching the attributes, or increment the existing record.
+     */
+    public function incrementOrCreate(array $attributes, string $column = 'count', float|int $default = 1, float|int $step = 1, array $extra = []): Model
+    {
+        return tap($this->firstOrCreate($attributes, [$column => $default]), function ($instance) use ($column, $step, $extra) {
+            if (! $instance->wasRecentlyCreated) {
+                $instance->increment($column, $step, $extra);
+            }
+        });
+    }
+
     /**
      * Execute the query and get the first result or throw an exception.
      *

src/Model/Casts/ArrayObject.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Database\Model\Casts;
+
+use ArrayObject as BaseArrayObject;
+use Hyperf\Collection\Collection;
+use Hyperf\Contract\Arrayable;
+use JsonSerializable;
+
+/**
+ * @template TKey of array-key
+ * @template TItem
+ * @extends  BaseArrayObject<TKey, TItem>
+ */
+class ArrayObject extends BaseArrayObject implements Arrayable, JsonSerializable
+{
+    /**
+     * Get a collection containing the underlying array.
+     */
+    public function collect(): Collection
+    {
+        return new Collection($this->getArrayCopy());
+    }
+
+    /**
+     * Get the instance as an array.
+     */
+    public function toArray(): array
+    {
+        return $this->getArrayCopy();
+    }
+
+    /**
+     * Get the array that should be JSON serialized.
+     */
+    public function jsonSerialize(): array
+    {
+        return $this->getArrayCopy();
+    }
+}

src/Model/Casts/AsArrayObject.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+/**
+ * This file is part of Hyperf.
+ *
+ * @link     https://www.hyperf.io
+ * @document https://hyperf.wiki
+ * @contact  group@hyperf.io
+ * @license  https://github.com/hyperf/hyperf/blob/master/LICENSE
+ */
+
+namespace Hyperf\Database\Model\Casts;
+
+use Hyperf\Codec\Json;
+use Hyperf\Contract\Castable;
+use Hyperf\Contract\CastsAttributes;
+
+class AsArrayObject implements Castable
+{
+    /**
+     * Get the caster class to use when casting from / to this cast target.
+     * @return CastsAttributes<ArrayObject<array-key, mixed>, iterable>
+     */
+    public static function castUsing(): CastsAttributes
+    {
+        return new class implements CastsAttributes {
+            public function get($model, $key, $value, $attributes)
+            {
+                if (! isset($attributes[$key])) {
+                    return;
+                }
+
+                $data = Json::decode($attributes[$key]);
+
+                return is_array($data) ? new ArrayObject($data, ArrayObject::ARRAY_AS_PROPS) : null;
+            }
+
+            public function set($model, $key, $value, $attributes): array
+            {
+                return [$key => Json::encode($value)];
+            }
+
+            public function serialize($model, string $key, $value, array $attributes)
+            {
+                return $value->getArrayCopy();
+            }
+        };
+    }
+}

src/Model/Model.php

@@ -1197,6 +1197,14 @@ public function setPerPage($perPage)
         return $this;
     }
 
+    /**
+     * Determine if the model is soft deletable.
+     */
+    public static function isSoftDeletable(): bool
+    {
+        return in_array(SoftDeletes::class, class_uses_recursive(static::class));
+    }
+
     /**
      * Determine if the given attribute exists.
      */

src/Model/Relations/BelongsTo.php

@@ -312,6 +312,16 @@ public function getRelation()
         return $this->relationName;
     }
 
+    /**
+     * Alias of "dissociate" method.
+     *
+     * @return Model
+     */
+    public function disassociate()
+    {
+        return $this->dissociate();
+    }
+
     /**
      * Gather the keys from an array of related models.
      *

src/Query/Builder.php

@@ -1478,6 +1478,48 @@ public function orWhereJsonDoesntContain($column, $value)
         return $this->whereJsonDoesntContain($column, $value, 'or');
     }
 
+    /**
+     * Add a where between columns statement using a value to the query.
+     * @param array{Expression|string, Expression|string} $columns
+     */
+    public function whereValueBetween(mixed $value, array $columns, string $boolean = 'and', bool $not = false): static
+    {
+        $type = 'valueBetween';
+
+        $this->wheres[] = compact('type', 'value', 'columns', 'boolean', 'not');
+
+        $this->addBinding($value, 'where');
+
+        return $this;
+    }
+
+    /**
+     * Add an or where between columns statement using a value to the query.
+     * @param array{Expression|string, Expression|string} $columns
+     */
+    public function orWhereValueBetween(mixed $value, array $columns): static
+    {
+        return $this->whereValueBetween($value, $columns, 'or');
+    }
+
+    /**
+     * Add a where not between columns statement using a value to the query.
+     * @param array{Expression|string, Expression|string} $columns
+     */
+    public function whereValueNotBetween(mixed $value, array $columns, string $boolean = 'and'): static
+    {
+        return $this->whereValueBetween($value, $columns, $boolean, true);
+    }
+
+    /**
+     * Add an or where not between columns statement using a value to the query.
+     * @param array{Expression|string, Expression|string} $columns
+     */
+    public function orWhereValueNotBetween(mixed $value, array $columns): static
+    {
+        return $this->whereValueNotBetween($value, $columns, 'or');
+    }
+
     /**
      * Add a "where JSON overlaps" clause to the query.
      */

src/Query/Grammars/Grammar.php

@@ -457,6 +457,20 @@ protected function compileColumns(Builder $query, $columns): ?string
         return $select . $this->columnize($columns);
     }
 
+    /**
+     * Compile a "value between" where clause.
+     */
+    protected function whereValueBetween(Builder $query, array $where): string
+    {
+        $between = $where['not'] ? 'not between' : 'between';
+
+        $min = $this->wrap(is_array($where['columns']) ? reset($where['columns']) : $where['columns'][0]);
+
+        $max = $this->wrap(is_array($where['columns']) ? end($where['columns']) : $where['columns'][1]);
+
+        return $this->parameter($where['value']) . ' ' . $between . ' ' . $min . ' and ' . $max;
+    }
+
     /**
      * Compile the "from" portion of the query.
      *

tests/DatabaseIntegrationTest.php

@@ -264,6 +264,53 @@ public function testWithWhereHasOnNestedSelfReferencingHasManyRelationship()
         $this->assertSame($results->first()->childPosts->pluck('childPosts')->flatten()->pluck('name')->unique()->toArray(), ['Child Post']);
     }
 
+    public function testIncrementOrCreate()
+    {
+        $user1 = ModelTestUser::incrementOrCreate(['email' => 'test@example.com'], 'value');
+        $this->assertTrue($user1->wasRecentlyCreated);
+        $this->assertSame('test@example.com', $user1->email);
+        $this->assertEquals(1, $user1->value);
+
+        $user2 = ModelTestUser::incrementOrCreate(['email' => 'test@example.com'], 'value');
+        $this->assertFalse($user2->wasRecentlyCreated);
+        $this->assertEquals($user1->id, $user2->id);
+        $this->assertEquals(2, $user2->value);
+
+        $user3 = ModelTestUser::incrementOrCreate(['email' => 'test2@example.com'], 'value', 10, 5);
+        $this->assertTrue($user3->wasRecentlyCreated);
+        $this->assertEquals(10, $user3->value);
+
+        $user4 = ModelTestUser::incrementOrCreate(['email' => 'test2@example.com'], 'value', 10, 5);
+        $this->assertFalse($user4->wasRecentlyCreated);
+        $this->assertEquals(15, $user4->value);
+
+        $user5 = ModelTestUser::incrementOrCreate(['email' => 'test3@example.com'], 'value', 1, 1, ['name' => 'Test User']);
+        $this->assertTrue($user5->wasRecentlyCreated);
+        $this->assertEquals(1, $user5->value);
+        $this->assertNull($user5->name);
+
+        $user6 = ModelTestUser::incrementOrCreate(['email' => 'test3@example.com'], 'value', 1, 1, ['name' => 'Updated User']);
+        $this->assertFalse($user6->wasRecentlyCreated);
+        $this->assertEquals(2, $user6->value);
+        $this->assertSame('Updated User', $user6->name);
+    }
+
+    public function testIncrementOrCreateOnDifferentConnection()
+    {
+        $user1 = ModelTestUser::on('second_connection')->incrementOrCreate(['email' => 'test@example.com'], 'value');
+        $this->assertTrue($user1->wasRecentlyCreated);
+        $this->assertSame('second_connection', $user1->getConnectionName());
+        $this->assertEquals(1, $user1->value);
+
+        $user2 = ModelTestUser::on('second_connection')->incrementOrCreate(['email' => 'test@example.com'], 'value');
+        $this->assertFalse($user2->wasRecentlyCreated);
+        $this->assertSame('second_connection', $user2->getConnectionName());
+        $this->assertEquals(2, $user2->value);
+
+        $this->assertEquals(0, ModelTestUser::count());
+        $this->assertEquals(1, ModelTestUser::on('second_connection')->count());
+    }
+
     protected function createSchema(): void
     {
         foreach (['default', 'second_connection'] as $connection) {