El concepto CRUD está estrechamente vinculado a la gestión de datos digitales.

CRUD
hace referencia a un acrónimo en el que se reúnen las primeras letras de las cuatro
operaciones fundamentales de aplicaciones persistentes en sistemas de bases de datos:

• Create (Crear registros)

• Read bzw. Retrieve (Leer registros)

• Update (Actualizar registros)

• Delete bzw. Destroy (Borrar registros)

En pocas palabras, CRUD resume las funciones requeridas por un usuario para crear y
gestionar datos. Varios procesos de gestión de datos están basados en CRUD, en los
que dichas operaciones están específicamente adaptadas a los requisitos del sistema
y de usuario, ya sea para la gestión de bases de datos o para el uso de aplicaciones.
Para los expertos, las operaciones son las herramientas de acceso típicas e
indispensables para comprobar, por ejemplo, los problemas de la base de datos,
mientras que para los usuarios, CRUD significa crear una cuenta (créate) y utilizarla
(read), actualizarla (update) o borrarla (delete) en cualquier momento. Dependiendo de
la configuración regional, las operaciones CRUD pueden implementarse de diferentes
maneras, como lo muestra la siguiente tabla:

CRUD-Operation 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
Dominios web
Compra y registra tu dominio ideal

• Domina el mercado con nuestra oferta 3x1 en dominios

• Tu dominio protegido con SSL Wildcard gratis
• 1 cuenta de correo electrónico por contrato
Comprobar
Frameworks CRUD: capa de acceso a las bases de
datos
Si los objetos individuales son visualizados por medio de una interfaz gráfica y
modificados con las llamadas operaciones CRUD, entonces se habla de un framework
CRUD o de un CRUD grid. Por lo general, se trata de interfaces HTML. Un
framework CRUD demanda varios pasos de transacción, de forma que los datos no se
recogen una vez se han introducido, sino que es necesario pulsar la opción “Guardar” o
“Continuar”. Las operaciones de un framework CRUD pueden aplazarse para ser
ejecutadas en diferentes plazos, sin que los datos de dichos periodos de tiempo se
bloqueen para otros usuarios. Este hecho resulta de gran importancia para sistemas
multiusuario, pues permite que varias personas lean los mismos datos al mismo
tiempo.

Para llevar a cabo las operaciones se utilizan las denominadas capas de persistencia,
que, por lo general, pueden ser implementadas o están contenidas en forma de
extensiones (módulos) en el framework. Estas rompen con la representación relacional y
tabular de la totalidad de los datos para, en su lugar, presentarlos en un nivel
orientado a objetos. Los frameworks CRUD facilitan el acceso al sistema de bases de
datos y son utilizados tanto en el desarrollo como en el uso de aplicaciones. Existen
numerosos frameworks con un concepto CRUD basados en diferentes lenguajes y
plataformas. A continuación, presentamos algunos ejemplos:

Lenguaje o
Framework
plataforma
JDBC (The Java Database Connectivity), Hibernate, JBoss
Java
Seam, Isis
PHP Yii, CakePHP, Zikula, Symfony, TYPO3 Flow
Perl Catalyst, Gantry
Python Django, SQLAlchemy, web2py
Groovy Grails
.NET NHibernate, ADO.NET/Entity Framework
Ruby Ruby on Rails
JavaScript Backbone.js, AngularJS
Cómo desarrollar un CRUD PHP grid para tu base
de datos
En la siguiente parte de este artículo te mostraremos cómo crear una interfaz de
arranque para MySQL, el sistema de base de datos más utilizado, que permita el
acceso a través operaciones CRUD. Adicionalmente podrás crear la operación
“create”. Para manipular la base de datos se utiliza, en este caso, el lenguaje de script
del lado del servidor PHP y la extensión PHP Data Objects (PDO).

1. El primer paso consiste en crear una tabla de base de datos simple que pueda ser
manipulada con operaciones CRUD a lo largo de este tutorial. Para ello, importa la
siguiente tabla de ejemplo en tu base de datos 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;
Copy
La tabla se utiliza para recopilar información del usuario como nombre, correo
electrónico y número de teléfono. A cada entrada se le asigna automáticamente
una clave principal (AUTO_INCREMENT PRIMARY KEY), es decir un identificador
único.

2. A continuación, es necesario regular las conexiones de apertura y de cierre de la base

de datos. Crea un archivo PHP con el nombre database.php y añade la siguiente
secuencia de comandos con la clase “Database” para gestionar las conexiones de la base
de datos.

<?php
class Database
{
private static $dbName = 'nombre_de_la_basededatos';
private static $dbHost = 'localhost';
private static $dbUsername = 'nombre_de_usuario';
private static $dbUserPassword = 'contraseña';
private static $cont = null;
public function __construct() {
die('Init-Función no permitida');
}
public static function connect() {
// Permitir solo una conexión para la totalidad del acceso
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;
}
}
Copy
Para que puedas utilizar la clase definida en el documento y lograr el acceso a la base de
datos con PDO, necesitas los valores exactos de los elementos $dbName (nombre de la
base de datos utilizada), $dbHost (nombre del host donde se ejecutará la base de datos,
por lo general localhost como en el ejemplo), $dbUsername (nombre del usuario que
accede) y $dbUserPassword (contraseña del usuario que accede).

En esta secuencia de comandos se le asignan tres funciones a la clase “base de

datos”: __construct(), el constructor de la clase que le recuerda a los usuarios que la
inicialización (es decir, la asignación del valor inicial o de inicio) no está
permitida. connect() hace referencia a la función principal de la clase que controla el
establecimiento de la conexión y, por último, disconnect() que se encarga de finalizar la
conexión.

3. Debido a que las operaciones CRUD solo pueden utilizarse con la correspondiente
superficie de contacto, es necesario crear el grid base utilizando Twitter Bootstrap. La
versión actual de este framework puede descargarse en su página web oficial.
Descomprime Bootstrap en el mismo directorio donde se encuentra database.php y crea
un nuevo archivo con el nombre index.php. Ahora puedes crear la interfaz:

<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="utf-8">
<link href="css/bootstrap.min.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="row">
<h3>My CRUD PHP grid</h3>
</div>
<div class="row">
<table class="table table-striped table-bordered">
<thead>
<tr>
<th>Nombre</th>
<th>Correo electrónico </th>
<th>Móvil</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>
Copy
En la sección <head>, se encuentran los archivos CSS y JavaScript de Bootstrap; en la
sección <body> se encuentra el anteriormente creado database.php, incluyendo los
intentos para establecer una conexión POD (Database::connect()) y sus datos
relacionados (SELECT). Adicionalmente, el archivo contiene la tabla HTML <table>
con las opciones nombre, correo electrónico y móvil (que también son almacenados en
la base de datos).

4. Ahora, para formar la estructura esencial, es necesario concentrarse en la

realización de las diferentes operaciones CRUD. Por ejemplo, para poner en marcha la
operación create se necesita otra página HTML con campos de formulario para
introducir los datos de usuario vinculados en index.php y a los que se puede acceder a
través de un botón en la interfaz Bootstrap. Para mayor comodidad se recomienda
comenzar con la creación de este botón, abriendo index.php y añadiendo el siguiente
fragmento de código al elemento <div class="row"> de la tabla:

<p>
<a href="create.php" class="btn btn-success">Create</a>
</p>
Copy
En el fragmento de código puedes ver que los datos se están vinculando al
archivo create.php aunque este todavía no exista. Al realizar una prueba del grid de
Bootstrap, esta muestra que hay un botón pero, al hacer clic sobre él, este dirige a una
página de error. Para finalizar y hacer válida la operación create debes crear el
archivo create.php y añadir el siguiente código:

<!DOCTYPE html>
<html lang="de">
<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">Name</label>
<div class="controls">
<input name="name" type="text" placeholder="Nombre" 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">E-Mail-Adresse</label>
<div class="controls">
<input name="email" type="text" placeholder="Correo Electrónico"
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">Móvil</label>
<div class="controls">
<input name="mobile" type="text" placeholder="Mobilnummer" 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>
Copy
El código genera el formulario HTML que permite personalizar la información en los
campos nombre, correo electrónico y móvil. Para cada casilla se crea una variable PHP
que, en combinación con el fragmento de código que presentamos a continuación (se
debe añadir antes del código HTML en el archivo create.php), genera mensajes de error
cuando no se realiza ninguna entrada en el campo correspondiente:

<?php
require 'database.php';
if ( !empty($_POST)) {
// Detectar errores de validación
$nameError = null;
$emailError = null;
$mobileError = null;
// Capturar valores de entrada
$name = $_POST['name'];
$email = $_POST['email'];
$mobile = $_POST['mobile'];
// Validar entrada
$valid = true;
if (empty($name)) {
$nameError = Por favor, introduce tu nombre';
$valid = false;
}
if (empty($email)) {
$emailError = 'Por favor, introduce una dirección de correo electrónico';
$valid = false;
} else if ( !filter_var($email,FILTER_VALIDATE_EMAIL) ) {
$emailError = 'Por favor, introduce una dirección de correo electrónico';
$valid = false;
}
if (empty($mobile)) {
$mobileError = 'Por favor, introduce tu número de móvil';
$valid = false;
}
// Daten eingeben
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");
}
}
?>
Copy
De esta forma habrás creado una página create.php a la que se accede haciendo clic en
el botón crear y que permite al usuario introducir su información. El script se asegura de
comprobar que se hayan introducido todos los datos y, en caso contrario, de mostrar
los respectivos errores de validación; así, no solo se mostrarán mensajes para avisar
al usuario de que los datos serán enviados a la base de datos, sino también mensajes
de error cuando la entrada sea incorrecta. Si quieres conocer cómo crear y usar las
demás operaciones CRUD read, update y delete, puedes visitar este tutorial, donde
también encontrarás información para crear el grid de Bootstrap y la operación create.