Il termine CRUD è stret­ta­men­te collegato alla gestione dei dati digitali. Detto più pre­ci­sa­men­te, CRUD è un acronimo, che deriva dalle iniziali dalle quattro ope­ra­zio­ni fon­da­men­ta­li compiute nei database:

  • Create (creare i dati)
  • Read o Retrieve (leggere i dati)
  • Update (ag­gior­na­re i dati)
  • Delete o Destroy (eliminare i dati)

Più sem­pli­ce­men­te la tavola CRUD riassume le funzioni di cui un utente ha bisogno per creare e gestire i dati. I diversi processi per la gestione dei dati si basano sul CRUD, dove le ope­ra­zio­ni sono adattate spe­ci­fi­ca­men­te alle richieste del sistema e dell’utente, a pre­scin­de­re dal fatto che si ge­sti­sca­no dei database o si usino delle ap­pli­ca­zio­ni. Così le ope­ra­zio­ni sono gli strumenti di accesso tipici e ir­ri­nun­cia­bi­li con cui gli esperti possono ad esempio ve­ri­fi­ca­re dei problemi del database, mentre con una tavola CRUD un utente può creare (create) un account e uti­liz­zar­lo (read) quando vuole, ag­gior­nar­lo (update) o eli­mi­nar­lo (delete). Le ope­ra­zio­ni CRUD vengono eseguite in maniera diversa a seconda dell’ambiente di pro­gram­ma­zio­ne in cui si trovano, come mostra la tabella seguente:

Ope­ra­zio­ne CRUD SQL RESTful HTTP XQuery
Create INSERT POST, PUT insert
Read SELECT GET, HEAD copy/modify/return
Update UPDATE PUT, PATCH replace, rename
Delete DELETE DELETE delete
Registra il tuo dominio
  • Domain Connect gratuito per una con­fi­gu­ra­zio­ne facile del DNS
  • Cer­ti­fi­ca­to SSL Wildcard gratuito
  • Pro­te­zio­ne privacy inclusa

Framework CRUD: livello di accesso per i database

Se i singoli oggetti si vi­sua­liz­za­no grazie ad un’in­ter­fac­cia grafica e si mo­di­fi­ca­no tramite le citate ope­ra­zio­ni CRUD, si parla di un framework CRUD o anche di una griglia CRUD. So­li­ta­men­te si tratta di in­ter­fac­ce HTML. Un framework CRUD prevede diversi passaggi, così che i dati non vengano mo­di­fi­ca­ti dopo la loro im­mis­sio­ne, ma solo dopo aver cliccato su “Salva” o “Avanti”. Le ope­ra­zio­ni di un framework CRUD si possono eseguire anche in diversi momenti, senza che per questo lasso di tempo i dati vengano bloccati per altri utenti.  Questa proprietà è molto im­por­tan­te, spe­cial­men­te per i sistemi con più utenti, perché in questo modo più persone possono avere accesso agli stessi dati in un database con­tem­po­ra­nea­men­te.

Per rea­liz­za­re le ope­ra­zio­ni vengono uti­liz­za­ti i livelli di per­si­sten­za, che so­li­ta­men­te sono compresi nel framework sotto forma di esten­sio­ni (moduli) o possono essere im­ple­men­ta­ti suc­ces­si­va­men­te. Queste esten­sio­ni sud­di­vi­do­no i database nelle forme re­la­zio­na­li, tabellari e li pre­sen­ta­no su un livello orientato agli oggetti. I framework CRUD fa­ci­li­ta­no lo sviluppo e l’utilizzo delle ap­pli­ca­zio­ni tramite un accesso ot­ti­miz­za­to al sistema di database in uso. Esistono in­nu­me­re­vo­li framework CRUD, che si basano sulle diverse lingue e piat­ta­for­me. Trovate alcuni esempi nella seguente tabella:

Lin­guag­gio die pro­gram­ma­zio­ne o piat­ta­for­ma
 Framework
Java JDBC (The Java Database Con­nec­ti­vi­ty), Hibernate, JBoss Seam, Isis
PHP Yii, CakePHP, Zikula, Symfony, TYPO3 Flow
Perl Catalyst, Gantry
Python Django, SQ­LAl­che­my, web2py
Groovy Grails
.NET NHi­ber­na­te, ADO.NET/Entity Framework
Ruby Ruby on Rails
Ja­va­Script Backbone.js, AngularJS

Come svi­lup­pa­re una griglia CRUD in PHP per il proprio database

Nei paragrafi suc­ces­si­vi vi mostriamo come creare un’in­ter­fac­cia di Bootstrap, a cui si accede tramite ope­ra­zio­ni CRUD, per il più co­no­sciu­to sistema di database, MySQL. Inoltre verrà anche con­fi­gu­ra­ta l’ope­ra­zio­ne create. Per ma­ni­po­la­re op­por­tu­na­men­te le tabelle del database, viene uti­liz­za­to il lin­guag­gio di scripting lato server PHP tramite l’esten­sio­ne PHP Data Objects (PDO).

1. Nel primo passaggio si crea una tabella semplice del database, che suc­ces­si­va­men­te verrà ma­ni­po­la­ta in questo tutorial tramite accesso CRUD. Importate quindi la seguente tabella di esempio nel vostro database MySQL:

CREATE TABLE `customers` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`name` VARCHAR( 100 ) NOT NULL ,
`email` VARCHAR( 100 ) NOT NULL ,
`mobile` VARCHAR( 100 ) NOT NULL
) ENGINE = INNODB;

La tabella serve per rac­co­glie­re in­for­ma­zio­ni sull’utente, come nome, indirizzo e-mail e numero di cellulare. Ogni voce riceve au­to­ma­ti­ca­men­te una “primary key” (AUTO_INCREMENT PRIMARY KEY), cioè un ID univoco.

2. Dopo bisogna stabilire come avviene la con­nes­sio­ne e la di­scon­nes­sio­ne al database. Create un file PHP con il nome database.php e ag­giun­ge­te il seguente script con la classe “Database” per gestire le con­nes­sio­ni al database:

<?php
class Database 
{
private static $dbName = 'nome_del_database'; 
private static $dbHost = 'localhost';
private static $dbUsername = 'nome_utente';
private static $dbUserPassword = 'password';
private static $cont = null;
public function __construct() {
die('funzione Init non consentita');
}
public static function connect() {
//Consentire solo una connessione durante il tempo totale di accesso
if ( null == self::$cont )
{
    try
    {
        self::$cont = new PDO( "mysql:host=".self::$dbHost.";"."dbname=".self::$dbName, self::$dbUsername, self::$dbUserPassword);
    }
    catch(PDOException $e)
    {
        die($e->getMessage());
    }
} 
return self::$cont;
}
public static function disconnect()
{
self::$cont = null;
}
}

Per poter uti­liz­za­re anche qui la classe definita per l’accesso al database con PDO, dovete inserire i valori esatti per le quattro voci $dbName (nome del database in uso), $dbHost (nome dell’host sul quale viene eseguito il database, so­li­ta­men­te localhost, come indicato nell’esempio), $dbU­ser­na­me (nome dell’utente che accede al database) e $dbU­ser­Pas­sword (password dell’utente che accede al database).

In questo script sono assegnate tre funzioni alla classe “database”: __construct(), il co­strut­to­re della classe, che ricorda agli utenti che l’ini­zia­liz­za­zio­ne (quindi l’as­se­gna­zio­ne di un valore iniziale) non è con­sen­ti­ta. Con connect() si indica la funzione prin­ci­pa­le della classe, che regola la con­nes­sio­ne, mentre di­scon­nect() serve per ter­mi­nar­la.

3. Le ope­ra­zio­ni CRUD si possono eseguire solo ri­cor­ren­do alla giusta in­ter­fac­cia e per questo deve essere creata la griglia di base con Bootstrap. La versione attuale del framework è di­spo­ni­bi­le sul sito ufficiale. De­com­pri­me­te il programma nella stessa cartella in cui si trova anche il file database.php e create anche un altro file con il nome index.php, dove rea­liz­za­re la vostra in­ter­fac­cia:

<!DOCTYPE html>
<html lang="it">
<head>
<meta charset="utf-8">
<link href="css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="row">
<h3>La mia griglia CRUD in PHP</h3>
</div>
<div class="row">
<table class="table table-striped table-bordered">
<thead>
    <tr>
        <th>Nome</th>
        <th>Indirizzo e-mail</th>
        <th>Numero di cellulare</th>
    </tr>
</thead>
<tbody>
<?php 
include 'database.php';
$pdo = Database::connect();
$sql = 'SELECT * FROM customers ORDER BY id DESC';
foreach ($pdo->query($sql) as $row) {
echo '<tr>';
echo '<td>' . $row['name'] . '</td>';
echo '<td>' . $row['email'] . '</td>';
echo '<td>' . $row['mobile'] . '</td>';
echo '</tr>';
}
Database::disconnect();
?>
</tbody>
</table>
</div>
</div> <!-- /container -->
</body>
</html>

Nell’<head> del documento sono stati inseriti i file CSS e Ja­va­Script di Bootstrap, mentre nel <body> si ritrova il file database.php, pre­ce­den­te­men­te creato, com­pren­si­vo dei comandi per stabilire una con­nes­sio­ne con PDO, (Database::connect()), e il ri­fe­ri­men­to ai dati cor­ri­spon­den­ti (SELECT). Inoltre nel file è presente una tabella HTML <table> con tre colonne (nome, indirizzo e-mail e numero di cellulare), che sono anche salvate nel database.

4. Per poter mantenere la struttura di base, bisogna rea­liz­za­re le diverse ope­ra­zio­ni CRUD. Per im­ple­men­ta­re ad esempio l’ope­ra­zio­ne create, vi serve un’altra pagina HTML con moduli per l’in­se­ri­men­to dei dati utente, che vengono collegati nel file index.php e che si possono rag­giun­ge­re tramite un pulsante aggiunto nell’in­ter­fac­cia di Bootstrap. Per questioni di sem­pli­ci­tà potete co­min­cia­re con la creazione di questo pulsante, aprendo nuo­va­men­te il file index.php e ag­giun­gen­do il seguente codice nel secondo elemento <div class="row">, contenuto nella tabella:

<p>
    <a href="create.php" class="btn btn-success">Create</a>
</p>

Già in questa parte di codice potete notare che ci si è collegati al file create.php, che prima non esisteva affatto. Un test sulla griglia Bootstrap allo stato attuale mostra quindi il pulsante, ma un click sullo stesso porta solo ad una pagina di errore. Per rendere l’ope­ra­zio­ne create de­fi­ni­ti­va­men­te di­spo­ni­bi­le, create il file create.php già nominato e ag­giun­ge­te la prima parte del codice seguente:

<!DOCTYPE html>
<html lang="it">
<head>
<meta charset="utf-8">
<link href="css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="span10 offset1">
<div class="row">
<h3>Create a Customer</h3>
</div>
<form class="form-horizontal" action="create.php" method="post">
<div class="form-group <?php echo !empty($nameError)?'has-error':'';?>">
<label class="control-label">Nome</label>
<div class="controls">
<input name="name" type="text" placeholder="Nome" value="<?php echo !empty($name)?$name:'';?>">
<?php if (!empty($nameError)): ?>
<span class="help-inline"><?php echo   $nameError;?></span>
<?php endif; ?>
</div>
</div>
<div class="form-group <?php echo !empty($emailError)?'has-error':'';?>">
<label class="control-label">Indirizzo e-mail</label>
<div class="controls">
<input name="email" type="text" placeholder="Indirizzo e-mail" value="<?php echo !empty($email)?$email:'';?>">
<?php if (!empty($emailError)): ?>
<span class="help-inline"><?php echo   $emailError;?></span>
<?php endif;?>
</div>
</div>
<div class="form-group <?php echo !empty($mobileError)?'has-error':'';?>">
<label class="control-label">Numero di cellulare</label>
<div class="controls">
<input name="mobile" type="text" placeholder="Numero di cellulare" value="<?php echo !empty($mobile)?$mobile:'';?>">
<?php if (!empty($mobileError)): ?>
<span class="help-inline"><?php echo $mobileError;?></span>
<?php endif;?>
</div>
</div>
<div class="form-actions">
<button type="submit" class="btn btn-success">Create</button>
<a class="btn" href="index.php">Back</a>
</div>
</form>
</div>
</div> <!-- /container -->
</body>
</html>

Il codice genera il modulo HTML, dove inserire le singole in­for­ma­zio­ni sul nome, il numero di cellulare e l’indirizzo e-mail. In aggiunta è stata creata una variabile PHP per ogni campo, che genera un messaggio di errore se combinata con la seguente esten­sio­ne del codice (da inserire prima del codice HTML nel file create.php), qualora il campo preso in con­si­de­ra­zio­ne rimanga vuoto terminata la com­pi­la­zio­ne:

<?php 
require 'database.php';
if ( !empty($_POST)) {
// Rilevare un errore alla conferma
$nameError = null;
$emailError = null;
$mobileError = null;
// Rilevare i valori inseriti 
$name = $_POST['name'];
$email = $_POST['email'];
$mobile = $_POST['mobile'];
// Confermare l’inserimento 
$valid = true;
if (empty($name)) {
$nameError = 'Inserire un nome';
$valid = false;
}
if (empty($email)) {
$emailError = 'Inserire un indirizzo e-mail';
$valid = false;
} else if ( !filter_var($email,FILTER_VALIDATE_EMAIL) ) {
$emailError = 'Inserire un indirizzo e-mail valido';
$valid = false;
}
if (empty($mobile)) {
$mobileError = 'Inserire un numero di cellulare';
$valid = false;
}
// Inserire i dati
if ($valid) {
    $pdo = Database::connect();
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    $sql = "INSERT INTO customers (name,email,mobile) values(?, ?, ?)";
    $q = $pdo->prepare($sql);
    $q->execute(array($name,$email,$mobile));
    Database::disconnect();
    header("Location: index.php");
}
     }
?>

Così avete creato una pagina create.php, che può essere aperta con un click sul pulsante create e che consente l’in­se­ri­men­to delle in­for­ma­zio­ni utente. Lo script assicura che vengano rilevati tutti i dati inseriti e gli errori di conferma, che compaiano i messaggi di errore nel caso di in­se­ri­men­to errato e che i dati vengano inoltrati al database indicato. Scoprite come poter uti­liz­za­re le altre ope­ra­zio­ni CRUD, quali read, update e delete, in questo tutorial, che spiega nuo­va­men­te come si crea una griglia con Bootstrap e l’ope­ra­zio­ne create.

Vai al menu prin­ci­pa­le