Relacionamentos de modelo eloquente

Visão geral

Quando você usa um banco de dados relacional, o Eloquent ORM armazena modelos como linhas em tabelas que correspondem às classes de modelo. Quando você usa o MongoDB, o Laravel MongoDB armazena modelos como documentos em coleções que correspondem às classes de modelo.

Para definir um relacionamento, adicione uma função à classe de modelo que chama o método de relacionamento apropriado. Esta função permite a você acessar o modelo relacionado como uma propriedade dinâmica. Uma propriedade dinâmica permite acessar o modelo relacionado usando a mesma sintaxe usada para acessar uma propriedade no modelo.

As seções a seguir descrevem as relações específicas do Laravel Eloquent e do MongoDB disponíveis no Laravel MongoDB e mostram exemplos de como defini-las e usá-las:

• Relacionamento um para um, criado usando o método hasOne() e seu inverso, belongsTo()

• Relacionamento de um para muitos, criado usando hasMany() e seu inverso, belongsTo()

• Relacionamento Muitos para muitos, criado usando o método belongsToMany()

• Padrão de documento incorporado, um relacionamento específico do MongoDB que pode representar um relacionamento de um para um ou de um para muitos, criado usando o método embedsOne() ou embedsMany()

• Relacionamentos entre bancos de dados, necessários quando você deseja criar relacionamentos entre os modelos MongoDB e SQL

Relacionamento individual

Um relacionamento um para um entre modelos consiste em um registro de modelo relacionado a exatamente um outro tipo de registro de modelo.

Quando você adiciona um relacionamento um a um, o Eloquent permite acessar o modelo usando uma propriedade dinâmica e armazena o ID do documento do modelo no modelo relacionado.

No Laravel MongoDB, você pode definir um relacionamento um para um usando o método hasOne() ou belongsTo() .

Quando você adiciona o inverso do relacionamento usando o método belongsTo() , o Eloquent permite acessar o modelo usando uma propriedade dinâmica, mas não adiciona nenhum campo.

Para saber mais sobre relacionamentos um para um, consulte Um para Um na documentação do Laravel.

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\HasOne;
class Planet extends Model
{
    protected $connection = 'mongodb';
    public function orbit(): HasOne
    {
        return $this->hasOne(Orbit::class);
    }
}

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\BelongsTo;
class Orbit extends Model
{
    protected $connection = 'mongodb';
    public function planet(): BelongsTo
    {
        return $this->belongsTo(Planet::class);
    }
}

$planet = new Planet();
$planet->name = 'Earth';
$planet->diameter_km = 12742;
$planet->save();
$orbit = new Orbit();
$orbit->period = 365.26;
$orbit->direction = 'counterclockwise';
$planet->orbit()->save($orbit);

$planet = Planet::first();
$relatedOrbit = $planet->orbit;
$orbit = Orbit::first();
$relatedPlanet = $orbit->planet;

Relacionamento de um para muitos

Um relacionamento um para muitos entre modelos consiste em um modelo que é o pai e um ou mais registros de modelo filho relacionados.

Quando você adiciona um método de relacionamento de um para muitos, o Eloquent permite acessar o modelo usando uma propriedade dinâmica e armazena o ID do documento do modelo principal em cada documento do modelo filho.

No Laravel MongoDB, você pode definir um relacionamento de um para muitos adicionando o método hasMany() na classe pai e, opcionalmente, o método belongsTo() na classe filho.

Quando você adiciona o inverso do relacionamento usando o método belongsTo() , o Eloquent permite acessar o modelo principal usando uma propriedade dinâmica sem adicionar nenhum campo.

Para saber mais sobre relacionamentos um a muitos, consulte Um a muitos na documentação do Laravel.

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\HasMany;
class Planet extends Model
{
    protected $connection = 'mongodb';
    public function moons(): HasMany
    {
        return $this->hasMany(Moon::class);
    }
}

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\BelongsTo;
class Moon extends Model
{
    protected $connection = 'mongodb';
    public function planet(): BelongsTo
    {
        return $this->belongsTo(Planet::class);
    }
}

$planet = new Planet();
$planet->name = 'Jupiter';
$planet->diameter_km = 142984;
$planet->save();
$moon1 = new Moon();
$moon1->name = 'Ganymede';
$moon1->orbital_period = 7.15;
$moon2 = new Moon();
$moon2->name = 'Europa';
$moon2->orbital_period = 3.55;
$planet->moons()->save($moon1);
$planet->moons()->save($moon2);

$planet = Planet::first();
$relatedMoons = $planet->moons;
$moon = Moon::first();
$relatedPlanet = $moon->planet;

Relacionamento de muitos para muitos

Um relacionamento muitos para muitos consiste em um relacionamento entre dois tipos de modelo diferentes no qual, para cada tipo de modelo, uma instância do modelo pode estar relacionada a múltiplas instâncias do outro tipo.

No Laravel MongoDB, você pode definir um relacionamento de muitos para muitos adicionando o método belongsToMany() a ambas as classes relacionadas.

Quando você define um relacionamento muitos para muitos em um banco de dados relacional, o Laravel cria uma tabela dinâmica para rastrear os relacionamentos. Quando você usa o Laravel MongoDB, ele omite a criação da tabela dinâmica e adiciona os IDs de documento relacionados a um campo de documento derivado do nome da classe de modelo relacionado.

Para saber mais sobre relacionamentos muitos para muitos no Laravel, consulte Muitos para muitos na documentação do Laravel.

A seção a seguir mostra um exemplo de como criar um relacionamento de muitos para muitos entre as classes de modelo.

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\BelongsToMany;
class Planet extends Model
{
    protected $connection = 'mongodb';
    public function visitors(): BelongsToMany
    {
        return $this->belongsToMany(SpaceExplorer::class);
    }
}

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\BelongsToMany;
class SpaceExplorer extends Model
{
    protected $connection = 'mongodb';
    public function planetsVisited(): BelongsToMany
    {
        return $this->belongsToMany(Planet::class);
    }
}

$planetEarth = new Planet();
$planetEarth->name = 'Earth';
$planetEarth->save();
$planetMars = new Planet();
$planetMars->name = 'Mars';
$planetMars->save();
$planetJupiter = new Planet();
$planetJupiter->name = 'Jupiter';
$planetJupiter->save();
$explorerTanya = new SpaceExplorer();
$explorerTanya->name = 'Tanya Kirbuk';
$explorerTanya->save();
$explorerMark = new SpaceExplorer();
$explorerMark->name = 'Mark Watney';
$explorerMark->save();
$explorerJeanluc = new SpaceExplorer();
$explorerJeanluc->name = 'Jean-Luc Picard';
$explorerJeanluc->save();
$explorerTanya->planetsVisited()->attach($planetEarth);
$explorerTanya->planetsVisited()->attach($planetJupiter);
$explorerMark->planetsVisited()->attach($planetEarth);
$explorerMark->planetsVisited()->attach($planetMars);
$explorerJeanluc->planetsVisited()->attach($planetEarth);
$explorerJeanluc->planetsVisited()->attach($planetMars);
$explorerJeanluc->planetsVisited()->attach($planetJupiter);

$planet = Planet::first();
$explorers = $planet->visitors;
$spaceExplorer = SpaceExplorer::first();
$explored = $spaceExplorer->planetsVisited;

Padrão de documento incorporado

No MongoDB, o padrão de documento incorporado adiciona os dados do modelo relacionado ao modelo principal em vez de manter as referências de chave estrangeira. Use esse padrão para atender a um ou mais dos seguintes requisitos:

• Mantendo dados associados juntos em uma única collection

• Executando atualizações atômicas em vários campos do documento e os dados associados

• Reduzindo o número de leituras necessárias para buscar os dados

No Laravel MongoDB, você pode definir documentos incorporados adicionando um dos seguintes métodos:

• embedsOne() para incorporar um único documento

• embedsMany() para incorporar vários documentos

Para saber mais sobre o padrão de documento incorporado do MongoDB, consulte os seguintes tutoriais do servidor MongoDB:

• Modelar relacionamentos de um para um com documentos incorporados

• Modele relacionamentos um-para-muitos com documentos incorporados

A seção a seguir mostra um exemplo de como usar o padrão de documento incorporado.

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
use MongoDB\Laravel\Relations\EmbedsMany;
class SpaceShip extends Model
{
    protected $connection = 'mongodb';
    public function cargo(): EmbedsMany
    {
        return $this->embedsMany(Cargo::class);
    }
}

<?php
declare(strict_types=1);
namespace App\Models;
use MongoDB\Laravel\Eloquent\Model;
class Cargo extends Model
{
    protected $connection = 'mongodb';
}

$spaceship = new SpaceShip();
$spaceship->name = 'The Millenium Falcon';
$spaceship->save();
$cargoSpice = new Cargo();
$cargoSpice->name = 'spice';
$cargoSpice->weight = 50;
$cargoHyperdrive = new Cargo();
$cargoHyperdrive->name = 'hyperdrive';
$cargoHyperdrive->weight = 25;
$spaceship->cargo()->attach($cargoSpice);
$spaceship->cargo()->attach($cargoHyperdrive);

Relacionamentos entre bancos de dados

Um relacionamento entre bancos de dados no Laravel MongoDB é um relacionamento entre modelos armazenados em um banco de dados relacional e modelos armazenados em um banco de MongoDB database.

Quando você adiciona um relacionamento entre bancos de dados, o Eloquent permite acessar os modelos relacionados usando uma propriedade dinâmica.

O Laravel MongoDB suporta os seguintes métodos de relacionamento entre bancos de dados:

• hasOne()

• hasMany()

• belongsTo()

Para definir um relacionamento entre bancos de dados, você deve importar o pacote MongoDB\Laravel\Eloquent\HybridRelations na classe armazenada no banco de dados relacional.

A seção a seguir mostra um exemplo de como definir um relacionamento entre bancos de dados.

<?php
declare(strict_types=1);
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;
use MongoDB\Laravel\Eloquent\HybridRelations;
class SpaceShip extends Model
{
    use HybridRelations;
    protected $connection = 'sqlite';
    public function passengers(): HasMany
    {
        return $this->hasMany(Passenger::class);
    }
}

<?php
declare(strict_types=1);
namespace App\Models;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use MongoDB\Laravel\Eloquent\Model;
class Passenger extends Model
{
    protected $connection = 'mongodb';
    public function spaceship(): BelongsTo
    {
        return $this->belongsTo(SpaceShip::class);
    }
}

$spaceship = new SpaceShip();
$spaceship->id = 1234;
$spaceship->name = 'Nostromo';
$spaceship->save();
$passengerEllen = new Passenger();
$passengerEllen->name = 'Ellen Ripley';
$passengerDwayne = new Passenger();
$passengerDwayne->name = 'Dwayne Hicks';
$spaceship->passengers()->save($passengerEllen);
$spaceship->passengers()->save($passengerDwayne);