Laravel
Elocuente

Introducción

Observaciones

class User extends Model
{ 
    protected $table = 'customers';
}

Introducción

Elocuente es el ORM integrado en el marco de Laravel. Le permite interactuar con las tablas de su base de datos de una manera orientada a objetos, mediante el uso del patrón ActiveRecord .

Una clase de modelo único generalmente se asigna a una tabla de base de datos única, y también se pueden definir relaciones de diferentes tipos ( uno a uno , uno a muchos , muchos a muchos , polimórficos) entre diferentes clases de modelos.

La sección Making a Model describe la creación y definición de clases de modelos.

Antes de que pueda comenzar a usar los modelos Eloquent, asegúrese de que al menos una conexión de base de datos se haya configurado en su archivo de configuración config/database.php .

Para comprender el uso del generador de consultas elocuente durante el desarrollo, puede usar php artisan ide-helper:generate comando. Aquí está el enlace .

Subtema de navegación

Relación elocuente

Persistiendo

Además de leer datos con Eloquent, también puede usarlo para insertar o actualizar datos con el método save() . Si ha creado una nueva instancia de modelo, se insertará el registro; de lo contrario, si ha recuperado un modelo de la base de datos y ha establecido nuevos valores, se actualizará .

En este ejemplo creamos un nuevo registro de User :

$user = new User();
$user->first_name = 'John';
$user->last_name = 'Doe';
$user->email = '[email protected]';
$user->password = bcrypt('my_password');
$user->save();

También puede utilizar el método de create para rellenar campos utilizando una matriz de datos:

User::create([
    'first_name'=> 'John',
    'last_name' => 'Doe',
    'email'     => '[email protected]', 
    'password'  => bcrypt('changeme'),
]);

Cuando utilice el método de creación, sus atributos deben declararse en la matriz fillable dentro de su modelo:

class User extends Model
{
    protected $fillable = [
         'first_name',
         'last_name',
         'email',
         'password',
    ];
}

Alternativamente, si desea que todos los atributos sean asignables en masa, puede definir la propiedad $ guarded como una matriz vacía:

class User extends Model
{
    /**
    * The attributes that aren't mass assignable.
    *
    * @var array
    */
    protected $guarded = [];
}

Pero también puede crear un registro sin siquiera cambiar el atributo fillable en su modelo usando el método forceCreate lugar de create método

User::forceCreate([
    'first_name'=> 'John',
    'last_name' => 'Doe',
    'email'     => '[email protected]', 
    'password'  => bcrypt('changeme'),
]);

El siguiente es un ejemplo de la actualización de un modelo de User existente al cargarlo primero (mediante la find ), modificarlo y luego guardarlo:

$user = User::find(1);
$user->password = bcrypt('my_new_password');
$user->save();

Para lograr la misma hazaña con una sola llamada de función, puede usar el método de update :

$user->update([
    'password' => bcrypt('my_new_password'),
]);

Los métodos de create y update hacen que trabajar con grandes conjuntos de datos sea mucho más sencillo que tener que configurar cada par de clave / valor individualmente, como se muestra en los siguientes ejemplos:

Tenga en cuenta el uso de only y except al recopilar datos de solicitud. Es importante que especifique las claves exactas que desea permitir / no permitir que se actualicen, de lo contrario, es posible que un atacante envíe campos adicionales con su solicitud y cause actualizaciones no deseadas.

// Updating a user from specific request data
$data = Request::only(['first_name', 'email']);
$user->find(1);
$user->update($data);

// Create a user from specific request data
$data = Request::except(['_token', 'profile_picture', 'profile_name']);
$user->create($data);

Borrando

Puede eliminar datos después de escribirlos en la base de datos. Puede eliminar una instancia de modelo si ha recuperado una, o especificar las condiciones para los registros que desea eliminar.

Para eliminar una instancia de modelo, recupérela y llame al método delete() :

$user = User::find(1);
$user->delete();

Alternativamente, puede especificar una clave primaria (o una matriz de claves primarias) de los registros que desea eliminar a través del método destroy() :

User::destroy(1);
User::destroy([1, 2, 3]);

También puede combinar la consulta con la eliminación:

User::where('age', '<', 21)->delete();

Esto eliminará todos los usuarios que coincidan con la condición.

Nota: Al ejecutar una declaración de eliminación masiva a través de Eloquent, los eventos de deleting y deleted modelo no se activarán para los modelos eliminados. Esto se debe a que los modelos nunca se recuperan realmente al ejecutar la instrucción de eliminación.

Eliminación suave

Algunas veces, no desea eliminar un registro de forma permanente, sino mantenerlo para fines de auditoría o informe. Para esto, Eloquent proporciona una funcionalidad de eliminación suave .

Para agregar la funcionalidad de borrados suaves a su modelo, necesita importar el rasgo SoftDeletes y agregarlo a su clase de modelo Eloquent:

namespace Illuminate\Database\Eloquent\Model;
namespace Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model
{
     use SoftDeletes;
}

Al eliminar un modelo, establecerá una marca de tiempo en una columna de marca de tiempo deleted_at en la tabla para su modelo, así que asegúrese de crear la columna deleted_at en su tabla primero. O en la migración, debe llamar softDeletes() método softDeletes() en su proyecto para agregar la deleted_at tiempo deleted_at . Ejemplo:

Schema::table('users', function ($table) {
    $table->softDeletes();
});

Cualquier consulta omitirá los registros borrados. Puede forzarlos, mostrarlos si lo desea, usando el ámbito withTrashed() :

User::withTrashed()->get();

Si desea permitir que los usuarios restauren un registro después de la eliminación suave (es decir, en un área de tipo de papelera), puede usar el método restore() :

$user = User::find(1);
$user->delete();
$user->restore();

Para eliminar un registro a la forceDelete() use el método forceDelete() que realmente eliminará el registro de la base de datos:

$user = User::find(1);
$user->forceDelete();

Cambiar clave principal y marcas de tiempo

De manera predeterminada, los modelos Eloquent esperan que la clave primaria se llame 'id' . Si ese no es su caso, puede cambiar el nombre de su clave principal especificando la propiedad $primaryKey .

class Citizen extends Model
{
    protected $primaryKey = 'socialSecurityNo';

    // ...
}

Ahora, cualquier método Eloquent que use su clave principal (por ejemplo, find o findOrFail ) usará este nuevo nombre.

Además, Eloquent espera que la clave principal sea un entero de incremento automático. Si su clave principal no es un entero de incremento automático (por ejemplo, un GUID), debe indicar a Eloquent actualizando la propiedad $incrementing a false :

class Citizen extends Model
{
    protected $primaryKey = 'socialSecurityNo';

    public $incrementing = false;

    // ...
}

De forma predeterminada, Eloquent espera que updated_at columnas created_at y updated_at en sus tablas. Si no desea que Eloquent administre estas columnas automáticamente, establezca la propiedad $timestamps en su modelo en false:

class Citizen extends Model
{
    public $timestamps = false;

    // ...
}

Si necesita personalizar los nombres de las columnas utilizadas para almacenar las marcas de tiempo, puede configurar las constantes CREATED_AT y UPDATED_AT en su modelo:

class Citizen extends Model
{
    const CREATED_AT = 'date_of_creation';
    const UPDATED_AT = 'date_of_last_update';

    // ...
}

Lanzar 404 si no se encuentra la entidad

Si desea lanzar automáticamente una excepción al buscar un registro que no se encuentra en un modal, puede usar

Vehicle::findOrFail(1);

o

Vehicle::where('make', 'ford')->firstOrFail();

Si no se encuentra un registro con la clave principal de 1 , se lanza una ModelNotFoundException . Que es esencialmente lo mismo que escribir ( ver fuente ):

$vehicle = Vehicle::find($id);

if (!$vehicle) {
    abort(404);
}

Modelos de clonación

Puede que necesite clonar una fila, tal vez cambiar algunos atributos, pero necesita una manera eficiente de mantener las cosas en SECO. Laravel proporciona una especie de método 'oculto' para permitirte hacer esta funcionalidad. Aunque está completamente sin documentar, debe buscar a través de la API para encontrarlo.

Usando $model->replicate() puedes clonar fácilmente un registro

$robot = Robot::find(1);
$cloneRobot = $robot->replicate();
// You can add custom attributes here, for example he may want to evolve with an extra arm!
$cloneRobot->arms += 1;
$cloneRobot->save();

Lo anterior encontraría un robot que tiene un ID de 1 y luego lo clonará.