Eloquent, el ORM (Object Relational Mapping) de Laravel.

Eloquent es un sistema de mapeo objeto-relacional (ORM) incluido en Laravel, un framework de desarrollo web en PHP. Eloquent facilita la interacción con bases de datos utilizando objetos de PHP en lugar de escribir consultas SQL manualmente. Su objetivo es hacer que el acceso y manipulación de los datos sea más sencillo y expresivo, siguiendo el principio de la programación orientada a objetos.

1. Funciones Básicas de Consultas.

Función	Descripción	Ejemplo
`all()`	Obtiene todos los registros de un modelo.	`User::all();`
`find($id)`	Encuentra un registro por su ID.	`User::find(1);`
`first()`	Obtiene el primer registro.	`User::where('email', 'test@example.com')->first();`
`pluck($column)`	Obtiene un listado de valores de una columna.	`User::pluck('email');`
`get()`	Obtiene todos los resultados de una consulta.	`User::where('active', 1)->get();`

2. Filtrado y Condiciones

Función	Descripción	Ejemplo
`where($column, $operator, $value)`	Filtra registros con una condición.	`User::where('age', '>', 25)->get();`
`orWhere($column, $operator, $value)`	Agrega una condición OR.	`User::where('age', '>', 25)->orWhere('name', 'John')->get();`
`whereIn($column, $values)`	Filtra registros con valores en una lista.	`User::whereIn('id', [1, 2, 3])->get();`
`whereNull($column)`	Filtra registros donde la columna es NULL.	`User::whereNull('deleted_at')->get();`
`whereNotNull($column)`	Filtra registros donde la columna no es NULL.	`User::whereNotNull('email')->get();`

3. Ordenamiento y Agrupación

Función	Descripción	Ejemplo
`orderBy($column, $direction)`	Ordena los resultados.	`User::orderBy('name', 'asc')->get();`
`groupBy($column)`	Agrupa resultados por una columna.	`Order::select('status')->groupBy('status')->get();`
`having($column, $operator, $value)`	Agrega condiciones después del `groupBy`.	`Order::groupBy('status')->having('total', '>', 100)->get();`

4. Relaciones entre Modelos

Función	Descripción	Ejemplo
`hasMany()`	Define una relación de “uno a muchos”.	`public function posts() { return $this->hasMany(Post::class); }`
`belongsTo()`	Define una relación de “pertenece a”.	`public function user() { return $this->belongsTo(User::class); }`
`hasOne()`	Define una relación de “uno a uno”.	`public function profile() { return $this->hasOne(Profile::class); }`
`belongsToMany()`	Define una relación de “muchos a muchos”.	`public function roles() { return $this->belongsToMany(Role::class); }`

5. Inserción y Actualización

Función	Descripción	Ejemplo
`create($attributes)`	Crea un nuevo registro en la base de datos.	`User::create(['name' => 'John', 'email' => 'john@example.com']);`
`update($attributes)`	Actualiza un registro existente.	`$user->update(['name' => 'Updated Name']);`
`save()`	Guarda un modelo nuevo o existente.	`$user = new User(['name' => 'John']); $user->save();`
`delete()`	Elimina un registro.	`$user = User::find(1); $user->delete();`

6. Relaciones con Eager Loading

Función	Descripción	Ejemplo
`with($relation)`	Carga relaciones con los modelos relacionados.	`User::with('posts')->get();`
`load($relation)`	Carga relaciones en un modelo existente.	`$user->load('posts');`

7. Funciones de Paginación

Función	Descripción	Ejemplo
`paginate($perPage)`	Devuelve resultados en páginas.	`User::paginate(10);`
`simplePaginate($perPage)`	Versión más ligera de paginación.	`User::simplePaginate(10);`

8. Funciones de Agregación

Función	Descripción	Ejemplo
`count()`	Cuenta el número de registros.	`User::count();`
`sum($column)`	Suma los valores de una columna.	`Order::sum('total');`
`avg($column)`	Calcula el promedio de una columna.	`Order::avg('total');`
`min($column)`	Encuentra el valor mínimo de una columna.	`Order::min('total');`
`max($column)`	Encuentra el valor máximo de una columna.	`Order::max('total');`

9. Funciones de Relaciones Avanzadas

Función	Descripción	Ejemplo
`exists()`	Comprueba si existe algún registro.	`User::where('email', 'test@example.com')->exists();`
`doesntExist()`	Comprueba si no existe algún registro.	`User::where('email', 'notfound@example.com')->doesntExist();`

10. Scopes (Filtros Personalizados)

Función	Descripción	Ejemplo
`scope<NombreScope>`	Define un filtro reutilizable.	`User::active()->get();` (con `scopeActive($query)`)

Definición en el modelo:

public function scopeActive($query) {
    return $query->where('active', 1);
}

Características clave de Eloquent:

Modelos Eloquent:
- En Laravel, los modelos son clases que representan tablas de la base de datos. Cada instancia de un modelo representa una fila de la tabla, y las propiedades del modelo corresponden a las columnas de la tabla.Los modelos Eloquent permiten que los desarrolladores trabajen con bases de datos sin escribir SQL explícitamente.
Ejemplo de un modelo Eloquent: <?php namespace App\Models; use Illuminate\Database\Eloquent\Model; class Post extends Model { // Aquí se definen las relaciones y comportamientos específicos de los modelos }
Consultas usando Eloquent:
- Eloquent permite realizar consultas a la base de datos usando una sintaxis simple y fluida. Por ejemplo, para obtener todos los registros de una tabla, puedes hacer algo como:
$posts = App\Models\Post::all();
- Esto recupera todos los registros de la tabla posts.
Operaciones CRUD (Crear, Leer, Actualizar, Eliminar): Eloquent facilita las operaciones CRUD de manera muy simple:
- Crear:$post = new App\Models\Post; $post->title = 'Nuevo Post'; $post->content = 'Contenido del post'; $post->save();
- Leer:$post = App\Models\Post::find(1); // Encuentra el post con ID 1
- Actualizar:p$post = App\Models\Post::find(1); $post->title = 'Título actualizado'; $post->save();
- Eliminar:$post = App\Models\Post::find(1); $post->delete();
- Relaciones entre modelos:
  - Eloquent simplifica las relaciones entre tablas, como uno a uno, uno a muchos, muchos a muchos, y polimórficas.Por ejemplo, si un Post tiene muchos Comment, puedes definir esta relación en el modelo Post con el siguiente método:
  public function comments() {
- return $this->hasMany(Comment::class);
- }
- Luego, puedes acceder a los comentarios de un post así:phpCopy code$post = App\Models\Post::find(1); $comments = $post->comments;
Consultas avanzadas y Eloquent Fluent: Eloquent también admite métodos para realizar consultas más complejas, como filtrar, ordenar, y agrupar resultados de manera fluida y expresiva.Ejemplo de una consulta fluida:phpCopy code$posts = App\Models\Post::where('status', 'published') ->orderBy('created_at', 'desc') ->take(5) ->get();

Ventajas de usar Eloquent:

Simplicidad: Eloquent hace que trabajar con bases de datos sea muy intuitivo y fácil de entender.
Seguridad: Protege contra ataques de inyección SQL, ya que las consultas se construyen de manera segura.
Productividad: Permite escribir menos código para realizar las mismas operaciones en la base de datos.
Mantenibilidad: Las consultas y operaciones son más legibles y fáciles de mantener, ya que se usan objetos en lugar de SQL crudo.

En resumen, Eloquent es una herramienta poderosa de Laravel que mejora la interacción con la base de datos al abstraer muchas de las complejidades del manejo de SQL, haciendo que el código sea más limpio, fácil de entender y más rápido de desarrollar.

TechPost