Migrazioni e database in Laravel 4 – Guida Laravel 4

Continua la nostra guida dedicata a Laravel 4 in questo articolo dove affrontiamo il tema del database e delle migrazioni, utile strumento introdotto da questo framework.

SOMMARIO GUIDA LARAVEL 4

• Primi passi e installazione di Laravel
•  Introduzione alle routes per gestire il progetto
• Guida all’uso dei Controller 
• Gestire il layout in Laravel 4: Guida al blade template system
• Database e migrazioni in Laravel 4

Laravel 4 permette diversi modi e strategie per accedere al database ed elaborare i dati. I driver per i database supportati di default sono molto vari e comprendono:

• Mysql
• Sql Server
• PostgreSQL
• SqlLITE

Configurare laravel 4 per la connessione al db

La prima cosa da fare per poter usare laravel collegato ad un database è configurare il “puntamento” agendo sul file app/config/database.php

<?php

'connections' => array(

    'sqlite' => array(
        'driver'   => 'sqlite',
        'database' => __DIR__.'/../database/production.sqlite',
        'prefix'   => '',
    ),

    'mysql' => array(
        'driver'    => 'mysql',
        'host'      => 'localhost',
        'database'  => 'database',
        'username'  => 'root',
        'password'  => '',
        'charset'   => 'utf8',
        'collation' => 'utf8_unicode_ci',
        'prefix'    => '',
    ),

    'pgsql' => array(
        'driver'   => 'pgsql',
        'host'     => 'localhost',
        'database' => 'database',
        'username' => 'root',
        'password' => '',
        'charset'  => 'utf8',
        'prefix'   => '',
        'schema'   => 'public',
    ),

    'sqlsrv' => array(
        'driver'   => 'sqlsrv',
        'host'     => 'localhost',
        'database' => 'database',
        'username' => 'root',
        'password' => '',
        'prefix'   => '',
    ),

),

A seconda del driver impostato laravel andrà a recuperare il set di informazioni utili alla connessione al database. Ovviamente dovete impostare il driver a questa riga:

'driver'    => 'mysql',

Gli shortcode da inserire nella riga precedente  per richiamare le varie connessioni differenti sono:

• mysql – MySQL
• sqlite – SQLite
• pgsql – PostgreSQL
• sqlsrv – SQL Server

Ricordatevi di impostare altresì una connessione predefinita:

'default' => 'mysql',

Le migrazioni

Nella creazione di un’applicazione o sito internet, ogni developer ha l’esigenza di effettuare aggiornamenti “mirati” al suo database. Pensiamo ad esempio una task list di questo tipo:

• Creare tabella articoli con 4 campi base
• Aggiungere campo “status” ad articoli
• Rinomina della colonna da “category” a “cat”
• Aggiungere sistema di votazione articolo

Come avrete modo di notare da questo semplice esempio un sito è di fatto “vivo” e ha bisogno di continue manutenzioni, modifiche e aggiustamenti. Laravel4 vi consente di aggiungere in modo sequenziale e controllato le vostre modifiche al database tramite l’uso delle migrazioni. E non solo. Vi permette infatti, qualora qualcosa andasse storto, di effettuare un roll-back per annullare l’effetto della migrazione. Questo può sembrare poco utile ma pensate a un sito medio-grande: ogni modifica può compromettere la stabilità del sistema e ogni amministratore deve agire in modo chirurgico in modo tale da poter ripristinare il sistema in pochi istanti qualora vi siano errori.

Creare ed eseguire una migration

Per agire su laravel aprite la vostra console di sistema (su windows scrivete cmd nella barra di ricerca). Spostatevi nella cartella contenente l’installazione di laravel in questo modo:

cd C:\\xampp\htdocs\tuainstallazionelaravel

Ovviamente il percorso è puramente indicativo, e varia a seconda di dove avete installato il vostro xampp o easyphp o similari.

Una volta dentro la cartella dell’installazione di laravel che volete amministrare create la vostra prima migrazione digitando questo codice:

$ php artisan migrate:make create_articoli

Di fatto questo codice (da digitare nel terminale!) crea un file all’interno della cartella app/database/migrations. Il nome del file è varibiabile ma al suo interno troverete:

<?php

use Illuminate\Database\Migrations\Migration;

class CreateArticoli extends Migration {

    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        //
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        //
    }

}

Come vedete il codice è diviso in due public function up() e down(). Nella sezione UP andremo a mettere cosa deve fare la migrazione, nella parte DOWN andiamo a inserire cosa deve fare laravel qualora facessimo il roll-back. Ecco, nel nostro esempio come agire sul codice:

<?php

/**
 * Run the migrations.
 *
 * @return void
 */
public function up()
{
    Schema::create('articoli', function($table)
    {
        $table->increments('id');
        $table->text('titolo');
        $table->text('descrizione');
        $table->timestamps();
    });
}

La funzione UP di questo esempio crea (create) la tabella articoli nel database con i campi: id(auto-increments), titolo (text), descrizione (text), timestamps() crea automaticamente due campi chiamati “created_at” ed “updated_at” che sono davvero molto utili in fase di gestione.

Andiamo a vedere il codice della function down()

<?php

/**
 * Reverse the migrations.
 *
 * @return void
 */
public function down()
{
    Schema::drop('articoli');
}

Nel nostro esempio la funzione down, per effettuare il rollback, dovrà semplicemente eliminare la tabella appena creata dal database. Pertanto conterrà semplicemente il comando drop(NOMETABELLA).

Una volta che avrete “compilato” i vari metodi up e down siete pronti per effettuare il run della migrazione  e rendere effettive le modifiche al database.Per farlo aprite il terminale precedentemente aperto e digitate:

php artisan migrate

Fatto! avete creato la vostra prima tabella “articoli” all’interno del vostro database!

Utile tips per la creazione di nuove tabelle tramite migrazioni

Se non avete voglia ogni volta di aggiungere la parte di codice up down etc potete digitare da termina il comando:

php artisan migrate:make create_articoli --create --table=articoli

che fornirà un codice di migrazione di questo tipo:

<?php

use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateUsers extends Migration {

    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('articoli', function(Blueprint $table)
        {
            $table->increments('id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('articoli');
    }

}

Come vedete in questo caso laravel4 vi fornisce già l’intelaiatura di base pronta per essere modificata con i vostri campi personalizzati.

Rollback di una migrazione

E se volessimo ritornare indietro? Molto semplice vi basterà usare da terminale il seguente codice:

 php artisan migrate:rollback

Ritornerete automaticamente alla versione del database senza la tabella articoli creata della migrazione.

Schema Builder Column Types: tipi di campi database

Nel precedente capitolo abbiamo specificato termini come increments, text per fornire a laravel informazioni sulla tipologia di campi da creare per il database. Ne esistono ovviamente diversi tipi. ecco una comoda lista dei principali pronta all’uso.

increments

<?php
Schema::create('example', function($table)
{
$table->increments('id');
});

+-------+------------------+-----+----------------+
| Field | Type             | Key | Extra          |
+-------+------------------+-----+----------------+
| id    | int(10) unsigned | PRI | auto_increment |
+-------+------------------+-----+----------------+

bigIncrements

<?php
Schema::create('example', function($table)
{
$table->bigIncrements('id');
});

+-------+---------------------+-----+----------------+
| Field | Type                | Key | Extra          |
+-------+---------------------+-----+----------------+
| id    | bigint(20) unsigned | PRI | auto_increment |
+-------+---------------------+-----+----------------+

string

<?php
Schema::create('example', function($table)
{
$table->string('nickname', 128);
});

+----------+--------------+
| Field    | Type         |
+----------+--------------+
| nickname | varchar(255) |
+----------+--------------+

text

<?php
Schema::create('example', function($table)
{
$table->text('body');
});
+-------+------+
| Field | Type |
+-------+------+
| body  | text |
+-------+------+

integer

<?php
Schema::create('example', function($table)
{
    $table->integer('esempio');
});
+-----------+---------+
| Field     | Type    |
+-----------+---------+
| shoe_size | int(11) |
+-----------+---------+

date

<?php
Schema::create('example', function($table)
{
$table->date('when');
});
+-------+------+
| Field | Type |
+-------+------+
| when  | date |
+-------+------+

dateTime

<?php
Schema::create('example', function($table)
{
$table->dateTime('when');
});
+-------+----------+
| Field | Type     |
+-------+----------+
| when  | datetime |
+-------+----------+

time

<?php
Schema::create('example', function($table)
{
$table->time('when');
});
+-------+------+
| Field | Type |
+-------+------+
| when  | time |
+-------+------+

timestamp

<?php
Schema::create('example', function($table)
{
$table->timestamp('when');
});
+-------+-----------+---------------------+
| Field | Type      | Default             |
+-------+-----------+---------------------+
| when  | timestamp | 0000-00-00 00:00:00 |
+-------+-----------+---------------------+

Modifica di una tabella tramite migrations

Nell’esempio di apertura abbiamo usato le migrazioni per creare una tabella. Se volessimo modificarne una esistente? Da terminale create intanto il file di migrazione in questo modo:

$ php artisan migrate:make add_status_to_articoli

Cercate di dare un nome “utile” alla migrazione in modo da capire da subito la modifica che avete effettuato. Nel caso d’esempio aggiungiamo un campo “status” all’interno della tabella appena creata articoli. Una volta fatto vi apparirà un file come da manuale all’interno di app/database/migrations.

<?php

use Illuminate\Database\Migrations\Migration;

class AddTitleToUsers extends Migration {

    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('articoli', function($table)
        {
            $table->string('status');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('articoli', function($table)
        {
            $table->dropColumn('status');
        });
    }

}

Il procedimento è simile al precedente, come noterete però non uso più la formula Schema::create ma Schema::table. La logica di up() e down() è rimasta tuttavia invariata.

UP()-> aggiungo campo status (string)

DOWN() -> in caso di rollback elimina la colonna status (dropColumn)

Per eseguire la modifica che avete creato vi basterà eseguire da terminale il comando:

php artisan migrate

Link Approfondimento

Sezione presente solo nel PDF scaricabile.

Conclusioni

Nel prossimo articolo dedicato a Laravel4 tratteremo il vero “cuore” pulsante di Laravel ovvero Eloquent.

Se la guida ti è stata utile condividila sui tuoi social network preferiti. Se invece mi vuoi offrire una pizza effettua una donazione via paypal (trovi il form poco sopra), per ringraziarti potrai scaricare la guida in formato PDF per poterla leggere ovunque vuoi. Man mano che usciranno le lezioni la guida PDF ottenuta tramite la donazione conterrà tutte le lezioni precedenti con qualche interessante aggiunta.

Hai domande o consigli? Commenta questo articolo!