LARAVEL-PHP:orm

 php artisan list

  php artisan help comando

MIGRACIONES EN LARAVEL

 

 

idea a desarrollar: crear una migración y cómo es su estructura.

 

CREAR UNA MIGRACIÓN POR CADA TABLA QUE TENGAS EN TU DISEÑO

Ya tenemos el diseño de nuestro base de datos para nuestro proyecto, pero empezar a escribir la estructura de SQL llevara tiempo, tiempo que podemos ahorrarnos con el uso de migraciones, lo primero como te imaginas, será crear una migración por cada una de las tablas que tenemos en nuestro diseño.

 

El orden en que las creas importa mucho, asegurate de crear primero las tablas que no tiene relación con otras(tablas padres) para luego crear las tablas que si tiene relaciones, asi cuando corras las migraciones no tendras erroeres de referencia a tablas que no existen, solo porque creaste primero una tabla que tenia una relacion foránea con otra que aún no ha sido creada.

Las migraciones son como el control de versión para tu base de datos, permiten que tu equipo modifique y comparta el esquema de base de datos de la aplicación.

 

 

Las migraciones son emparejadas típicamente con el constructor de esquema de. Laravel para construir el esquema de base de datos de tu aplicación.

Generando migraciones

php artisan make:migration create_users_table

La nueva migración se colocará en su directorio database/migrations .

Para crear migraciones en Laravel requieres el comando:

 “php artisan make:migration” + “el nombre de tu tabla”

 Pero el nombre de la tabla debe tener la siguiente convención: php artisan make:migration create_hoteles_table

 

EJECUTAR MIGRACIONES EN LARAVEL

Para poder ejecutar dotas la migraciones en laravel tienes que usar el comando "php artisan migrate" pero antes asegurate de a ver configurado tu archivo .env.

 php artisan migrate

 

¿Cómo es la estructura?

Si la abrimos notara en ella una clase con los metodos up y down.

-Up: Esta funcion se ejecutara cuano corras la migración (php artisan migration). En su interior encontrarás el squema(schema::create) que se encargará de crear la tabla, para ello requiere del nombre que tendra tu tabla y una función anónima a la que debrás llenar con cada columna que necesite en tu tabla.

-dow: Esta funcion revierte los cambios echos por la funci+on up

 

MODIFICAR MIGRACIONES

Si haces cambios en  tus archivos de migracion y quieres que se vean reflejados , volver a ejecutar el comando "php artisan migrate" no te sera de ayuda, para que tus cambios se reflejen deberás ejecutar el comando:   

php artisan migrate:refresh

que básicamente borrara todas tus tablas (metodo dow)y las volvera a crear(metodo up), así los cambios que hayas hecho se verán reflejados.

Revertir migraciones

Para revertir migraciones recientes puedes usar el comando rollbak que revierte migraciones por lotes.

$php artisan migrate:rollback

Puedes revertir un numero liminado de migraciones agregando la opcion step al comando rollback

$php artisan migrate:rollback --step=5

El comando migrate:reset revertira todas las migraciones de tu aplicacion.

$php artisan migrate:reset

 

ROLLBACK Y MIGRATE EN UN SOLO COMANDO-refresh

El comando migrate:refresh revertira todas tus migraciones y después ejecutara el comando migrate. Este comando vuelve a crear tu esquema de base de datos.

Puedes revertir un numero limitado de migraciones agregando la opción step al comando refresh

 php artisan migrate:refresh

php artisan migrate:refresh --step=5

 

EL COMANDO FRESH

El comando migrate:fresh eliminará todas las tablas de la base de datos y después ejecutara el comando migrate.

php artisan migrate:fresh

Tipos de columna permitidos

 

Modificadores de columna

 Por ejemplo, para hacer que la columna «acepte valores nulos», puedes usar el método nullable .

 

crear migraciones de bd existente

Paquete:  laravel-migration-generator

 Genere migraciones a partir de estructuras de bases de datos existentes, una alternativa al volcado de esquema proporcionado por Laravel.Otro caso de uso sería tomar un proyecto con una base de datos y sin migraciones y convertir esa base de datos en migraciones base.

Instalación

composer require --dev bennett-treptow/laravel-migration-generator

php artisan vendor:publish --provider="LaravelMigrationGenerator\LaravelMigrationGeneratorProvider"

Uso

Siempre que tenga cambios en la base de datos o esté listo para reducir la estructura de su base de datos a migraciones, ejecute:

php artisan generate:migrations

Por defecto, las migraciones se crearán en tests/database/migrations. Puede especificar una ruta diferente con el --pathopción:

php artisan generate:migrations --path=database/migrations

Puede especificar la conexión para usar como base de datos con el --connectionopción:

php artisan generate:migrations --connection=mysql2

También puede borrar el directorio con el --empty-pathopción:

php artisan generate:migrations --empty-path

 

https://github.com/bennett-treptow/laravel-migration-generator?ref=laravelnews#example-usage

 https://laravel-news.com/migration-generator-for-laravel

 

MODELOS EN LARAVEL

Cada tabla de base de datos tiene un "Modelo" correspondiente que se utiliza para interactuar con esa tabla. Los modelos le permiten consultar datos en sus tablas, así como insertar nuevos registros en la tabla.

ELOQUENT ORM:

 

CREAR UN NUEVO MODELO DE ELOQUENT

Gracias a los comandos de artisan podemos crear los modelos desde la consola:

 $ php artisan make:model Movie

 Por lo general el nombre del modelo debe ser la primera letra en mayuscula y en singular, laravel ara el resto por nosotros.

$ php artisan make:model Movie -m

  Con el comando anterior se crearan dos archivos uno dentro de la carpeta /app llamado "Movie.php", el cual es el modelo y el otro create_movies_table_00000.php dentro de databse/migrations que es la migración para dicha tabla.

migracion::

public functio up(){

            schema::create('movie', function (Blueprint $table){

            $table->inscrements('id');

            $table->string('nombre',30);

            $table->string('descripcion');

            $table->timestamps();

}

 

})

Después de mirar el ejemplo anterior, es posible que haya notado que no le dijimos a Eloquent qué tabla de base de datos corresponde a nuestro Flightmodelo. Por convención, el "caso de la serpiente", el nombre plural de la clase se utilizará como nombre de la tabla a menos que se especifique explícitamente otro nombre. Entonces, en este caso, Eloquent asumirá el Flightmodelo almacena registros en el flightsmesa, mientras que un AirTrafficControllermodelo almacenaría registros en un air_traffic_controllersmesa.

Configuración del modelo

use Illuminate-Database-Eloquent-Model;

class Movie estends Model{

protected $table= 'movies';

protected $fillable=['name', 'descripcion'];

protected $guarded=['id']

}

 

 

Si la tabla de la base de datos correspondiente de su modelo no se ajusta a esta convención, puede especificar manualmente el nombre de la tabla del modelo definiendo un tablepropiedad en el modelo:

protected $table = 'my_flights';
 

Dentro de este array se pueden especificar cuáles campos puden ser llenados por asignación masiva(que es el caso cuando enviamos un formulario creando un array asociativo para ser guardado)

 $fillable=[];

 

Esta propiedad indica que los campos definidos allí no puden ser llenados usando Mass Assignment.

 $guarded =[];

 

Configuración del modelo

use Illuminate-Database-Eloquent-Model;

class Movie estends Model{

protected $table= 'movies';

protected $fillable=['name', 'descripcion'];

protected $guarded=['id']

}

 

use illuminare Database Eloquent Model;

class Movie exrends Model{

protected $table='movies';

protected $fillable=['name'.'descripcion'];

protected $guarded =['id']

}

GUARDAR UN NUEVO MODELO CON ELOQUENT

Cuando creamos un registro, instanciamos el modelo, asigamos los valores a cada campo y  procedemos a guardar. Con eloquent podemos hacer esto de dos formas diferentes.

Primero inciamos creando un controlador para el recurso movie, llamado

MovieController

$php artisan make:controler MovieController

En la cabecera de este archivo importamos el modelo movie con:

use app/movie as movie

 

La función store() sera quien reciba la peticion de guardado del nuevo registro, nos apoyaremos de la clase illuminate-Http-Request para manejar la peticion.

public function store(Request, $request){

$movie =new Movie;

$movie->nombre=$request->nombre;

$movie->descripcion=$request->descripcion;

$movie->save();

return redirect ('movie');

}

De esta forma instaciamos el modelo Movie, asignamos uno a uno los valores de cada campo de la tabla y luego guardamos usando el metodo save().

 

Segunda manera

public function store(Request, $request) {

$movie= new Movie;

$movie= create($request->all());

return redirect('Movie')

}

 

En este caso usamos el metodo create() y como nuestro formulario tiene los mismos nombres que los campos de la tabla, no habrá ningún problema al enviar el request como un array asociativo.

 

 https://norvicsoftware.com/eloquent-orm-en-laravel-8/

 https://geekflare.com/es/laravel-eloquent-model-relationship/

 

CONSTRUCTOR DE CONSULTAS (Query Builder)

Cuando estamos usando conexiones múltiple

//añadimos 
use Illuminate\Support\Facades\DB;

....
//obtenemos todos los usuarios
$users = DB::table('users')->get();

foreach ($users as $user)
{
    echo $user->name;
}

//Más ejemplos de consultas
$user = DB::table('users')->first();

$user = DB::table('users')->where('name', 'julio')->get();

$users = DB::table('users')->where('edad', '>', 100)->get();

$users = DB::table('users')->where('estado', '<>', 'active')->get();

$users = DB::table('users')->where('name', 'like', 'J%')->get();

//insertar
DB::table('Articulos')->insert(
        ['titulo'=>"pepe",'descripcion'=>"nuevadescripcion"]
    );

//update

DB::table('datos')
              ->where('id', 1)
              ->update(['nombre' => 'Estefania']);

//delete
DB::table('datos')->delete();
DB::table('datos')->where('votes', '>', 100)->delete();

CONSULTAS SQL NATIVAS

//seleccionar
$results = DB::select('select * from users where id = :id', ['id' => 1]);

//insertar en la Base users
DB::insert('insert into users (id, name) values (?, ?)', [1, 'Dayle']);

//actualizar
$affected = DB::update('update users set votes = 100 where name = ?', ['John']);

//borrar
$deleted = DB::delete('delete from users');

//Ejecutando una instrucción general que no devuelve ningún valor
DB::statement('drop table users');

http://documentacion-laravel.com/database.html#ejecutando-consultas-sql-nativas

ELOQUENT

$escritores=Escritor::all();  //$escritores=Escritor::get();

$escritoresOrdenados=Escritor::orderBy('nombre','DESC')->get();

$escritor= App\Escritor::findOrFail(1);

$escritor= App\Escritor::where('edad', '>', 100)->firstOrFail();

$escritor= App\Escritor::whereEdad(100)->get();  //es más eficiente especificar las columnas Escritor::select('id','name')->whereEdad(100)->get()

$EscritoresUlti=Escritor::latest('created_at')->get();   //muestra los últimos que se han añadido

 

• all() devuelve todos los elementos de una tabla.

• find($id) coge una id y devuelve un sólo modelo. Si no existe un modelo coincidente, devuelve null.

• findOrFail($id) toma una idy devuelve un sólo modelo. Si no existe un modelo coincidente, arroja un error1 404.

• first() devuelve el primer registro encontrado en la base de datos. Si no existe un modelo coincidente, devuelve null.

• firstOrFail() devuelve el primer registro encontrado en la base de datos. Si no existe un modelo coincidente, arroja un error1 404.

• get() devuelve una colección de modelos que coinciden con la consulta.

• findOrCreate() en el caso que no existe en la BD, lo crea.

Que es y como usar Laravel Tinker

 Altrabajar con eloquent, eloquent trata acada uno de los resgitros como si fuera un objeto si quisieramos a gregar un nuevo registro vamos a crear un nuevo objeto de la clase curso. Primero voy espesificar que voy hacer uso de ese modelo de una manera similar a la que hicimos cuando llamamos un controlador en las 

rutas debo escribir un use y pasarle su namespace e indicar el modelo exacto que vamos usar.

Una ves que ya indique que voy hacer uso del modelo curso voy a crear una instacia de esta clase.

 

Tinker es una consola de comandos con la que podremos interactuar con todas las clases y métodos de nuestra aplicación, una herramienta muy útil a la hora de realizar pruebas de funcionamiento
para correr tinker solo necesita correr el siguiente comando en consola:

php artisan tinker

>>> 

 

Para iniciar vamos a especificar qué quiero hacer uso del modelo movie de una manera similar a la que hicimos cuando llamamos a un controlador en las rutas debo escribir un  yus debo pasarles unam space lo pego aquí y indicarle el modelo exacto que queremos usar en este caso es el modelo Movie

https://norvicsoftware.com/tinker-consola-de-comandos-de-laravel/

Lo primero es hacer la referencia a nuestros modelos Alumno, Profesor y Curso.

 use App\Models\Profesor;

 use App\Models\Alumno;

 

guardar alumno

 $alumno = new Alumno;

 $alumno->nombre_apellido = 'Daniel Merida';

 $alumno->save();

 

Buscar alumno

 $alumno = Alumno::find(41);

>>> $user = new App\Movie;

  >>>$curso=curso::all();

 

  >>>$curso=curso::all()->take(6);

get->() Crea una coleccion de objetos

 >>>$curso=curso::select()->where()->take(6)->ger();

 

 >>>$curso=curso::find(5);

 

 Propiedad take en laravel

 >>> $user

 User::first();


Devuelve el primer usuario

Utilizando el método all() retornamos todos los registros asociados a un modelo:

$professions = Profession::all();

Los métodos all() y get() en Eloquent retornan colecciones (objetos de la clase Illuminate\Database\Eloquent\Collection) las cuales «envuelven» el array de resultados y nos proveen de funciones y métodos adicionales, por ejemplo:

 

 

Ahora veremos como se puede introducir registros a nuestra base de datos utilizando Eloquent desde Tinker. Lo primero es hacer la referencia a nuestros modelos Alumno, Profesor y Curso.

use App\Models\Profesor;

use App\Models\Alumno;

use App\Models\Curso;

 

 

Creando registros desde Tinker

En primer lugar, vamos a crear un objeto de tipo Alumno

$alumno = new Alumno;

Una vez instanciado el objeto $alumno podemos acceder a sus propiedades para asignarles su valor correspondiente.

$alumno->nombre_apellido = 'Daniel Merida';

$alumno->edad = 22;

$alumno->telefono = '+5348989887';

$alumno->direccion = 'Av. Los robles #675765';

Finalmente con el objeto $alumno llamamos a la función save() para guardar los datos en las tablas de nuestra base de datos.

$alumno->save();

Seguidamente, abrimos nuestro navegador favorito, nos dirigimos a phpMyAdmin, base de datos cursos_online (O el nombre que le dieron a su base de datos) y verificamos si el nuevo registro está en la tabla alumnos.

Editar registros desde Tinker

De manera similar, como lo hicimos en crear un registro, al editar la información de un determinado registro lo primero será obtenerlo de nuestra base de datos mediante su Id y cargarlo a la variable $alumno.

$alumno = Alumno::find(41);

Editamos los campos necesarios, en mi caso modificare los campos edad y dirección.

$alumno->edad = 23;

$alumno->direccion = 'Av los pinos #899';

Por último, vamos a llamar a la función save() para guardar los cambios.

$alumno->save();

De igual forma, verificamos si los datos fueron cambiados en la base de datos desde el phpMyAdmin

Eliminar registros desde tinker

De manera similar, cuando editamos un registro para eliminar lo primero es buscar un registro mediante su Id y cargarlo en el objeto $alumno.

$alumno = Alumno::find(41);

Por último, desde el objeto $alumno vamos a llamar al método delete() para eliminar el registro seleccionado.

$alumno->delete();

Buscar registros

Para poder buscar registros no es necesario crear una instancia del modelo, dado que el registro ya existe.

$product->all();

*Este comando retorna todos los registros

$product->find(1);

*Este comando retorna el elemento con el id especificado

$product->select("name", "slug")->where("id", 1)->get();

*Este comando selecciona los atributos solicitado del id indicado

$product->select("name", "slug")->where("id", 1)->first();

*El ejemplo anterior regresa una colección, pero cuando buscamos por ID ya sabemos que solo existe un registro, es por ello que podemos usar first para mostrar un solo registro

 

$product->where("slug","sudadera-politecnico-mujer-con-capucha")->get();

*El comando retorna un registro que coincide con la validación

 

$product->select("name", "slug")->whereBetween("amount_full", [150, 300])->get();

*Este comando retorna los parámetros indicados, con un rango de precios

$product->whereNull("SKU")->get();

*Este comando retorna los registros con valor null en el parámetro indicado

 

Modificar un registros

Para poder modificar registros es necesario primero buscar el registro a modificar, y luego una nueva asignación al atributo que se desea modificar y asignarle un nuevo valor y salvar

$producto::find(1);
$product->name = "Sudadera para mujer con descripción más cool";
$product->save();

Eliminar un registros

Para poder eliminar un registro es indispensable primero localizar el registro que se desea eliminar y usar el método delete o destroy.

$producto::find(1);
$product->delete();

Laravel Utilizando Eloquent ORM

 https://omarbarbosa.com/posts/optimiza-consultas-eloquent-reducir-uso-memoria-laravel

 https://ajgallego.gitbook.io/laravel-5/capitulo_3/base_de_datos_query_builder

 https://laravel.com/docs/4.2/eloquent

 

Devuelve una colección de objetos de todos los usuarios.

// retorna object(Illuminate\Database\Eloquent\Collection) $users = User::all(); $users = User::get();

Si buscamos un solo usuario, nos devuelve el modelo User.

// retorna object(App\User) $user = User::find(10); $user = User::all()->first();

Para crear un registro.

$user = new User; $user->username = "user"; $user->save(); // save retorna un boolean, podrían usarlo así: if( $user->save() ){ var_dump($user->id); }

Para actualizar un registro.

$user = User::find(10); $user->username = "new user"; $user->save();

Para eliminar un registro.

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

Usando where.

$user = User::where("estado","=",1)->find(10);

Para que nos devuelva una instancia de Illuminate\Pagination\LengthAwarePaginator y pagine cada 10 registros.

$users = User::where("estado","=",1)->paginate(10); // En la vista foreach ($users as $key => $user) { // $user es una Instancia de la clase User }

Seleccionamos solo algunas columnas.

$users = User::where("estado","=",1)->select("id","username")->paginate(10);

Si queremos usar alguna función de mysql, podemos usar DB::raw().

$users = User::where("estado","=",1) ->select(DB::raw("id,username, DATE_FORMAT(created_at,'%d/%m/%Y %h:%i %p') AS fecha")) ->paginate(10);

Otras funciones

$users = User::where("estado","=",1) ->whereNotNull('updated_at') ->whereNull('email') ->whereIn('id', [1, 2, 3]) ->whereBetween('edad', [1, 30]) ->where('username','like','%ad%') ->orderBy('username') ->orderBy('created_at','desc') ->skip(10)->take(5) ->get();

Obtener las consultas generadas

Para ver la consulta SQL que genera usamos DB::getQueryLog() esta función devuelve un array con todas las consultas que se han generado.

En Laravel 4

// En Laravel 4 $log = DB::getQueryLog(); var_dump($log);

En Laravel 5

DB::enableQueryLog(); $log = DB::getQueryLog(); var_dump($log); // Multiples conexiones DB::connection('connection1')->enableQueryLog(); DB::connection('connection1')->getQueryLog(); DB::connection('connection2')->enableQueryLog(); DB::connection('connection2')->getQueryLog();

Para que los registros devuelvan en array o formato json.

$users = User::where("estado","=",1)->get()->toArray(); $users = User::where("estado","=",1)->get()->toJson(); $users = User::where("estado","=",1)->first()->toArray();

Si queremos usar un condicional al momento de generar las consultas.

$users = User::where("estado","=",1); if($buscar) $users = $users->where('username','like','%ad%'); $users = $users->get();

Consultas con Join y Left Join

Usando Join y Left Join

$users = User::join("roles","users.roles_id","=","roles.id") ->where('users.estado','=',1) ->get();   $users = User::leftJoin("roles","users.roles_id","=","roles.id") ->where('users.estado','=',1) ->get();   $users = User::join("roles","users.roles_id","=","roles.id") ->leftJoin('posts',function($join){ $join->on('users.posts_id','=','posts.id')->where('posts.estado','=',1); }) ->where('users.estado','=',1) ->get();   $users = User::join("roles","users.roles_id","=","roles.id") ->leftJoin(DB::raw("(SELECT * FROM posts where posts.estado=1) as posts"),function($join){ $join->on('users.posts_id','=','posts.id'); }) ->where('users.estado','=',1) ->get();

Laravel usando Query Builder para generar SQL

Consultas varias

DB::table('users') ->whereExists(function ($query) { $query->select(DB::raw(1)) ->from('orders') ->whereRaw('orders.user_id = users.id'); }) ->get();   $users = DB::table('orders') ->select('department', DB::raw('SUM(price) as total_sales')) ->groupBy('department') ->havingRaw('SUM(price) > 2500') ->get();

Para insertar un registro.

DB::table('users')->insert( ['username' => 'editor', 'edad' => 20] );

Para actualizar registros.

DB::table('users') ->where('id', 1) ->update(['edad' => 20]);

Para eliminar registros.

DB::table('users')->delete(); DB::table('users')->where('edad', '<', 20)->delete();

Usando Join y Left Join.

$users = DB::table('users') ->join('contacts', 'users.id', '=', 'contacts.user_id') ->join('orders', 'users.id', '=', 'orders.user_id') ->select('users.*', 'contacts.phone', 'orders.price') ->get();   $users = DB::table('users') ->leftJoin('posts', 'users.id', '=', 'posts.user_id') ->get();

Actualizar registros entre dos tablas

DB::table('posts') ->join('users', 'posts.users_id', '=', 'users.id') ->where('estado','=',1) ->update(array('posts.order'=>1));

Transacciones

DB::beginTransaction(); $user = new User; $user->username = "user"; if($user->save()) DB::commit(); else DB::rollback();

Procedimientos almacenados

$sql = "call my_procedure(?,?)"; DB::select($sql,array(1,20)); // retorna un array de objetos.

$db = DB::connection(); $stmt = $db->getPdo()->prepare("CALL my_procedure(?,?)"); $stmt->execute(['buscar',5]); $result = $stmt->fetchAll(PDO::FETCH_CLASS, 'stdClass');

Otras formas de ejecutar consultas en Laravel

$sql = "SELECT * FROM users WHERE estado=? AND edad<?"; DB::select($sql,array(1,20));   $sql = "SELECT * FROM users WHERE estado=? AND edad<?"; DB::statement($sql,array(1,20));   $sql = "SET FOREIGN_KEY_CHECKS = 0;DROP TABLE IF EXISTS `users`;DROP TABLE IF EXISTS `roles`;"; DB::unprepared($sql);   $file_sql = './data/consultas.sql'; $sql = file_get_contents($file_sql); DB::unprepared($sql);   // Si pierdes la conexión, ejemplo cuando eliminas y vuelves a crear la base de datos, esta función te permite reconectar y seguir trabajando. DB::reconnect();

Relaciones en Laravel

Convenciones de Eloquent Model

La tabla de un Modelo se le agrega la s, en plural.
La tabla de la clase Post sería posts.
La tabla de la clase ProductImage sería product_images.
El campo primary key de una tabla debe tener el nombre de id, con el atributo AUTO_INCREMENT.

Estructura básica de la clase Post

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Post extends Model { // }

Dentro de la clase podemos definir diferente a lo predeterminado

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Post extends Model { // cambiar el nombre de la tabla protected $table = 'my_post';   // Por defecto id es la clave primaria, podemos definir un campo diferente con la propiedad primaryKey protected $primaryKey = 'id_post';   // Todo modelo debe tener 2 campos created_at y updated_at, si no usamos esos campos en nuestra tabla // definimos de la siguiente manera public $timestamps = false;   // Definir un nombre de conexión diferente protected $connection = 'connection-name';   // Atributos que pueden ser asignados en App\Post::create(['name' => 'Article 1']); protected $fillable = ['name'];   // Todos los atributos se pueden asignar excepto price protected $guarded = ['price']; }

Uno a Uno

Ejemplo User y Phone estan relacionados uno a uno

<?php namespace App; use Illuminate\Database\Eloquent\Model; class User extends Model { /** * Get the phone record associated with the user. */ public function phone() { return $this->hasOne('App\Phone'); // Si el id tienen diferentes nombres return $this->hasOne('App\Phone', 'user_id', 'local_key'); } }

Definimos la otra clase

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Phone extends Model { /** * Get the user that owns the phone. */ public function user() { return $this->belongsTo('App\User'); // Si el id tienen diferentes nombres return $this->belongsTo('App\User', 'user_id', 'local_key'); } }

Uno a Muchos

Un Post tiene muchos Comentarios

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Post extends Model { /** * Get the comments for the blog post. */ public function comments() { return $this->hasMany('App\Comment'); // Si el id tienen diferentes nombres return $this->hasMany('App\Comment', 'post_id', 'local_key'); } }

Un Comentario pertenece a un Post

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Comment extends Model { /** * Get the post that owns the comment. */ public function post() { return $this->belongsTo('App\Post'); } }

Muchos a Muchos

Un Usuario tiene varios Roles

<?php namespace App; use Illuminate\Database\Eloquent\Model; class User extends Model { /** * The roles that belong to the user. */ public function roles() { return $this->belongsToMany('App\Role'); // Si el nombre de la tabla es diferente a lo predeterminado o el ID de la tabla tiene otro nombre. return $this->belongsToMany('App\Role', 'user_roles', 'user_id', 'role_id'); } }

Un Rol tiene varios Usuarios

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Role extends Model { /** * The users that belong to the role. */ public function users() { return $this->belongsToMany('App\User'); // Si el nombre de la tabla es diferente a lo predeterminado o el ID de la tabla tiene otro nombre. return $this->belongsToMany('App\User', 'user_roles', 'role_id', 'user_id'); } }

Recuperando columnas de tablas intermedias

Definimos en la función withPivot los campos de la tabla intermedia

<?php namespace App; use Illuminate\Database\Eloquent\Model; class User extends Model { public function roles() { return $this->belongsToMany('App\Role', 'user_roles') ->withPivot('create', 'read','update', 'delete'); } }

Accedemos al campo de la siguiente manera.

$user = App\User::find(1); foreach ($user->roles as $role) { echo $role->pivot->create; }

Diferencias en el retorno del resultado

// retorna App\Phone App\User::first()->phone; // retorna Illuminate\Database\Eloquent\Relations\BelongsToMany App\User::first()->roles(); // retorna Illuminate\Database\Eloquent\Collection App\User::first()->roles;

Usando Alias para las tablas

$users = User::from('users as a') ->join('roles as b',function($join){ $join->on('a.roles_id','=','b.id')->where('b.estado','=',1); }) ->select("a.*","b.name") ->where('a.estado','=',1) ->get();

Ejemplo: Buscar un término

$search = 'Palabra a buscar'; $posts = Post::from('posts as a') ->where(function ($query) use ($search) { $query = $query->orWhere('a.titulo','like',"%$search%"); $query = $query->orWhere('a.descripcion','like',"%$search%"); $query = $query->orWhere('a.tags','like',"%$search%"); }); $posts = $posts->where('a.estado','=',1) ->get();

Ejemplo: Buscando varias palabras en varias columnas

$columns = ['titulo','descripcion','tags']; $term = 'Palabras a buscar'; $words_search = explode(" ",$term); $posts = Post::from('posts as a') ->where(function ($query) use ($columns,$words_search) { foreach ($words_search as $word) { $query = $query->where(function ($query) use ($columns,$word) { foreach ($columns as $column) { $query->orWhere($column,'like',"%$word%"); } }); } }); $posts = $posts->where('a.estado','=',1) ->get();

Consultas con prefijo de tabla

En Laravel podemos configurar un prefijo a todas las tablas de nuestra Base de Datos, ese cambio lo realizamos en el archivo config/database.php, en la opción prefix.
Si ponemos prefijo_ las tablas se llamarían prefijo_users

'mysql' => [ 'driver' => 'mysql', 'host' => env('DB_HOST', 'localhost'), 'database' => env('DB_DATABASE', 'database'), 'username' => env('DB_USERNAME', 'root'), 'password' => env('DB_PASSWORD', ''), 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => 'prefijo_', 'strict' => false, 'options' => array(), ],

Si realizamos consultas simples no habría ningún problema con este cambio, pero cuando realizamos consultas complejas usando la función DB::raw es donde tenemos que obtener el prefijo y agregarlo a nuestra consulta.
Con esta función obtenemos el prefijo.

$db_prefix = DB::getTablePrefix();

Ahora dentro de la función DB::raw ingresamos el prefijo.

$users = App\User::join("roles","users.roles_id","=","roles.id") ->leftJoin(DB::raw("(SELECT * FROM {$db_prefix}posts where {$db_prefix}posts.estado=1) as posts"), function($join){ $join->on('users.id','=','posts.users_id'); } ) ->select(DB::raw("{$db_prefix}users.*")) ->addSelect(DB::raw("DATE_FORMAT({$db_prefix}posts.created_at,'%d/%m/%Y %h:%i %p') AS posts_creado")) ->where('users.estado','=',1) ->where('posts.comments_count','>',0) ->whereRaw(DB::raw("{$db_prefix}posts.tags !=''")) ->get();

También tenemos que agregar el prefijo de las tablas cuando usamos consultas SQL puras.

$sql = "SELECT * FROM {$db_prefix}users WHERE {$db_prefix}users.estado = ? AND {$db_prefix}users.edad < ?";
DB::select($sql,array(1,20));