README

NeoEloquent

Neo4j 图形 Eloquent 驱动器 for Laravel

快速参考

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

安装

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

Laravel 5

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，这样您就可以在模型中简单地 extend NeoEloquent。

配置

连接

在 app/config/database.php 或在基于环境的配置情况下 app/config/[env]/database.php 中，将 neo4j 设置为默认连接

'default' => 'neo4j',

添加连接默认值

'connections' => [
    'neo4j' => [
        'driver' => 'neo4j',
        'host'   => 'localhost',
        'port'   => '7474',
        'username' => null,
        'password' => null
    ]
]

迁移设置

如果您愿意使用迁移

创建 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 关系方向。

关联模型

由于我们不处理外键，在我们的情况下，这不仅仅是设置父模型的键属性。在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;

多态

多态关系的概念在本质上与骨相关联，但在图数据库中，我们将其表示为超边。

超边涉及三个模型，即parent模型、hyper模型和related模型，如图所示

在代码中，这将被表示为三个模型User、Comment和Post，其中id为1的User发布了一个Post，id为6的User在Post上COMMENTED一条Comment，如下所示

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关系中找到的所有功能，如通过Id附加模型

$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
与边一起工作
边属性

介绍

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

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，并且仅在将 $timestamps 设置为 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;

从关系检索边

与关联将创建 EdgeIn 关系相同，我们可以通过在 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);

仅在 Neo 中

创建With

在这里，您将找到 NeoEloquent 特有的方法和实现，这些方法和 Eloquent 方法结合使用，可以让您在图和 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 的简单模式来执行索引和约束。

命令

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

模式方法

删除标签

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特定的聚合，如百分位数和标准差，以方便起见，保持相同的函数名。查看文档以获取更多信息。

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');

变更日志

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

避免

以下是一些约束和图特定的注意事项，这是一些不支持或不推荐的功能列表。

连接 😖

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

多对多关系中的Pivot表

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

嵌套数组和对象

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

// 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

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

n1ks2n / neoeloquent

维护者

详细信息

README

NeoEloquent

快速参考

安装

Laravel 5

5.1

5.0

Laravel 4

配置

连接

迁移设置

文档

模型

命名空间模型

自定义节点标签

软删除

Laravel 5

Laravel 4

关系

一对一

保存

定义此关系的反向

关联模型

一对多

定义此关系的反向

多对多

动态属性

多态

检索多态关系

动态加载多态模型

急切加载多态模型

检索多态关系的逆关系

多态关系简述

急切加载

边

介绍

EdgeIn

EdgeOut

HyperEdge

与边一起工作

边属性

从关系检索边

仅在 Neo 中

创建With

创建新记录和关系

作为关系附加现有记录

迁移

命令

创建迁移

运行迁移

运行所有未执行的迁移

运行指定路径的所有未执行的迁移

运行指定包的所有未执行的迁移

在生产中强制运行迁移

回滚迁移

回滚最后迁移操作

回滚所有迁移

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

模式

模式方法

删除标签

重命名标签

检查标签的存在性

检查关系的存在性

聚合

变更日志

避免

连接 😖

多对多关系中的Pivot表

嵌套数组和对象

测试