Usuario:ManuelRomero/Laravel/migraciones

Migraciones

https://laravel.com/docs/master/migrations

Es una forma de crear fácilmente una base de datos para trabajar con laravel.
Migración es un término que alude al hecho de que vamos a pasar o migrar la base de datos de un fichero php a la base de datos de un servidor.

(: No confundir migración con pasar una base de datos que tenga en mi gestor a mi aplicación.)

Para trabajar con una base de datos, lo primero que hemos hacer es configurar la base de datos con la que queremos trabajar.

Configurar la conexión

Ir al fichero .env

Establecer los parámetros de conexión

.....
 DB_CONNECTION=mysql
 DB_HOST=127.0.0.1
 DB_PORT=3306
 DB_DATABASE=Nombre_Base_Datos
 DB_USERNAME=root
 DB_PASSWORD=root
....

Configurar conexiónes

En el caso anterior estamos usando una conexión llamada 'mysql'.
Podemos tener varias conexiones, las establecemos en el fichero de configuración de la base de datos config/database.php

 'connections' => [
 
//.....
        'mysql' => [ //Aquí parámetros de conexión para una conexión llamada msyql
            'driver' => 'mysql',
            'url' => env('DATABASE_URL'),
            'host' => env('DB_HOST', '127.0.0.1'),
            'port' => env('DB_PORT', '3306'),
            'database' => env('DB_DATABASE', 'forge'),
            'username' => env('DB_USERNAME', 'forge'),
            'password' => env('DB_PASSWORD', ''),
            'unix_socket' => env('DB_SOCKET', ''),
            'charset' => 'utf8mb4',
            'collation' => 'utf8mb4_unicode_ci',
            'prefix' => '',
            'prefix_indexes' => true,
            'strict' => true,
            'engine' => null,
            'options' => extension_loaded('pdo_mysql') ? array_filter([
                PDO::MYSQL_ATTR_SSL_CA => env('MYSQL_ATTR_SSL_CA'),
            ]) : [],
        ],
   'mysql2' => [
     //Parámetros de conexión para la conexión llamada mysql2
    ],
    //.....
//...

Hay que tener en cuenta que este sistema es como crear las tablas/campos con phpmyadmin u otro gestor
Tiene una serie de ventajas, una vez que has creado las migraciones, otros las pueden ejecutar para tener exactamente tu estructura de bases de datos, y también puedes tener un control de versiones sobre tu base de datos

Crear Migraciones

Para crear una migración especificamos el nombre

 php artisan make:migration usuarios

Esto nos creará un fichero con la estructura de la migración en database/migration/fecha_nombre_migracion.php

Archivo:Migration:usuarios.png

Podemos especificar el nombre de la tabla con --table o --create

 php artisan make:migration usuarios --table=usuarios
 o
 php artisan make:migration usuarios --create=usuarios

Para elecutar una migración

php artisan migrate:install

Con esto tendríamos creada un migración.
Ahora si vamos al phpmyadmin observamos que tenemos creada la tabla migrations con dos campos

Ahora tendremos que indicar la/s tabla/s que queremos crear
Para añadir los campos de la tabla tendremos que ir a la carpeta database/migrations/FECHA_CREACION_usuarios.php y lo abrimos
En el vemos que tenemos dos métodos uno up y otro down
Ahora tendríamos que ir a la clase tabla_producto y en el método up e indicar la estructura de tabla a crear.

<?php
 
use Illuminate\Database\Migrations\Migration;
 
class CrearTablaUsuario extends Migration {
 
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('usuarios', function($tabla) 
        {
            $tabla->increments('id');
            $tabla->string('nombre', 50);
            $tabla->string('email', 100)->unique();
            $tabla->string('password', 200);
            $tabla->timestamps();
        });
    }
 
    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('usuarios');
    }
}

Modificando la migración

Podemos volver a alterar la estructura de la base de datos y volver a ejectuar la migración.

Modificando, ejecutando migraciones

Ejectuar la migración

php artisan migrate

Deshace la última migración (ejecutando métodos down de cada una de ellas)

php artisan migrate:roollback

Deshace las 3 últimas migracion

php artisan migrate:roollback --step=3

Deshace todo (ejecuta los métodos down de cada migración )

php artisan migrate:reset

Deshace todo y vuelve a ejectuar las migraciones: (métodos down y up de cada migración)

php artisan migrate:refresh

Deshace todo y vuelve a ejectuar las migraciones y ejecuta la población de datos

php artisan migrate:refresh --seed

Borra todas las tablas de la base de datos y ejecuta las migraciones (solo métodos up)

php artisan migrate:fresh

Vemos como se crean los campos. Los tipos string, laravel los convierte a Varchar2.
id es de tipo autoincremento
timestamps, básicamente lo que hace ese método es crear dos campos llamados created_at y otro updated_at.
Estos campos son de tipo TIMESTAMP. Nos informarán de cuando fue creado o modificado cada uno de los registros de nuestra tabla.

Tipos de datos

A la hora de crear las tablas tenemos disponibles los tipos de datos que hay en sql
Podemos verlos en la página de Laravel https://laravel.com/docs/9.x/migrations#available-column-types

La clase Schema (facade)

Esta clase proporcina métodos para toda el LDD (lenguaje de definición de datos) del gestor de bases de datos

https://laravel.com/docs/master/migrations#creating-tables

Crear las tablas con campos especificados (método create)

  Schema::create('usuarios', function($tabla) 
        {
         $tabla->increments('id'); //Campo autoincrementto
         $tabla->string('nombre', 50); //String
         $tabla->string('email', 100)->unique();
         $tabla->string('password', 200);
         $tabla->string('direccion', 200);
         $tabla->timestamps(); //Crea los campos update_up y current_up de tipo '''''timestamp'''''
        });

Para ver los métodos para especificar los tipos campos de la base de datos consultar a la web de referencia.

Borrar la tabla, método drop

  Schema::drop('nombreTabla');
  Schema::dropIfExists('users');

Cambiar el nombre de una tabla, método rename

Schema::table('nombre_Tabla', function (Blueprint $table) {
///
  Schema::rename('nombreAntiguo','nombreNuevo);
}

Cambiar el nombre de un campo de una tabla, método rename

Schema::table('nombre_Tabla', function (Blueprint $table) {
///
 
  Schema::renameColumn('nombreAntiguo','nombreNuevo);
}

Añadir un campo en la tabla método table

Schema::table('nombreTabla', function($table)
{
    $table->string('email');
});

Añadir restricciones

1.- clave primaria

$table->primary('id'); //Clave principal id
$table->primary(array('first', 'last'));//Clave principal compuesta

1.- clave candidata o valor único

$table->unique('email');

1.- índice

  $table->index('codigo'); 	Agregar un índice básico

=

Poblando una base de datos desde migration

Laravel provee una sencilla manera de poblar una base de datos
Esta acción se conoce como seeding
En una forma de gestionar todo desde el framework, no obstante igualmente se puede hacer directamente desde el phpmyadmin.
Vamos a utilizarlo
Primero vamos a la carpeta app/database/seedsy creamos un fichero PoblarUsuariosSeeder.php
Como siempre, estas acciones se recomienda hacerlas directametne desde artisan

 php artisan make:seeder PoblarAlumnos

Esta clase debe de extender de Seeder

class PoblarUsuariosSeeders extends Seeder {
    //put your code here
     public function run()
    { //Usando el modelo creamos un nuevo registro. Tambien se puede hacer con el método save
       Usuario::create(array(
            'usuario'  => 'manolo',
            'email'     => 'admin@admin.com',
            'password' => Hash::make('manolo') // Hash::make() nos va generar una cadena con nuestra contraseña encriptada
    }
}

Ahora nos queda ejecutarla; Para ello vamos a modificar la clase DataBaseSeeders.php que tenemos en /app/database/seeds. Esta clase se va a encargar de invocar al resto de clases creadas para poblar tablas
Para ello añadimos una linea para que se llame a la clase que previamente hemos creado.

  $this->call('PoblarUsuariosSeeders');

Si tuviéramos varias clases, le pasaríamos al método call un array en lugar de una clase

  $this->call(['PoblarUsuariosSeeders', 'Clase2Seeder,...,'ClaseNSeeder']);

Quedándonos el código de la clase

class DatabaseSeeder extends Seeder {
	/**
	 * Run the database seeds.
	 *
	 * @return void
	 */
	public function run()
	{
                $this->call('PoblarUsuariosSeeders');
	}
}

Generara valores aleatorios

La clase seeder en lugar de generar un valor concreto, podemos hacer que invoque a una clase Factory
En esta clase podremos generar valores aleatorios a partir de la clase Faker que tenemos disponible dentro de la clase Factory. Es ésta una librería disponible para php

https://github.com/fzaninotto/Faker
https://packagist.org/packages/fzaninotto/faker

También va a ser posible invocar un número repetitivo de veces a la ejecución del método de esta clase, por lo que la lectura es que podremos poblar un número de registros que deseemos nuestra tabla.
Pasos a realizar

1.- creamos un factory de nuestra tabla

php artisan make:factory ClienteFactory

Nos habrá creado una clase llamada ClienteFactory
Si creamos una factory con solo el nombre, igualmente nos añadirá el identificador Factory a la clase creada

php artisan make:factory Cliente2

Vemos como nos ha creado dos clases que terminan con el identificador Factory

Archivo:ClienteFactory.png

Ahora implementamos el método definition de la clase creada para que nos devuelva el un array asociativo dando un valor para cada uno de los campos de la tabla.
Para asignar un valor aleaotiro, usamos el objeto faker disponible dentro de la clase ClienteFactory, ya que es un atributo de la propia clase
Podemos usar el helper fake* para obtener valores aleatorios pero coherentes a la hora de poblar nuestra BD para realizar pruebas.

Si quieres establecer un idioma concreto, debes busar la opción 'faker_locale en tu fichero de configuración config/app.php

    public function definition()
    {
        return [
            "nombre"=>fake()->firstName(),
            "apellido"=>fake()->faker->lastName(),
            "direccion"=>fake()->address(),
            "email"=>fake()->email(),
        ];
    }

Ahora lo invocamos en el método run de la clase ClienteSeeder
Observe que a partir del modelo Cliente tenemos disponible su método factory donde invocamos 50 veces al méotodo.
Este método va a invocar a la clase ClienteFactory, de la que en cada invocación va a obtener un registro con valores para cada uno de los campos de la tabla
Cada uno de ellos los creará' o insertará en la tabla correspondiente asigana a este modelo

public function run()
    {
        Cliente::factory()->count(50)->create();
 
        //
    }

Vemos el resultado visualizando con phpmyadmin el contenido de la tabla

Ahora sólo nos queda ejecutar esta acción, esto lo haremos en la línea de comandos de artisan

php artisan db:seed

Esta acción también la podemos hacer al ejecutar la migración

php artisan migrate:fresh --seed

Vamos a probar un componente que nos va a permitir realizar una población masiva de datos

Usuario:ManuelRomero/Laravel/migraciones

Contenido

¡Programa tus programas no tus herramientas!

Bases de datos con Laravel: ejemplo de simplicidad

Migraciones

Crear Migraciones

Modificando la migración

Tipos de datos

La clase Schema (facade)

Poblando una base de datos desde migration

Generara valores aleatorios

Menú de navegación

Herramientas personales

Espacios de nombres

Variantes

Vistas

Acciones

Buscar

Navegación

Herramientas

Imprimir/exportar