El diario de Pepe Molina (Caricatos)

Sencilla gestión de una base de datos: estructuras

Publicado el día 26 de enero de 2012

MySQL es el sistema de gestión de bases de datos más popular de Internet, y en este apunte trataremos su gestión desde páginas web. Para nuestra gestión plantearemos como navegar y modificar algunos datos con muy pocas líneas de código.

Siempre será necesario datos básicos para realizar la conexión y el acceso, cosa en la que no nos detendremos considerando que se dispone de esos datos. Para empezar solo necesitaremos de nuestro lenguaje del servidor (PHP) y usar la instrucción "mysql_connect()" con nuestros datos "privados" de conexión.

Empezaremos con un pequeño listado que nos permitirá ver los nombres de cada base de datos de nuestro sistema, de forma que podamos enlazar a un listado de sus tablas. Supondremos que el fichero será "ver_bases_de_datos.php"; luego los enlaces serán del tipo "ver_tablas?bd=[aquí el nombre de la base de datos].

$sql = "show databases";
$res = mysql_query($sql);
if ($res)	{
	if (mysql_num_rows($res) > 0)    {
		$datos = array();
		while	($dato = mysql_fetch_array($res))
			array_push($datos, "<li><a href='ver_tablas.php?bd=".$dato[0]."' >".$dato[0]."</a></li>");
		$body = "<ul>\n".implode("\n", $datos)."\n</ul>";
	}
	else
		$body = "No se encontraron bases de datos.";
}
else
	$body = "Se ha producido el error ".mysql_errno($res)." [".mysql_error($res)."].";

Como puede notarse tan solo estamos definiendo el cuerpo de la página web, que supuestamente tendrá otros elementos como títulos, comentarios, estilos, etc.

A continuación añadiremos un botón que nos permita crear una nueva base de datos:

ob_start();
echo <<< nueva
<form action="crear_bd.php" method="get">
<label for="bd" >Base de datos: </label>
<input id="bd" type="text" name="bd" />
<button type="submit"> Crear </button>
</form>

nueva;
$body .= ob_get_clean();

Ahora ponemos el código necesario para crear esa nueva base de datos en nuestro sistema, que como se puede ver se trata de el fichero "crear_bd.php":

$bd = $_GET["bd"];
if ($bd != "") {
	$sql = "create database $bd";
	$res = @mysql_query($sql);
}
header("Location: ver_bases_de_datos.php");

Propondremos también un fichero que borre las bases de datos del sistema, pero debe usarse con Mucha Precaución.

Junto al enlace que nos mostrará las distintas tablas pondremos otro que enlace al fichero borrar_bd.php, que recibirá en el parámetro "bd" el nombre de esa base de datos, y al igual que en la creación vuelva al listado de bases de datos de nuestro sistema. Tan solo se debe cambiar en el listado anterior la palabra "create" por "drop".

Gestión de las tablas

El listado de las tablas es tan sencillo como el de las bases de datos, pero hay que indicar el nombre de la misma con la cláusula from: "show tables from base_de_datos".

$from = (isset($_GET["bd"])) ? " from ".$_GET["bd"]:"";
$bd = $_GET["bd";
$sql = "show tables$from";
$res = mysql_query($sql);
if ($res)	{
	if (mysql_num_rows($res) > 0)    {
		$datos = array();
		while	($dato = mysql_fetch_array($res))	{
			array_push($datos, "<li><a href='ver_columnas.php?bd=$bd&tabla=".$dato[0]."'>".$dato[0]."</a> <a href='borrar_tabla?bd=$bd&tabla=".$dato[0]."'>borrar</a></li>");
		}
		$body = "<ul>\n".implode("\n", $datos)."\n</ul>";
	}
	else $body = "No existe tablas en la base de datos {$_GET[bd]}...";
}
else $body = "ha ocurrido un error nº ".mysql_errno($res)." en la consulta $sql ".mysql_error($res);

ob_start();
echo <<< nueva
<form action="crear_tabla.php" method="get">
	<input type="hidden" name="bd" value="$bd" />
	<label for="tabla" >Tabla: </label>
	<input id="tabla" type="text" name="tabla" />
	<button type="submit"> Crear </button>
</form>

nueva;
$body .= ob_get_clean();

Hemos añadido un botón para crear una nueva tabla al igual que habíamos hecho con las bases de datos, pero en su implementación hay una pequeña diferencia, ya que al crear una tabla al menos hay que crear un campo sin importar el nombre, tipo u otras características.

Como más adelante propondremos añadir y borrar campos en las tablas, nuestro código añadirá un campo que denominaremos id (identificador): entero que será clave primaria.

$bd = $_GET["bd"];
$tabla = $_GET["tabla"];
if ($tabla != "") {
	$t = (isset($bd)) ? "$bd.$tabla": $tabla;
	$sql = "create table if not exists $t (id int(11) key auto_increment)";
	$res = @mysql_query($sql);
}
header("Location: ver_tablas.php?bd=$bd");

Vemos que después de insertar la nueva tabla, vuelve a redireccionarse a la página que muestra las tablas de la base de datos que estamos tratando. Volviendo al listado, evidentemente también podríamos borrar tablas, exactamente igual que lo hemos hecho con las bases de datos, con la misma instrucción drop.

Nos toca conocer la estructura de la tabla y para ello disponemos de un par de sentencias sql que hacen lo mismo (se podría decir que son alias); se trata de "show columns" y "describe". A continuación, nuestro código:

$bd = $_GET["bd"];
$tabla = $_GET["tabla"];
$describe = (isset($_GET["bd"])) ? "$_GET[bd].$_GET[tabla]":$_GET["tabla"];
$sql = "describe $describe";
$res = mysql_query($sql);
if ($res)	{
	if (mysql_num_rows($res) > 0)    {
		$c = mysql_num_fields($res);
		$titulos = array();
		$ths = array();
		for ($i = 0; $i < $c; $i++)	{
			$titu = mysql_field_name($res, $i);
			array_push($titulos, $titu);
			array_push($ths, "<th>$titu</th>");
		}
		array_push($ths, "<th>opciones</th>");
		$datos = array();
		while	($dato = mysql_fetch_array($res))	{
			$datito = array();
			for ($i = 0, $total = count($titulos); $i < $total; $i++)
				array_push($datito, "<td>".$dato[$titulos[$i]]."</td>");
			array_push($datito,
				"<td><a href='borrar_columna.php?bd=$_GET[bd]&tabla=$_GET[tabla]&columna=$dato[Field]' >borrar</a>
				| <a href='editar_columna.php?bd=$_GET[bd]&tabla=$_GET[tabla]&columna=$dato[Field]' >editar</a></td>");
			array_push($datos, "<tr>".implode("\n", $datito)."</tr>\n");
		}
		$body = "<table border='1'>\n<caption>Base de datos: $_GET[bd]; Tabla: $_GET[tabla]</caption>\n<tbody>\n<tr>".implode("\n", $ths)."</tr>\n".implode("\n", $datos)."\n</tbody>\n</table>\n";

En el mismo listado hemos añadido una columna "opciones" en la cabecera del listado, y en cada campo un par de enlaces:

borrar => "borrar_columna.php?bd=$bd&tabla=$tabla&columna=$columna

Con una simple instrucción "alter table $bd.$tabla drop column $columna"

editar => "editar_columna.php?bd=$bd&tabla=$tabla&columna=$columna

Con un código más complejo que veremos más adelante.

En la misma página añadiremos un formulario para insertar nuevos campos en la tabla. El código será sensiblemente más extenso debido a la gran cantidad de opciones posibles como tipo de campo:

ob_start();
echo <<< form
<form action="sumar_columna.php" style="margin: auto; width: 60%;">
<label>Base de datos: <input type="text" name="bd" value="$bd" /></label><br/>
<label>Tabla: <input type="text" name="tabla" value="$tabla" /></label><br/>
<label>Campo (Field): <input type="text" name="campo" value="" /></label><br/>
<label>Tipo: <select name="tipo">
	<option value="INT">INT</option>
	<option value="VARCHAR">VARCHAR</option>
	<option value="TEXT">TEXT</option>
	<option value="DATE">DATE</option>
	<option value="TINYINT">TINYINT</option>
	<option value="SMALLINT">SMALLINT</option>
	<option value="MEDIUMINT">MEDIUMINT</option>
	<option value="BIGINT">BIGINT</option>
	<option value="DECIMAL">DECIMAL</option>
	<option value="FLOAT">FLOAT</option>
	<option value="DOUBLE">DOUBLE</option>
	<option value="REAL">REAL</option>
	<option value="BIT">BIT</option>
	<option value="BOOLEAN">BOOLEAN</option>
	<option value="SERIAL">SERIAL</option>
	<option value="DATETIME">DATETIME</option>
	<option value="TIMESTAMP">TIMESTAMP</option>
	<option value="TIME">TIME</option>
	<option value="YEAR">YEAR</option>
	<option value="CHAR">CHAR</option>
	<option value="TINYTEXT">TINYTEXT</option>
	<option value="MEDIUMTEXT">MEDIUMTEXT</option>
	<option value="LONGTEXT">LONGTEXT</option>
	<option value="BINARY">BINARY</option>
	<option value="VARBINARY">VARBINARY</option>
	<option value="TINYBLOB">TINYBLOB</option>
	<option value="MEDIUMBLOB">MEDIUMBLOB</option>
	<option value="BLOB">BLOB</option>
	<option value="LONGBLOB">LONGBLOB</option>
</select>
</label><br/>
<label>Longitud/Valores: <input type="text" name="long" value="" /></label><br/>
<label>Predeterminado: <input type="text" name="pred" value="" /></label><br/>
<label>Nulo: <input type="checkbox" name="null" /></label><br/>
Clave:
	<label>(no <input type="radio" name="key" value="no" checked="checked" />)</label>
	<label>(si <input type="radio" name="key" value="si" />)</label>
	<label>(auto_increment <input type="radio" name="key" value="auto_increment" />)</label>
<br/>
<button type="submit" > Añadir campo </button>
</form>

form;
$body .= ob_get_clean();

	}
	else $body = "No existe '$describe'";
}
else $body = "No existe '$describe'";
ob_start();
echo <<< estilos
table {
margin: auto;
}
th {
padding: 0 2em;
}
estilos;
$css .= ob_get_clean();

Insertar nuevos campos evidentemente implica mayor complejidad en el código ya que hay muchas posibilidades, pero no es nuestra intención realizar códigos complejos sino simples, así que lo limitaremos considerablemente:

$bd = $_GET["bd"];
$tabla = $_GET["tabla"];
$campo = $_GET["campo"];
$long = ($_GET["long"] == "") ? "":"($_GET[long])";
$tipo = $_GET["tipo"].$l;
$nulo = (isset($_GET["null"])) ? " NULL":" NOT NULL";
$pred = ($_GET["pred"] == "") ? "":" default '$_GET[pred]'";

if ($_GET["key"] == "auto_increment") $clave = " auto_increment, add primary key ($campo)";
elseif ($_GET["key"] == "si") $clave = ", add primary key ($campo)";
else $clave = "";

$sql = "alter table $bd.$tabla add column $campo $tipo$nulo$pred$clave";
$res = @mysql_query($sql);
header("Location: ver_columnas.php?bd=$bd&tabla=$tabla");

Sobre este último código vemos la instrucción SQL que hemos utilizado para borrar columnas y nos acompañará el resto de este apunte: alter table. Viendo su sintaxis, notamos que después de indicar la tabla que vamos a "alterar", debemos indicar la lista de modificaciones separadas por comas; en este caso concreto queremos añadir una columna (campo), así que usamos "add [columna] [características]".

También hemos puesto en el listado de campos o columnas un enlace para editarlos que al igual que en el caso del borrado, tiene como parámetros la base de datos, la tabla y la columna. Nos servirá el formulario que usamos en "ver_columnas.php", donde cabiamos el action por modificar_columna.php, y añadimos un campo oculto para no perder la referncia de la columna. A continuación mostramos el código que modifica columnas:

$bd = $_GET["bd"];
$tabla = $_GET["tabla"];
$describe = (isset($_GET["bd"])) ? "$_GET[bd].$_GET[tabla]":$_GET["tabla"];
$columna = $_GET["Field"];
$sql = "describe $describe";
$res = mysql_query($sql);
if ($res)	{
	if (mysql_num_rows($res) > 0)    {
		$c = mysql_num_fields($res);
		$titulos = array();
		$ths = array();
		for ($i = 0; $i < $c; $i++)
			array_push($titulos, mysql_field_name($res, $i));
		$datos = array();
		while	($dato = mysql_fetch_array($res))	{
			if ($dato["Field"] == $columna)	{
				$datito = array();
				for ($i = 0, $total = count($titulos); $i < $total; $i++)
					$datito[$titulos[$i]] = $dato[$titulos[$i]];
			}
		}
	}
}
preg_match('/\((.*?)\)/is', $datito["Type"], $l);
$long = $l[1];
$tipo = preg_replace('/\((.*?)\)/is', "", $datito["Type"]);
$pred = $datito["Default"];
$null = ($datito["Null"] == "YES") ? " checked='checked'":"";
$auto = ($datito["Extra"] == "auto_increment") ? " checked='checked'" : "";
$pri = ($auto == "" && $datito["Key"] == "PRI") ? " checked='checked'" : "";
$no = ($auto == "" && $pri == "") ? " checked='checked'" : "";
$alter = array();
if ($_GET["pred"] != $pred)	{
	array_push($alter, ($_GET["pred"] == "") ? "alter $datito[Field] drop default": "alter $datito[Field] set default '$_GET[pred]'");
}
$type = ($_GET["long"] == "") ? $_GET["tipo"]:"$_GET[tipo]($_GET[long])";
if ($datito["Type"] != $type)
	array_push($alter, "modify $columna $type");
if (isset($_GET["null"]))	{
	if ($datito["Null"] != "YES")
 		array_push($alter, "modify $columna $type null");
}
else	{
	if ($datito["Null"] == "YES")
		array_push($alter, "modify $columna $type not null");
}
switch ($_GET["key"])	{
	case "auto_increment":
		if ($datito["Extra"] != "auto_increment")
		array_push($alter, "modify $columna $type not null auto_increment, add primary key ($columna)");
	break;
	case "si":
		if ($datito["Key"] == "" && $datito["Extra"] != "auto_increment")
		array_push($alter, "add key ($columna)");
	break;
	case "no":
		if ($datito["Key"] != "" && $datito["Extra"] != "auto_increment")
		array_push($alter, "drop key $columna");
	break;
	default:
	break;
}
if ($_GET["campo"] != $columna)
	array_push($alter, "change $columna $_GET[campo] $type");
if (count($alter) > 0)	{
	$sql = "alter table $bd.$tabla ".implode(", ", $alter);
	$res = mysql_query($sql);
}
header("Location: ver_columnas.php?bd=$bd&tabla=$tabla");

Del código que hemos presentado destacamos que podemos realizar más de una alteración: cambio de nombre, de tipo, de valores predeterminados, que admitan o no valores nulos y algunas posibilidades con los índices; y aunque existen más posibilidades, por tratarse de una "gestión sencilla", lo dejaremos así.

Notas finales

Hemos comentado que hay que hacer algunas cosas con mucha precaución, sobre todo cuando empecemos a ingresar datos, ya que podríamos hacer modificaciones "no reversibles" que podrían causar pérdidas de datos; evidentemente son consecuencias no deseadas. Y aunque son códigos funcionales, hay herramientas muy potentes y a veces totalmente gratuitas con muchas opciones y del todo recomendables como es el caso de phpMyAdmin.

Reivindicación del código en español

Publicado el día 15 de enero de 2012

Como en otras ocasiones, tenemos una buena razón para crear un apunte crítico basándonos en un artículo que en mi opinión fomenta una costumbre que deberíamos erradicar.

El artículo lo encontré en un tema de los foros del web: [ARTICULO] Por qué se debe programar en inglés, y se plantean muchos beneficios con la afirmación pero tan solo uno para para la opción de programar en español, y expresado con una ironía propia de quién no se ha preocupado en reflexionar seriamente.

Y ¿por qué debe haber razones? ...

Vamos a intentar poner nuestra lista de razones para programar en español, obviando la más importante que sería simplemente "porque nos da la gana".

Traducciones cada vez más fáciles de conseguir y bastante aproximadas

¡Exacto!, al igual que cuando queremos enterarnos de un texto en cualquier idioma, basta con entrar en cualquier traductor en línea para encontrar una traducción muy aproximada del texto original. Para quién necesite ese dato en otro idioma tiene la misma facilidad.

Comprensión y semántica "natural"

Si bien es cierto que debemos limitarnos algo por lo que se consideran "caracteres especiales" para el inglés como tildes o eñes, siempre podemos encontrar sinónimos o formas alternativas de usar esas palabras; por ejemplo: si queremos referirnos al año, podemos pensar en palabras como anuario, anual, o incluso componerlas como "doce_meses".

La comunidad de programadores hispanos es muy grande

Es tiempo de independizarnos de los vicios y costumbres adquiridos por el uso de otro lenguaje (en muchos casos "mal uso"). Además, si hemos aprendido en aulas con profesores que nos enseñaban en nuestro idioma, hasta encuentro en la afirmación "falta de ética profesional".

Tendencia: Programación Orientada a Objetos (POO)

Aquel problema mencionado sobre los caracteres especiales pierde importancia porque los identificadores dentro de los objetos son texto sin las limitaciones de los identificadores de variables.

A continuación unas pocas líneas javascript para mostrar el año actual con javascript (también puede usarse la palabra año como variable). El código puede probarse directamente en nuestro Probador web:

window.onload = function() {
	fecha = {};
	fecha["año actual"] = new Date().getFullYear();
	//año = new Date().getFullYear();
	alert("Año actual: " + fecha["año actual"]);
}

También encontramos la variable "$año" en el siguiente código php.

Este diario: Sindición extra

Publicado el día 12 de enero de 2012

Cuando hemos tratado el "resumen del año 2011" mostramos unos nuevos extras que implementamos recientemente, y ahora que empiezan a ser considerables, nos ha parecido buena idea mejorar el rincón dedicado a los extras que tenemos en la página.

Entre esas nuevas implementaciones acabamos de realizar una que permite sindicar automáticamente los propios extras y que en la nueva sección aparece con el clásico dibujo de sindicación de contenidos: .

Preliminares

Para que el enlace al archivo "rss" fuera legible hemos creado también un fichero "xsl" para que se vean los extras como una lista:

<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:xlink="www.w3.org/1999/xlink">
<xsl:template match="/">
<html>
<head>
<title><xsl:value-of select="rss/channel/title" /></title>
<style type="text/css">
<![CDATA[
*	{
	margin: 0;
}
h1	{
	text-align: center;
	background-color: #eeeeee;
	padding: 1em;
}
dl	{
	margin: 1em;
	padding: 1em;
	border: 3px ridge blue;
}
dd	{
	text-indent: 2em;
}
#pie	{
	background-color: #eeeeee;
	padding: 10px 0;
	clear: both;
}
h6	{
	text-align: center;
	margin: 0;
}
]]>
</style>
</head>
<body>
<h1>
<xsl:value-of select="rss/channel/title" />
</h1>
<dl>
<xsl:for-each select="rss/channel/item" >
<dt>
<a href="{link}"><xsl:value-of select="title" /></a>
</dt>
<dd><xsl:value-of select="description" /></dd>
</xsl:for-each>
</dl>
<div id="pie">
	<h6>
		<span style="font-weight: bolder">Copyright © 2002-2012 <a href="index.php">www.pepemolina.com</a></span>
		<br/>
		<a href="diario.rss.xml" >RSS
			<img src="diario.imagen.php?id=22&max=10" alt="rss" title="rss" longdesc="diario.ficha.php?id=22" />
		</a>
		| Ver
		<a href="diario.sitemap.html" >
			Mapa del sitio
		</a>
	</h6>
</div><!-- id="pie" -->
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Y para descripciones hemos usado el típico BBCode que en nuestro caso son del tipo [rss]Descripción[/rss]. El código puede verse con este otro comodín: Código del extra "extras_xml". Nótese como la "descripción" se añade en un comentario del código.

// descripción para la sindicación:
/*
	[rss]Con este comodín podemos obtener el listado de extras del diario en formato rss (xml).[/rss]
*/

Algunos extras destacados

Aparte de los que se han añadido en el nuevo sector reservado a los extras, destacamos los relacionados con manipulación de imágenes:

En el recuadro hemos utilizado los siguientes comodines:

• escalar (imagen de fondo del recuadro)
• PaletaWeb
• marcOval (aplicado a la flor)
• redondear_esquinas (aplicado al tigre)
• pngshape (círculo azul)
• bandera (dentro del círculo azul)

Marcos ovalados

Publicado el día 07 de enero de 2012

Hemos mostrado como crear esquinas redondeadas en las imágenes, pero ahora tengo que hacer una orla, y necesito un marco ovalado con borde negro.

La técnica que hemos usado es similar al anterior sistema, aunque en vez de superponer cuatro imágenes en las cuatro esquinas de las fotos, simplemente creamos una imagen con la forma oval transparente con su borde, y la superponemos a la original, para luego transparentar el color de las esquinas.

El tipo de imagen resultante tendrá que permitir transparencias, pero también alta definición, así que nos hemos decantado por el formato png.

El código real puede verse en el visor de código que acabamos de presentar en el anterior apunte: marcOval. El grosor del marco puede definirse, pero si no fuese el caso, se quedará en el 15% del radio menor de las dimensiones de las foto.

A continuación mostramos el código:

$foto = imagecreatefromstring(file_get_contents($_GET["url"]));
$ancho = imagesX($foto);
$alto = imagesY($foto);
$anchi = ($ancho % 2 == 1) ? $ancho : $ancho - 1;
$alti = ($alto % 2 == 1) ? $alto : $alto - 1;
$fondo = imagecolorallocate($foto, 255, 255, 255);
$mX = (int) $ancho / 2;
$mY = (int) $alto / 2;
$menor = ($mX < $mY) ? $mX : $mY;
$grueso = (isset($_GET["grosor"])) ? (int) $_GET["grosor"]: (int) ($menor / 15);
$grosor = (is_integer($grueso)) ? $grueso: (int) ($menor / 15);
$figura = imagecreatetruecolor($ancho, $alto);
$blanco = imagecolorallocate($figura, 255, 255, 255);
imagefill($figura, 0, 0, $blanco);
$negro = imagecolorallocate($figura, 0, 0, 0);
$rojo = imagecolorallocate($figura, 255, 0, 0);
imagefilledellipse($figura, $mX, $mY, $anchi, $alti, $negro);
imagefilledellipse($figura, $mX, $mY, $anchi - $grosor, $alti - $grosor, $rojo);
imagecolortransparent($figura, $rojo);
imagecopymerge($foto, $figura, 0, 0, 0, 0, $ancho, $alto, 100);
imagecolortransparent($foto, $fondo);
header("Content-Type: image/png");
imagepng($foto);
imagedestroy($figura);
imagedestroy($foto);

Entre las pocas cosas que podemos comentar del código, es que el borde se le resta a la imagen, aunque sea un detalle poco relevante.

Este diario: resumen del año 2011

Publicado el día 05 de enero de 2012

Este año que acaba de terminar hemos publicado algo más de una cincuentena de apuntes de diversa índole, pero también hemos modificado algunos aspectos de la misma, tanto estéticos como de funcionalidad.

Con respecto a los contenidos, intentamos que fuesen originales y en lo posible de utilidad, aunque también quisimos ser algo críticos (véase la categoría Mamarrachadas).

Intentamos que todos los apuntes sean fáciles de encontrar desde nuestro Mapa del web, pero también creamos propias herramientas con nuestros comodines. Uno de ellos (el último hasta el momento) nos proporciona el listado anual de nuestros apuntes. Así podemos mostrar el listado de apuntes del año pasado: 2011.

Extras: pocos pero importantes.

Algunos de los extras que hemos implementado son bastante útiles, tanto es así que en este año que comienza reservaremos un rinconcito de la página principal para ellos. Por lo pronto desde hace algunos días hemos añadido el listado de los extras. A continuación listamos algunos:

Listado de extras

Con este comodín, podemos ver todos los extras y los apuntes donde se utilizan. Es el primero incluido en la página principal.

Código de los extras

Desde el listado (item anterior) podemos enlazar para ver su código. Aquí mostramos el suyo propio.

Código del comodín (diario.jocker.php)

Página mágica que permite ejecutar código php guardado en una tabla de la base de datos.

Búsqueda de texto (Novedad) en los apuntes y demás páginas del diario (categorías, etiquetas, extras, imágenes...)

Aunque es un extra de este año nuevo (2012), evidentemente es a consecuencia del incremento de contenidos del sitio.

Resultado de la búsqueda complementando al item anterior.

A continuación podemos ver un resultado: buscar=caricaturas (en la tabla apuntes).

Una característica del comodín asociado a los extras es que el nombre se pasa en la línea de comandos, pero también puede tratarse de valores pasados por formularios con método "post" (http).

Comentarios, seguridad... y otras yerbas.

En un principio solo se podían comentar los apuntes y aunque sea lo más importante, hemos ampliado las posibilidades en el sistema de comentarios pudiéndolo hacer también en las descripciones de categorías, etiquetas e imágenes; y tenemos pensado aún ampliar esa caracteríatica a las viejas páginas del dominio. Éstas últimas también se han añadido durante el 2011.

Con respecto a la seguridad, nos han atacado con spam en numerosas ocasiones, viéndonos obligados a borrar cientos de comentarios; por tal motivo hemos hecho unos retoques en el sistema, y no descartamos seguir en ello.

Otras temáticas que hemos tratado en bastantes ocasiones son las imágenes y postales, donde hemos retocado un viejo editor de postales para poderlas guardar y editar; así como hemos hablado en muchas ocasiones de manipulación de imágenes.

También hemos comentado algunas cosas del mundo de las caricaturas y los caricaturistas.