Usando Illuminate Database Con Eloquent en Tu Aplicación PHP Sin Laravel

() translation by (you can also view the original English article)

Illuminate es el motor de base de datos de Laravel sin Laravel. Viene en paquete con el ORM Eloquent en Laravel. Si te gustaría construir tus aplicaciones PHP con ORMs y prefieres no usar Laravel, este tutorial es para ti.

En este tutorial, vamos a construir el back end para una aplicación Q&A con PHP, Illuminate Databse y el ORM Eloquent.

Dependencias del Proyecto

PHP: 5.5+
MYSQL
Composer

Capacidades de Aplicación

Nuestra aplicación desempeñará diez tareas:

Agregar un usuario.
Agregar una pregunta.
Agregar una respuesta a una pregunta.
Votar una respuesta.
Obtener una pregunta con respuestas.
Obtén todas las preguntas y usuarios que las hicieron.
Obtén preguntas, respuestas y votos particulares.
Cuanta preguntas de un usuario particular.
Actualiza una respuesta por usuario.
Borra una pregunta.

Primero, creamos nuestro directorio y estructura de proyecto.

En el directorio principal de proyecto, crearemos una carpeta app, y después en esta carpeta app, crearemos dos carpetas: models y controllers. En esta imagen, nuestra carpeta principal de proyecto se llama eloquent. Deberías reemplazarla con cualquier nombre que prefieras.

Después, creamos un archivo index.php en la carpeta principal, al mismo nivel que la carpeta app.

Usaremos git, para que podamos crear un archivo .gitignore. Nota que este paso es opcional.

Después, instalamos las dependencias necesarias para este proyecto para trabajar. En la carpeta principal del proyecto, crearemos un archivo composer.json. Después pegaremos esto en nuestro archivo composer.json.

{
 “name”: “illuminate-example/eloquent”,
 “description”: “Implementation of Database Queries with illuminate and Eloquent”,
 “type”: “project”,
 “require”: {}
}

Para instalar la base de datos Illuminate, agregamos esto a nuestro composer.json:
“illuminate/database”: “5.1.8”,.

Después, agregamos autocarga psr-4 para nuestros Modelos y controladores:

“autoload”: {
 “psr-4”: {
 “Controllers\\”: “app/controllers/”,
 “Models\\”: “app/models/” }
 }

Ahora, nuestro archivo composer.json debería lucir así:

{
 “name”: “illuminate-example/eloquent”,
 “description”: “Implementation of Database Queries with illuminate and Eloquent”,
 “type”: “project”,
 “require”: {
 “illuminate/database”: “5.1.8”},
 “autoload”: 
    {“psr-4”: 
        { “Controllers\\”: “app/controllers/”,
            “Models\\”: “app/models/"
            
                 }
    }
}

Ahora ejecutaremos estos dos coamandos composer en la misma ubicación que nuestro archivo composer.json:

1	composer install
2	composer dump-autoload -o

Esto generará un folder vendor que podemos agregar a gitignore (este también es un paso opcional).

Agreguemos un archivo config para nuestras credenciales de base de datos.

En el directorio principal del proyecto, creamos un archivo llamado config.php y definimos los detalles de la BD en el archivo Config.php. Nota que los valores deberían ser reemplazados con tus propios detalles de conexión.

<?php

defined(“DBDRIVER”)or define(‘DBDRIVER’,’mysql’);
defined(“DBHOST”)or define(‘DBHOST’,’localhost’);
defined(“DBNAME”)or define(‘DBNAME’,’eloquent-app’);
defined(“DBUSER”)or define(‘DBUSER’,’root’);
defined(“DBPASS”)or define(‘DBPASS’,’pass’);

Después, creamos el esquema para nuestra aplicación.

Una cosa que notar antes de que creemos el esquema para las tablas en nuestra base de datos es que podemos agregar estampas de tiempo a nuestro esquema.

El ORM eloquent espera dos columnas timestamp si queremos que habiliten la operación timestamp en una tabla/modelo particular. Estas son las columnas created_at y updated_at. Si habilitamos timestamps para un modelo, Eloquent automáticamente actualiza estos campos con el tiempo cuando creamos o actualizamos un registro.

Hay una tercera columna llamada deleted_at. La estampa de tiempo deleted_at trabaja diferente, sin embargo. Eloquent tiene una capacidad de borrado suave que usa la columna deleted_at para determinar si un registro ha sido borrado. Si borras un registro con la función 'delete' de eloquent y quieres habilitar Soft Delete, la columna es actualizada con el tiempo de borrado. Estos elementos borrados pueden ser entonces recuperados en cualquier momento.

En esta aplicación, estaremos sacando ventaja de las estampas de tiempo, así que usaremos las tres en nuestro Esquema de creación.

Crea tablas con los siguientes comando en MySQL:

Preguntas

CREATE TABLE `questions` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `question` tinytext,
 `user_id` int(11) DEFAULT NULL,
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 `deleted_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Respuestas

CREATE TABLE `answers` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `answer` tinytext,
 `user_id` int(11) DEFAULT NULL,
 `question_id` int(11) DEFAULT NULL,
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 `deleted_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Votos

CREATE TABLE `upvotes` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `answer_id` int(11) DEFAULT NULL,
 `user_id` int(11) DEFAULT NULL,
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 `deleted_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Usuarios

CREATE TABLE `users` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `username` varchar(100) DEFAULT NULL,
 `email` varchar(200) DEFAULT NULL,
 `password` varchar(200) DEFAULT NULL,
 `created_at` timestamp NULL DEFAULT NULL,
 `updated_at` timestamp NULL DEFAULT NULL,
 `deleted_at` timestamp NULL DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Procederemos creando archivos para modelos y controladores para nuestras tablas en las siguientes ubicaciones:

project_folder/app/models/question.php
project_folder/app/models/answer.php
project_folder/app/models/upvote.php
project_folder/app/models/user.php
project_folder/app/models/database.php
project_folder/app/controllers/questions.php
project_folder/app/controllers/answers.php
project_folder/app/controllers/upvotes.php
project_folder/app/controllers/users.php

Abre models/database.php con un editor.

Primero creamos la Cápsula:

<?php

namespace Models; 
use Illuminate\Database\Capsule\Manager as Capsule;

class Database {

    function __construct() {
    $capsule = new Capsule;
    $capsule->addConnection([
     ‘driver’ => DBDRIVER,
     ‘host’ => DBHOST,
     ‘database’ => DBNAME,
     ‘username’ => DBUSER,
     ‘password’ => DBPASS,
     ‘charset’ => ‘utf8’,
     ‘collation’ => ‘utf8_unicode_ci’,
     ‘prefix’ => ‘’,
    ]);
    // Setup the Eloquent ORM… 
    $capsule->bootEloquent();
}

}

En el archivo de arriba, inicializamos y configuramos la cápsula con las constantes definidas en config.php, y después iniciamos eloquent.

El siguiente paso es crear un script inicial. Este será un archivo en donde todo lo que tiene que ser ejecutado antes de nuestra app es ejecutado.

Creamos un archivo de inicio en la ubicación project_folder/start.php, y después en el archivo, requiere un archivo de auto-carga Composer:

require ‘vendor/autoload.php’;

Después de eso, requerimos config.php para obtener las credenciales definidas: require ‘config.php’;

Después inicializamos la clase de la base de datos.

<?php

use Models\Database;

//Boot Database Connection
new Database();

Tu start.php debería lucir como esto:

<?php
require ‘config.php’;
require ‘vendor/autoload.php’;
use Models\Database;
//Initialize Illuminate Database Connection
new Database();
?>

Incluye start.php en tu index.php ya que este será nuestro archivo principal.

Nuestro archivo index.php ahora luce así:

1	<?php
2	require ‘start.php’;
3	?>

Después, podemos comenzar a trabajar sobre nuestros controladores y modelos. En project_folder/app/models/question.php, agregamos esto:

<?php

namespace Models;

use \Illuminate\Database\Eloquent\Model;

class Question extends Model {
    
    protected $table = ‘questions’;
    
}

?>

Después en project_folder/app/controllers/questions.php:

<?php
namespace Controllers;

class Questions{
    
}

?>

En project_folder/app/controllers/answers.php, hacemos lo mismo:

<?php
namespace Controllers;

class Answers{
    
}
?>

Tarea 1: Agrega un Usuario

En el modelo usuario (project_folder/app/models/user.php), agregamos el siguiente código para definir nuestro namespace, extender el Modelo Eloquent y definir el nombre de la tabla (protected $table) y qué campos en las tablas pueden ser llenados por creación masiva (protected $fillable).

<?php
namespace Models;
use \Illuminate\Database\Eloquent\Model;

class User extends Model {
    protected $table = ‘users’;
    protected $fillable = [‘username’,’email’,’pass’];
}
?>

En el controlador de usuarios (project_folder/app/controllers/user.php), definimos nuestro namespace y clase como es usual:

<?php
namespace Controllers;

class Users{
    
}
?>

Después para crear un usuario, en el controlador de usuarios, importamos el namespace de Modelo de usuario, use Models\User;, y después agregamos una función para crear el usuario.

<?php

    public static function create_user($username, $email, $password){
        $user = User::create(['username'=>$username,'email'=>$email,'password'=>$password]);
        return $user;
    }

Nuestro controlador de usuario luce así:

<?php

namespace Controllers;
use Models\User;

class Users {
    
    public static function create_user($username, $email, $password){
        $user = User::create(['username'=>$username,'email'=>$email,'password'=>$password]);
        return $user;
    }
}
?>

Después en index.php, agregamos estas líneas y ejecutamos la aplicación para crear un nuevo usuario.

<?php

use Controllers\Users; 

// Import user controller
$user = Users::create_user(“user1”,”user1@example.com”,”user1_pass”);

Tarea 2: Agrega una Pregunta

Para agregar una pregunta importamos el namespace de modelo Pregunta en el controlador de preguntas, y escribimos una función create_question:

use Models\Question;

Después:

<?php

public static function create_question($question,$user_id){

    $question = Question::create(['question'=>$question,'user_id'=>$user_id]);
    return $question;
}

Hemos usado modelos de creación masiva de Eloquent para insertar este registro, pero antes de que funciones, necesitamos permitir que esos campos sean llenables, porque los modelos de Eloquent protegen contra creación masiva por defecto.

Así que vamos al modelo question y agregamos la propiedad protected $fillable a la clase.

protected $fillable = ['question','user_id'];

Para ejecutar esto, importa el controlador de preguntas en index.php y llama a la función create_question de manera estática:

use Controllers\Question;

Después crea una pregunta con una pregunta y Id de Usuario como parámetros:

$question = Questions::create_question("Have you ever met your doppelganger?",1);

Esto devuelve un objeto modelo si es exitoso.

Ahora ejecutaremos el script index.php con diferentes entradas para agregar más preguntas a la base de datos.

Tarea 3: Agrega una Respuesta a una Pregunta

En el modelo respuesta, repetimos los pasos tomados para los modelos pregunta y usuario agregando el código de abajo:

<?php
namespace Models;
use \Illuminate\Database\Eloquent\Model;

class Answer extends Model {
    
    protected $table = ‘answers’;
    protected $fillable = [‘answer’,’user_id’,’question_id’];
    
}
?>

Después en el controlador de respuestas, escribimos estas líneas:

<?php

namespace Controllers;
use Models\Answer;


class Answers {

    public static function add_answer($answer,$question_id,$user_id){
        $answer = Answer::create(['answer'=>$answer,'question_id'=>$question_id,'user_id'=>$user_id]);return $answer;
    }
}

?>

Después en index.php, podemos crear una respuesta para la pregunta con id 1 que agregamos anteriormente, con user id 2. No olvides importar el controlador respuestas a index.php primero.

<?php

use Controllers\Answers;

    $answers = Answers::add_answer(“This is an answer”,1,2);

Para prevenir múltiples entradas, comenta todas las otras llamadas en index.php antes de ejecutar una nueva.

Tarea 4: Vota una Respuesta

Estos son prácticamente los mismos pasos a los que estamos acostumbrados.

Así que copiaremos esto al modelo Upvote en project_folder/app/models/upvote.php.

<?php 
namespace Models;

use \Illuminate\Database\Eloquent\Model;


class Upvote extends Model {

    protected $table = 'upvotes';
    protected $fillable = ['answer_id','user_id'];
     
}
 ?>

Después en el controlador respuestas, importamos el Upvote Model namespace.

use Models\Upvote;

Después creamos una función upvote_answer.

<?php

    public static function upvote_answer($answer_id,$user_id){
        $upvote = Upvote::create(['answer_id'=>$answer_id,'user_id'=>$user_id]);
        return $upvote;
    }

En index.php, podemos llamar la función con un User ID dummy para votar la respuesta con id 1.

$upvote = Answers::upvote_answer(1,14);

Task 5: Obtén una Pregunta Con Respuestas

Para tareas como esta, podemos usar relaciones Eloquent.

Los tipos de relaciones incluyen uno a uno, uno a muchos, muchos a muchos, etc.

Cuando usamos estas relaciones, Eloquent asume una llave foránea en la forma que modelname_id existe en los modelos. Para esta tarea, la relación es una relación uno-a-muchos porque una sola pregunta puede poseer cualquier cantidad de respuestas.

Primero definimos esta relación agregando esta función a nuestro modelo pregunta.

<?php

public function answers()
{
    return $this->hasMany('\Models\Answer');
}

Después en el controlador preguntas, escribimos una función para obtener preguntas con respuestas.

<?php

public static function get_questions_with_answers(){
 
    $questions = Question::with('answers')->get()->toArray();
    return $questions;
}

Esto trae las preguntas con sus respuestas correspondientes.

En index.php, comentamos todas las otras llamadas y ejecutamos:

$all = Questions::get_questions_with_answers();

Podemos hacer var_dump o print_r a la variable $all para ver los resultados.

Tarea 6: Obtén Todas las Preguntas y Usuarios Que Las Hicieron

Esta es una relación uno a uno porque una pregunta tiene un usuario, así que agregamos esto al modelo pregunta.

<?php

public function user()
{
    return $this->belongsTo(‘\Models\User’);
}

Después creamos una función en el controlador preguntas y usamos la función with en el modelo pregunta.

<?php

public static function get_questions_with_users(){

    $questions = Question::with('user')->get()->toArray();
    return $questions; 
}

En index.php, comentamos todas las demás y ejecutamos esto:

$all_with_users = Questions::get_questions_with_users();

Tarea 7: Obtén Una Pregunta Con Respuestas y Votos

Primero, definimos una relación entre respuestas y votos. Una respuesta tiene muchos votos, así que la relación es uno a muchos.

Así que agregamos la siguiente función a nuestro modelo respuesta:

<?php

public function upvotes()
{
    return $this->hasMany('\Models\Upvote');
}

Después en el controlador preguntas, creamos la función para obtener esto:

<?php

public static function get_question_answers_upvotes($question_id){

    $questions = Question::find($question_id)->answers()->with('upvotes')->get()->toArray();
    return $questions;
}

Como en los pasos anteriores, comentamos todas las otras llamadas para index.php y ejecutamos esto:

$one_question = Questions::get_question_answers_upvotes(1);

Podemos imprimir la variable $one_question para ver los resultados.

Tarea 8: Cuenta Todas las Preguntas de un Usuario Particular

Primero importamos el modelo pregunta en los controladores de usuarios:

use Models\Question;

Después escribimos esta función:

<?php

public static function question_count($user_id){

    $count = Question::where('user_id',$user_id)->count();
    return $count;
}

En index.php, comentamos otras llamadas y agregamos esta línea:

$user_question_count = Users::question_count(1);

Esto devuelve un entero que es el número de preguntas que han sido agregadas por un usuario con id 1.

Podemos imprimir la variable $user_question_count y ejecutar index.php para ver los resultados.

Tarea 9: Actualiza la Respuesta por Usuario

El concepto de actualizar con el ORM Eloquent es bastante simple. Primero, encontramos un registro, y después lo mutamos y guardamos.

Ahora, en los controladores de respuestas, agregamos esta función:

<?php

public static function update_answer($answer_id,$new_answer){
    $answer = Answer::find($answer_id);
    $answer->answer = $new_answer;
    $updated = $answer->save();
    return $updated;
}

En index.php, podemos comentar todas las otras llamadas, y actualizar la respuesta con id 1 como esto:

$update_answer = Answers::update_answer(1,”This is an updated answer”);

Esto devuelve un valor booleano--true--si la actualización es exitosa.

Tarea 10: Borra una Pregunta (Borrado Suave)

En esta tarea final, vamos a implementar Eloquent SoftDelete.

Primero le decimos al modelo pregunta que use SodtDeletes importando en namespace SoftDeletes, y después usando la característica SoftDeletes en nuestra clase.

use Illuminate\Database\Eloquent\SoftDeletes;

Después de la línea de declaración de la clase, agrega esta línea:

use SoftDeletes;

Después agregamos delete_at a la propiedad protected $dates para el modelo. Estos son los pasos requeridos.

protected $dates = [‘deleted_at’];

Nuestro modelo pregunta ahora se ve así:

<?php 
namespace Models;
use \Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
class Question extends Model {

use SoftDeletes; 
    protected $table = 'questions';
    protected $fillable = ['question','user_id'];


    public function answers()
    {
        return $this->hasMany('\Models\Answer');
    }
    
    
    public function user()
    {
        return $this->belongsTo('\Models\User');
    }

 }

 ?>

Después creamos la función delete_question en el controlador preguntas.

<?php

public static function delete_question($question_id){

    $question = Question::find($question_id);
    $deleted = $question->delete();
    return $deleted; 

}

Ejecuta en index.php:

$delete = Questions::delete_question(1);

¡Felicidades! Acabas de construir un back end totalmente funcional con Illuminate y Eloquent. Y no tuvimos que escribir tanto código para lograrlo.

El código para este tutorial puede ser encontrado en GitHub.

Conclusión

Illuminate también viene con el Query Builder que puedes usar para consultas a la base de datos incluso más complejas y es definitivamente algo con lo que quieres experimentar y usar en tu aplicación.

La última cosa faltante en la Illuminate Database autónoma es migración de bases de datos, la cuál es una característica encantadora de Laravel. Deberías considerar usar ambas en tus aplicaciones para tomar las ventajas de las útiles características que vienen con estas.

Puedes averiguar más sobre Eloquent en la Página de Documentación Oficial de Eloquent.