README

NeoEloquent

Neo4j图数据库的Laravel Eloquent驱动器

聊天 & 支持

加入官方Neo4j Slack群组并使用#neo4j-php频道。

快速参考

安装
配置
模型
关系
边
迁移
模式
聚合
仅Neo4j中存在
要避免的事项

安装

将包添加到您的composer.json中，并运行composer update。

Laravel 5

5.6

{
    "require": {
        "vinelab/neoeloquent": "^1.4.6"
    }
}

5.5

{
    "require": {
        "vinelab/neoeloquent": "^1.4.5"
    }
}

5.4

{
    "require": {
        "vinelab/neoeloquent": "1.4.3"
    }
}

5.3

{
    "require": {
        "vinelab/neoeloquent": "1.4.2"
    }
}

5.2

{
    "require": {
        "vinelab/neoeloquent": "1.3.*"
    }
}

5.1

{
    "require": {
        "vinelab/neoeloquent": "1.2.*"
    }
}

5.0

{
    "require": {
        "vinelab/neoeloquent": "1.2.5"
    }
}

Laravel 4

{
    "require": {
        "vinelab/neoeloquent": "1.1.*"
    }
}

在app/config/app.php中添加服务提供者

'Vinelab\NeoEloquent\NeoEloquentServiceProvider',

服务提供者将注册此包所需的全部类，并将Model类别名为NeoEloquent，这样您就可以在模型中简单地扩展NeoEloquent。

配置

连接

在app/config/database.php中或根据基于环境的配置app/config/[env]/database.php，将neo4j作为默认连接

'default' => 'neo4j',

添加连接默认值

'connections' => [
    'neo4j' => [
        'driver' => 'neo4j',
        'host'   => env('DB_HOST', 'localhost'),
        'port'   => env('DB_PORT', '7474'),
        'username' => env('DB_USERNAME', null),
        'password' => env('DB_PASSWORD', null)
    ]
]

Lumen

对于Lumen，您需要在应用程序根目录下创建一个名为config的新文件夹，并在其中添加一个名为database.php的文件。在那里，您将添加以下代码。

<?php

return ['connections' => [
            'neo4j' => [
                'driver' => 'neo4j',
                'host'   => env('DB_HOST', 'localhost'),
                'port'   => env('DB_PORT', '7474'),
                'username' => env('DB_USERNAME', null),
                'password' => env('DB_PASSWORD', null)
            ]
        ]
    ];

并在bootstrap/app.php中添加以下行

$app->configure('database');

这是为了使Lumen能够读取除了提供的默认配置之外的配置。

在添加服务提供者时。您必须在bootstrap/app.php的“注册提供者”部分中添加它。您可以这样添加

$app->register('Vinelab\NeoEloquent\NeoEloquentServiceProvider');

迁移设置

如果您愿意使用迁移

创建文件夹app/database/labels
修改composer.json并将app/database/labels添加到classmap数组中
运行composer dump-autoload

文档

class User extends NeoEloquent {}

NeoEloquent与它一样简单，将从类名生成默认节点标签，在这种情况下，它将是:User。有关节点标签的更多信息，请参阅此处

命名空间模型

当您使用模型中的命名空间时，标签将考虑完整的命名空间。

namespace Vinelab\Cms;

class Admin extends NeoEloquent { }

从该关系生成的标签将是VinelabCmsAdmin，这是确保在引入另一个Admin实例（如Vinelab\Blog\Admin）时标签不会冲突的必要条件，这会使数据库中的:Admin变得混乱。

自定义节点标签

您可以指定要使用的标签（而不是默认生成的标签），它们也是大小写敏感的，因此将按照此处存储的方式存储。

class User extends NeoEloquent {

    protected $label = 'User'; // or array('User', 'Fan')

    protected $fillable = ['name', 'email'];
}

$user = User::create(['name' => 'Some Name', 'email' => 'some@email.com']);

NeoEloquent为$table变量提供了回退支持，如果找到并且模型上没有定义$label，则将使用它。

class User extends NeoEloquent {

    protected $table = 'User';

}

不要担心标签的格式，您可以将它们指定为array('Label1', 'Label2')或用逗号分隔，并在前面添加一个冒号:是可选的。

软删除

Laravel 5

要启用软删除，您需要使用use Vinelab\NeoEloquent\Eloquent\SoftDeletes代替Illuminate\Database\Eloquent\SoftDeletes，并且就像Eloquent一样，您需要在模型中包含$dates，如下所示

use Vinelab\NeoEloquent\Eloquent\SoftDeletes;

class User extends NeoEloquent {

    use SoftDeletes;

    protected $dates = ['deleted_at'];

}

Laravel 4

要启用软删除，您需要使用use Vinelab\NeoEloquent\Eloquent\SoftDeletingTrait代替Illuminate\Database\Eloquent\SoftDeletingTrait，并且就像Eloquent一样，您需要在模型中包含$dates，如下所示

use Vinelab\NeoEloquent\Eloquent\SoftDeletingTrait;

class User extends NeoEloquent {

    use SoftDeletingTrait;

    protected $dates = ['deleted_at'];

}

关系

一对一
一对多
多对多
多态

让我们通过一些节点之间关系的例子来进行说明。

一对一

class User extends NeoEloquent {

    public function phone()
    {
        return $this->hasOne('Phone');
    }

这代表从 :User 节点到 :Phone 的一个 OUTGOING 关系方向。

保存

$phone = new Phone(['code' => 961, 'number' => '98765432'])
$relation = $user->phone()->save($phone);

此语句执行的 Cypher 将如下所示

MATCH (user:`User`)
WHERE id(user) = 1
CREATE (user)-[:PHONE]->(phone:`Phone` {code: 961, number: '98765432', created_at: 7543788, updated_at: 7543788})
RETURN phone;

定义此关系的反向

class Phone extends NeoEloquent {

    public function user()
    {
        return $this->belongsTo('User');
    }
}

这代表从 :User 节点到该 :Phone 节点的 INCOMING 关系方向。

关联模型

由于我们不处理外键，在我们的例子中，这不仅仅是设置父模型的 foreign key 属性。在 Neo4j（以及图数据库）中，关系本身就是一个实体，它也可以有自己的属性，因此引入了边

注意：关联模型在调用 associate() 时不会自动持久化关系。

$account = Account::find(1986);

// $relation will be Vinelab\NeoEloquent\Eloquent\Edges\EdgeIn
$relation = $user->account()->associate($account);

// Save the relation
$relation->save();

此语句执行的 Cypher 将如下所示

MATCH (account:`Account`), (user:`User`)
WHERE id(account) = 1986 AND id(user) = 9862
MERGE (account)<-[rel_user_account:ACCOUNT]-(user)
RETURN rel_user_account;

一对多

class User extends NeoEloquent {

    public function posts()
    {
        return $this->hasMany('Post', 'POSTED');
    }
}

这代表从 :User 节点到 :Post 节点的 OUTGOING 关系方向。

$user = User::find(1);
$post = new Post(['title' => 'The Title', 'body' => 'Hot Body']);
$user->posts()->save($post);

类似于 One-To-One 关系，save() 语句返回的值是一个 Edge[In|Out]

此语句执行的 Cypher 将如下所示

MATCH (user:`User`)
WHERE id(user) = 1
CREATE (user)-[rel_user_post:POSTED]->(post:`Post` {title: 'The Title', body: 'Hot Body', created_at: '15-05-2014', updated_at: '15-05-2014'})
RETURN rel_user_post;

定义此关系的反向

class Post extends NeoEloquent {

    public function author()
    {
        return $this->belongsTo('User', 'POSTED');
    }
}

这代表从 :User 节点到该 :Post 节点的 INCOMING 关系方向。

多对多

class User extends NeoEloquent {

    public function followers()
    {
        return $this->belongsToMany('User', 'FOLLOWS');
    }
}

这代表一个 :User 节点与另一个 :User 节点之间的 INCOMING 关系。

$jd = User::find(1012);
$mc = User::find(1013);

$jd 关注 $mc

$jd->followers()->save($mc);

或者使用 attach() 方法

$jd->followers()->attach($mc);
// Or..
$jd->followers()->attach(1013); // 1013 being the id of $mc ($mc->getKey())

此语句执行的 Cypher 将如下所示

MATCH (user:`User`), (followers:`User`)
WHERE id(user) = 1012 AND id(followers) = 1013
CREATE (followers)-[:FOLLOWS]->(user)
RETURN rel_follows;

$mc 逆向关注 $jd

$mc->followers()->save($jd);

此语句执行的 Cypher 将如下所示

MATCH (user:`User`), (followers:`User`)
WHERE id(user) = 1013 AND id(followers) = 1012
CREATE (user)-[rel_user_followers:FOLLOWS]->(followers)
RETURN rel_follows;

获取 $jd 的粉丝

$followers = $jd->followers;

此语句执行的 Cypher 将如下所示

MATCH (user:`User`), (followers:`User`), (user)-[rel_user_followers:FOLLOWS]-(followers)
WHERE id(user) = 1012
RETURN rel_follows;

动态属性

class Phone extends NeoEloquent {

    public function user()
    {
        return $this->belongsTo('User');
    }

}

$phone = Phone::find(1006);
$user = $phone->user;
// or getting an attribute out of the related model
$name = $phone->user->name;

多态

多态关系的概念与骨结构纯粹是关系性的，但在图数据库中，我们将其表示为超边。

超边涉及三个模型，即父模型、超模型和相关模型，如下图所示

在代码中，这将通过三个模型 User、Comment 和 Post 来表示，其中 ID 为 1 的 User 发布了一个 Post，而 ID 为 6 的 User 在该 Post 上发表了一条 COMMENTED。

class User extends NeoEloquent {

    public function comments($morph = null)
    {
        return $this->hyperMorph($morph, 'Comment', 'COMMENTED', 'ON');
    }

}

为了保持简单但仍然涉及三个模型，我们将传递 $morph，这是一个任何 commentable 模型，在我们的例子中是 Video 或 Post 模型。

注意：确保将其默认设置为 null，这样我们就可以稍后通过 $user->comments 动态或急切地加载。

使用 create() 方法创建一个 Comment。

$user = User::find(6);
$post = Post::find(2);

$user->comments($post)->create(['text' => 'Totally agree!', 'likes' => 0, 'abuse' => 0]);

像往常一样，我们将返回一个边，但这次它不是有向的，它是一个 HyperEdge 的实例，更多关于超边的信息。

或者保存 Comment 实例

$comment = new Comment(['text' => 'Magnificent', 'likes' => 0, 'abuse' => 0]);

$user->comments($post)->save($comment);

还支持在 BelongsToMany 关系中找到的所有功能，例如通过 Ids 关联模型

$user->comments($post)->attach([$id, $otherId]);

或者解除模型

$user->comments($post)->detach($comment); // or $comment->id

同步

$user->comments($post)->sync([$id, $otherId, $someId]);

检索多态关系

从我们之前的例子中，我们将使用 Video 模型来检索它们的评论

class Video extends NeoEloquent {

    public function comments()
    {
        return $this->morphMany('Comment', 'ON');
    }

}

动态加载多态模型

$video = Video::find(3);
$comments = $video->comments;

急切加载多态模型

$video = Video::with('comments')->find(3);
foreach ($video->comments as $comment)
{
    //
}

检索多态关系的反向

class Comment extends NeoEloquent {

    public function commentable()
    {
        return $this->morphTo();
    }

}

$postComment = Comment::find(7);
$post = $comment->commentable;

$videoComment = Comment::find(5);
$video = $comment->commentable;

// You can also eager load them
Comment::with('commentable')->get();

您还可以指定要返回的 morph 类型

class Comment extends NeoEloquent {

    public function post()
    {
        return $this->morphTo('Post', 'ON');
    }

    public function video()
    {
        return $this->morphTo('Video', 'ON');
    }

}

多态关系概述

为了深入了解，以下是参与多态关系的三个模型是如何连接的

class User extends NeoEloquent {

    public function comments($morph = null)
    {
        return $this->hyperMorph($morph, 'Comment', 'COMMENTED', 'ON');
    }

}

class Post extends NeoEloquent { // Video is the same as this one

    public function comments()
    {
        return $this->morphMany('Comment', 'ON');
    }

}

class Comment extends NeoEloquent {

    public function commentable()
    {
        return $this->morphTo();
    }

}

急切加载

class Book extends NeoEloquent {

    public function author()
    {
        return $this->belongsTo('Author');
    }
}

以尽可能低的性能开销加载作者及其书籍。

foreach (Book::with('author')->get() as $book)
{
    echo $book->author->name;
}

循环中只运行两个 Cypher 查询

MATCH (book:`Book`) RETURN *;

MATCH (book:`Book`), (book)<-[:WROTE]-(author:`Author`) WHERE id(book) IN [1, 2, 3, 4, 5, ...] RETURN book, author;

边

EdgeIn
EdgeOut
HyperEdge
与边一起工作
边属性

简介

由于图中的关系与其他数据库类型有很大不同，因此我们必须相应地处理它们。关系有方向，可以是分别指向父节点的内部和外部。

EdgeIn

表示从相关模型指向父模型的INCOMING方向关系。

class Location extends NeoEloquent {

    public function user()
    {
        return $this->belongsTo('User', 'LOCATED_AT');
    }

}

要将User与Location关联起来

$location = Location::find(1922);
$user = User::find(3876);
$relation = $location->associate($user);

在Cypher世界中，它将映射为(:Location)<-[:LOCATED_AT]-(:User)，并且$relation是代表指向父节点的关系的EdgeIn实例。

您仍然可以从边访问模型

$relation = $location->associate($user);
$location = $relation->parent();
$user = $relation->related();

EdgeOut

表示从父模型到相关模型的OUTGOING方向关系。

class User extends NeoEloquent {

    public function posts()
    {
        return $this->hasMany('Post', 'POSTED');
    }

}

要保存从:User到:Post的外部边，操作如下

$post = new Post(['...']);
$posted = $user->posts()->save($post);

在Cypher中，这将表示为(:User)-[:POSTED]->(:Post)，并且$posted是代表指向父节点关系的EdgeOut实例。

并获取相关模型

$edge = $user->posts()->save($post);
$user = $edge->parent();
$post = $edge->related();

HyperEdge

此边是作为多态关系的结果，表示涉及两个其他边（左和右）的边，可以通过left()和right()方法访问。

与其他边相比，此边处理方式略有不同，因为它不是两个模型之间的直接关系，这意味着它没有特定的方向。

$edge = $user->comments($post)->attach($comment);
// Access the left and right edges
$left = $edge->left();
$user = $left->parent();
$comment = $left->related();

$right = $edge->right();
$comment = $right->parent();
$post = $right->related();

处理边

如前所述，与SQL中的外键不同，边是图的实体，在文档中它们要么是嵌入的，要么是id作为引用。因此，我们将其开发为轻量级模型，这意味着您可以像处理Eloquent实例一样处理它们 - 在某种程度上，除了超边之外。

// Create a new relationship
$relation = $location->associate($user); // Vinelab\NeoEloquent\Eloquent\Edges\EdgeIn

// Save the relationship to the database
$relation->save(); // true

在HyperEdge的情况下，您可以如下访问所有三个模型

$edge    = $user->comments($post)->save($comment);
$user    = $edge->parent();
$comment = $edge->hyper();
$post    = $edge->related();

边属性

默认情况下，边将具有自动设置和更新的时间戳created_at和updated_at，但前提是必须在父模型上将时间戳设置为true。

$located_at = $location->associate($user);
$located_at->since = 1966;
$located_at->present = true;
$located_at->save();

// $created_at and $updated_at are Carbon\Carbon instances
$created_at = $located_at->created_at;
$updated_at = $located_at->updated_at;

从关系中检索边

与创建关联的方式一样，我们可以通过在belongsTo关系上调用edge($model)方法来检索两个模型之间的边。

$location = Location::find(1892);
$edge = $location->user()->edge();

您也可以指定边的另一端的模型。

注意：默认情况下，NeoEloquent将尝试执行$location->user，根据关系函数名确定边的相关部分，在这种情况下是user()。

$location = Location::find(1892);
$edge = $location->user()->edge($location->user);

仅Neo4j中存在

创建With

在这里，您将找到NeoEloquent特定的方法和实现，这些方法与Eloquent的奇妙方法结合，可以让您在Graph和Neo4j上工作得更加愉快！

创建With

创建关系
附加关系

此方法将“某种程度上”填补关系数据库和文档数据库之间的差距，它允许通过一次数据库查询创建多个相关模型。

创建新记录和关系

以下是一个创建带有附加照片和视频的帖子的示例

class Post extends NeoEloquent {

    public function photos()
    {
        return $this->hasMany('Photo', 'PHOTO');
    }

    public function videos()
    {
        return $this->hasMany('Video', 'VIDEO');
    }
}

Post::createWith(['title' => 'the title', 'body' => 'the body'], [
    'photos' => [
        [
            'url'      => 'http://url',
            'caption'  => '...',
            'metadata' => '...'
        ],
        [
            'url' => 'http://other.url',
            'caption' => 'the bay',
            'metadata' => '...'
        ]
    ],

    'videos' => [
        'title' => 'Boats passing us by',
        'description' => '...'
    ]
]);

photos和videos键必须与Post模型中关系方法的名称相同。

上述示例执行了以下Cypher查询

CREATE (post:`Post` {title: 'the title', body: 'the body'}),
(post)-[:PHOTO]->(:`Photo` {url: 'http://url', caption: '...', metadata: '...'}),
(post)-[:PHOTO]->(:`Photo` {url: 'http://other', caption: 'the bay', metadata: '...'}),
(post)-[:VIDEO]->(:`Video` {title: 'Boats passing us by', description: '...'});

我们将获得创建的节点及其关系

您还可以混合模型和属性作为关系值，但这不是必需的，因为NeoEloquent将通过$fillable过滤器管道传递提供的属性。

$videos = new Video(['title' => 'foo', 'description' => 'bar']);
Post::createWith($info, compact('videos'));

您还可以使用单个属性数组

class User extends NeoEloquent {

    public function account()
    {
        return $this->hasOne('Account');
    }
}

User::createWith(['name' => 'foo'], ['account' => ['guid' => 'bar', 'email' => 'some@mail.net']]);

将现有记录作为关系附加

createWith非常智能，可以区分你传递的是现有模型、模型ID还是需要创建的新记录，这允许将新记录与现有记录混合。

class Post extends NeoEloquent {

    public function tags()
    {
        return $this->hasMany('Tag', 'TAG');
    }
}

$tag1 = Tag::create(['title' => 'php']);
$tag2 = Tag::create(['title' => 'dev']);

$post = Post::createWith(['title' => 'foo', 'body' => 'bar'], ['tags' => [$tag1, $tag2]]);

我们将获取与现有Tag节点相关的Post。

或者使用模型的id。

Post::createWith(['title' => 'foo', 'body' => 'bar'], ['tags' => 1, 'privacy' => 2]);

附加记录的查询的Cypher语句将是

CREATE (post:`Post` {title: 'foo', 'body' => 'bar'})
WITH post
MATCH (tag:`Tag`)
WHERE id(tag) IN [1, 2]
CREATE (post)-[:TAG]->(tag);

迁移

为了使迁移工作，请执行以下操作

创建文件夹app/database/labels
修改composer.json并将app/database/labels添加到classmap数组中

由于Neo4j是无模式的数据库，因此您不需要预先定义标签的属性类型。但是，您可以使用NeoEloquent的简单Schema来执行索引和约束。

命令

NeoEloquent在neo4j命名空间下引入了新的命令，因此您仍然可以并行使用Eloquent的迁移命令。

迁移命令与Eloquent相同，格式为neo4j:migrate[:command]

neo4j:make:migration                 Create a new migration file
neo4j:migrate                        Run the database migrations
neo4j:migrate:reset                  Rollback all database migrations
neo4j:migrate:refresh                Reset and re-run all migrations
neo4j:migrate:rollback               Rollback the last database migration

创建迁移

与Laravel一样，您可以使用Artisan的make命令创建新的迁移。

php artisan neo4j:migrate:make create_user_label

标签迁移将放置在app/database/labels

您可以为命令添加附加选项，例如

php artisan neo4j:migrate:make foo --path=app/labels
php artisan neo4j:migrate:make create_user_label --create=User
php artisan neo4j:migrate:make create_user_label --label=User

运行迁移

运行所有待处理的迁移

php artisan neo4j:migrate

运行路径上所有待处理的迁移

php artisan neo4j:migrate --path=app/foo/labels

运行包上所有待处理的迁移

php artisan neo4j:migrate --package=vendor/package

注意：如果您在运行迁移时收到“找不到类”的错误，请尝试运行composer dump-autoload命令。

在生产环境中强制运行迁移

要在生产数据库中强制运行迁移，可以使用

php artisan neo4j:migrate --force

回滚迁移

回滚最后一个迁移操作

php artisan neo4j:migrate:rollback

回滚所有迁移

php artisan neo4j:migrate:reset

回滚所有迁移并再次运行它们

php artisan neo4j:migrate:refresh

php artisan neo4j:migrate:refresh --seed

模式

NeoEloquent将自动为您代理Neo4jSchema门面，以便您可以在操作标签时使用。

Neo4jSchema::label('User', function(Blueprint $label)
{
    $label->unique('uuid');
});

如果您决定手动编写迁移类（不使用生成器），请确保有这些use语句

use Vinelab\NeoEloquent\Schema\Blueprint;
use Vinelab\NeoEloquent\Migrations\Migration;

目前Neo4j支持UNIQUE约束和属性上的INDEX。您可以在这里了解更多信息。

http://docs.neo4j.org/chunked/stable/graphdb-neo4j-schema.html

Schema Methods

删除标签

Neo4jSchema::drop('User');
Neo4jSchema::dropIfExists('User');

重命名标签

Neo4jSchema::renameLabel($from, $to);

检查标签是否存在

if (Neo4jSchema::hasLabel('User')) {

} else {

}

检查关系是否存在

if (Neo4jSchema::hasRelation('FRIEND_OF')) {

} else {

}

您可以在这里和这里了解更多关于迁移和模式的信息。

https://laravel.net.cn/docs/schema

https://laravel.net.cn/docs/migrations

聚合

除了Eloquent构建器的聚合函数外，NeoEloquent还支持Neo4j特定的聚合函数，如percentile和standard deviation，以方便地保留相同的函数名。有关更多信息，请参阅文档。

table()表示模型的标签

$users = DB::table('User')->count();

$distinct = DB::table('User')->countDistinct('points');

$price = DB::table('Order')->max('price');

$price = DB::table('Order')->min('price');

$price = DB::table('Order')->avg('price');

$total = DB::table('User')->sum('votes');

$disc = DB::table('User')->percentileDisc('votes', 0.2);

$cont = DB::table('User')->percentileCont('votes', 0.8);

$deviation = DB::table('User')->stdev('sex');

$population = DB::table('User')->stdevp('sex');

$emails = DB::table('User')->collect('email');

变更日志

请查看发行版以获取详细信息。

避免

以下是一些约束和图特定的问题，以及一些不支持或不推荐的功能列表。

JOIN 😖

对于图来说，它们没有意义，而且图讨厌它们！这使得它们故意不受支持。如果您从基于SQL的应用程序迁移，它们将是您的噩梦。

多对多关系中的交叉表

这不受支持，我们将使用边来处理模型之间的关系。

嵌套数组和对象

由于对象映射类型对单个对象施加的限制，您不能在单个模型中拥有嵌套的数组或对象，请确保它是扁平的。示例：

// Don't
User::create(['name' => 'Some Name', 'location' => ['lat' => 123, 'lng'=> -123 ] ]);

查看createWith()方法，了解如何以图形方式实现此功能。

测试

安装Neo4j实例，并使用默认配置localhost:7474运行它
确保数据库图形为空，以避免冲突
运行composer install后，应该存在/vendor/bin/phpunit
确保Neo4j实例正在运行后，运行./vendor/bin/phpunit

标记为不完整的测试意味着它们是已知问题或不受支持的功能，请检查包含的消息以获取更多信息。

digitalcloud / neo-eloquent

维护者

详细信息

README

NeoEloquent

聊天 & 支持

快速参考

安装

Laravel 5

5.6

5.5

5.4

5.3

5.2

5.1

5.0

Laravel 4

配置

连接

Lumen

迁移设置

文档

模型

命名空间模型

自定义节点标签

软删除

Laravel 5

Laravel 4

关系

一对一

保存

定义此关系的反向

关联模型

一对多

定义此关系的反向

多对多

动态属性

多态

检索多态关系

动态加载多态模型

急切加载多态模型

检索多态关系的反向

多态关系概述

急切加载

边

简介

EdgeIn

EdgeOut

HyperEdge

处理边

边属性

从关系中检索边

仅Neo4j中存在

创建With

创建新记录和关系

将现有记录作为关系附加

迁移

命令

创建迁移

运行迁移

运行所有待处理的迁移

运行路径上所有待处理的迁移

运行包上所有待处理的迁移

在生产环境中强制运行迁移

回滚迁移

回滚最后一个迁移操作

回滚所有迁移

回滚所有迁移并再次运行它们

模式

Schema Methods

删除标签

重命名标签

检查标签是否存在

检查关系是否存在

聚合

变更日志

避免

JOIN 😖

多对多关系中的交叉表

嵌套数组和对象