Consulta SQL para conocer el número de campos de una tabla

Por avatares del destino hoy estaba modificando una página en ASP clásico y necesitaba saber el número de campos que tenía una tabla. Basta con una consulta para tener estos datos:

SELECT Table_Name, COUNT(*) As NumeroCampos
FROM Information_Schema.Columns
WHERE Table_Name = 'nombre_de_la_tabla'
GROUP BY Table_Name;

Si queréis saber el de todas las tablas de la base de datos podéis hacer lo siguiente:

SELECT Table_Name, COUNT(*) As NumeroCampos
FROM Information_Schema.Columns
GROUP BY Table_Name
ORDER BY Table_Name

Hacer un UPSERT en MySQL

Si el otro día os contaba cómo hacer un INSERT IF NOT EXISTS en MySQL, hoy vamos a ver cómo hacer un UPSERT. La idea es intentar un INSERT, pero en caso de que se de una duplicidad de un campo único (una clave primaria, un campo UNIQUE…) en lugar de insertar actualizará el campo en cuestión. Hasta esta mañana desconocía esta forma de insertar, pero me lo comentaron en StackOverflow por un problemilla que tenía con un procedimiento almacenado.

La sintaxis sería más o menos:

INSERT INTO tabla (a,b,c) VALUES (1,2,3)
ON DUPLICATE KEY UPDATE c=c+1, b=2;

Os pongo un ejemplo práctico, metido dentro de un procedimiento almacenado. Recibe el id de un usurio y una variable bit que representa si se ha conectado o ha cerrado sesión, guarda estos datos junto con el momento en que se ha realizado dicha acción en una tabla usada para llevar el control de lo mismo (bueno, es más o menos lo mismo que me pusieron en SO):

DELIMITER $$
CREATE PROCEDURE `sp_UltimoLogin`(id_in int, accion_in bit)
BEGIN
  INSERT INTO `login` (`idusuario`, `fecha`, `accion`) VALUES (id_in, now(), accion_in)
    ON DUPLICATE KEY UPDATE `fecha` = now(), `accion` = accion_in;
END $$

Un truquito que os ahorrará realizar comprobaciones en muchos supuestos, aligerando la carga de trabajo y reduciendo líneas de código.

Poblar un combo dinámicamente con jQuery y JSON

Es habitual que, creando formularios, nos encontremos con la situación de tener dos combos (o campo select si lo preferís) y que uno tenga que cargar/modificar sus datos según el resultado seleccionado en el otro, de forma dinámica. Esto es posible con Javascript, y muy cómodo si utilizamos JSON y jQuery.

Os planteo un ejemplo simple: tenemos dos combos, uno con provincias y otro con ayuntamientos. El marcado HTML va a ser más o menos tal que así:

<select id="provincias" name="provincias">
  <option value=""></option>
  <option value="1">A Coruña</option>
  <option value="2">Lugo</option>
  <option value="3">Ourense</option>
  <option value="4">Pontevedra</option>
</select>
<select id="poblaciones" name="poblaciones" disabled="disabled">
</select>

Como véis, al momento de cargar la página el campo provincias tendrá las cuatro provincias gallegas, y el campo poblaciones estará desactivado. ¿Ahora qué necesitamos? Pues primero necesitamos un script que nos saque las poblaciones de la base de datos y nos las envíe como un JSON. Cualquier lenguaje de lado del servidor nos vale, para el ejemplo va a ser PHP (pero vamos, que podría aplicarse con Java, Ruby, node.js, Python…). Crearemos un script llamado getPoblacionesJson.php

<?php
include 'conexionbd.php';
if ($mysqli -> multi_query("CALL sp_GetPoblaciones(" . $_GET['pr'] . ")")) {
	$poblaciones = array();
	do {
		if ($result = $mysqli -> store_result()) {
			while ($fila = $result -> fetch_assoc()) {				
				$poblaciones[$fila['Id']] = $fila['Nombre'];
			}
		}
	} while($mysqli->next_result());
	print_r(json_encode($poblaciones));
}
?>

En este caso veis que lo que hacemos es llamar a un procedimiento almacenado que nos devuelve las provincias, recorremos el resultado y vamos guardándolo en un array. Finalmente lo convertimos a JSON y lo imprimios para que lo recoja la función de Javascript. Si os estáis preguntando cómo va el procedimiento almacenado, es una simple select en MySQL, tal que así:

DELIMITER $$
CREATE PROCEDURE sp_GetPoblaciones(IN provincia int)
begin
	SELECT Id, Nombre FROM poblaciones WHERE (provincia is null or IdProvincia = provincia) ORDER BY Nombre;
end $$
DELIMITER ;

Ok, tenemos entonces el script del servidor, el marcado y el procedimiento en la base de datos. ¿Qué nos queda? Pues el Javascript, vitaminado con jQuery para ganar productividad:

$("#provincias").change(function() {
	$("#poblaciones").empty();
	$.getJSON('http://localhost/getPoblacionesJson.php?pr='+$("#provincias").val(),function(data){
		console.log(JSON.stringify(data));
		$.each(data, function(k,v){
			$("#poblaciones").append("<option value=\""+k+"\">"+v+"</option>");
		}).removeAttr("disabled");
	});
});

La idea es simple: Si se registra algún cambio en el combo de provincias vaciamos el combo de poblaciones y lo rellenamos con los nuevos datos, obtenidos mediante la función getJSON() y que recorreremos con each() como un conjunto de claves/valores. Finalmente, por si está desactivado, lo reactivamos. He hecho un console.log por si queréis ver cómo funciona la cosa en la consola de javascript de Chrome o del Firebug.

Espero que os sirva de ayuda esta entrada para trabajar con combos dinámicos.

Importar datos desde un fichero CSV a una tabla de SQLite

Ya hemos hablado en el pasado de ficheros CSV en este blog, y hoy vuelven a la primera línea.

En este caso porque ayer estaba aconsejando a un amigo sobre cómo agilizar una tarea de inserción de datos en SQLite y llegamos a la conclusión de que, teniendo los datos en un fichero CSV tenía que haber una forma de importarlo. El caso es que San Google nos dio la respuesta, pero me fijé en que no había mucha cosa válida sobre el tema en español. Total, que me he decidido a traducir la entrada que nos fue más útil, que fue esta de HackGeo. Bueno, como siempre no será una traducción literal, sino una adaptación/explicación de su solución.

En fin, como dice el artículo original, hay una serie de puntos a considerar antes de ponerse a trabajar:

  • SQLite instalado en tu sistema operativo.
  • Una base de datos ya creada (si quieres seguir el ejemplo del original, podéis descargar ejemplos de código desde allí)
  • Una tabla creada en esa base de datos cuyos campos y tipos coincidan con los datos de nuestro CSV, tal que así:
    CREATE TABLE counties (
        name        CHAR,
        state       CHAR,
        state_abbrv CHAR( 2 ),
        FIPS        CHAR( 5 )
    );
    
  • Un fichero CSV cuyo esquema coincida con vuestra tabla, como por ejemplo:

    Maui,Hawaii,HI,15009
    Kauai,Hawaii,HI,15007
    Kalawao,Hawaii,HI,15005
    Honolulu,Hawaii,HI,15003
    Hawaii,Hawaii,HI,15001

Ahora, siguiendo el ejemplo original, ya tenemos todos los datos y el software listos. Ya sólo quedan cuatro pasos para tener todo listo:

  1. Lanza un terminal
  2. Abre la herramienta de terminal de comandos de SQLite, escribiendo sqlite3 y pasándole como parámetros la ruta absoluta a vuestra base de datos:
    sqlite3 '/Path/To/HackGeo - SQLite CSV Import Example/HackGeo.db'
    
  3. Pon la coma como separador por defecto (si usas tu propio CSV y no el del ejemplo entonces define el separador que corresponda, en caso de que no sea la coma):
    .separator ','
    
  4. Ahora ejecuta el importador de SQLite para volcar los datos del CSV en tu equipo. Le tenemos que pasar dos parámetros a este comando: la ruta del csv y el nombre de la tabla donde insertaremos los valores:
    .import '/Path/To/HackGeo - SQLite CSV Import Example/Counties.csv' counties
    

Y sólo con esto ya tenemos los datos pasados del CSV a la base de datos SQLite. Ya podéis cerrar el terminal de línea de comandos y empezar a trabajar con vuestros nuevos datos. Y si sabéis inglés en HackGeo tenéis muchos artículos interesantes sobre desarrollo, sistemas, etc…

Eventos en MySQL (planificar tareas por fecha y hora)

Seas un dba o seas un programador (y yo en mi caso soy ambas cosas) la automatización de tareas es algo no sólo útil, sino a veces indispensable. Al estilo de los cron jobs de Linux MySQL nos ofrece la posibilidad de definir una acción o serie de acciones que se repita periódicamente o se ejecuten en un momento concreto.

Lo primero es habilitar a nuestro servidor MySQL para que pueda hacerlo, con la siguiente línea:

SET GLOBAL event_scheduler = ON;

Si usas PHPMyAdmin tienes por ahí un botón para activarlo, no necesitas comandos.

Bueno, la sintaxis básica de la creación de eventos, y a la guía de usuario de MySQL me remito, es la siguiente:


CREATE
[DEFINER = { user | CURRENT_USER }]
EVENT
[IF NOT EXISTS]
event_name
ON SCHEDULE schedule
[ON COMPLETION [NOT] PRESERVE]
[ENABLE | DISABLE | DISABLE ON SLAVE]
[COMMENT 'comment']
DO sql_statement;

schedule:
AT timestamp [+ INTERVAL interval] ...
| EVERY interval
[STARTS timestamp [+ INTERVAL interval] ...]
[ENDS timestamp [+ INTERVAL interval] ...]

interval:
quantity {YEAR | QUARTER | MONTH | DAY | HOUR | MINUTE |
WEEK | SECOND | YEAR_MONTH | DAY_HOUR | DAY_MINUTE |
DAY_SECOND | HOUR_MINUTE | HOUR_SECOND | MINUTE_SECOND}

Ok, visto así, acojona. Pero no todos los parámetros son obligatorios, y explicado es fácil. Reamente necesitas sólo un nombre para el event_name, una condición para que se cumpla el ON SCHEDULE y un código sql que ejecutar después del DO. Te meto un ejemplillo sacado del curro, por ejemplo:

CREATE EVENT `close_expired_campaigns` 
ON SCHEDULE EVERY 1 DAY STARTS '2013-01-21 00:00:01' 
ON COMPLETION NOT PRESERVE ENABLE 
DO update tabla
set valido = 0
where
DATE_ADD(fechaCreacion, INTERVAL 45 DAY)<NOW() and valido=1;

Tiene algo más de código porque lo genera automáticamente PHPMyAdmin pero la idea es que crea un evento con ese nombre que, cada día un segundo después de medianoche actualice la tabla seleccionada poniendo a cero la columna indicada cuando se cumpla una condición (en este caso, que hayan pasado 45 días desde la creación). Bueno, como el código es tocho, os pongo debajo un ejemplo con la sintaxis más básica posible. Imaginemos una funcion que actualiza el saldo de una cuenta diaria de gastos a 1000 euros:

CREATE EVENT e_ActualizaSaldoDiario
ON SCHEDULE EVERY 1 DAY STARTS ‘2013-01-01 00:00:00’
DO UPDATE gastos SET saldo = 1000

Los dos ejemplos son recurrentes, se ejecutan todos los días a una hora (el parámetro Starts no permite definir el momento en que comenzará a ejecutarse, acuérdate de ponerlo porque si pones solo EVERY 1 DAY debería fallar, y no tiene por qué ser cada día, puedes poner un periodo concreto de horas, minutos, días, semanas…). Existe la posibilidad de que un evento se ejecute sólo una vez, en el momento que le indiques y luego se borre. Por ejemplo imaginemos que quieres que dentro de 6 horas se borren todos los registros del año 2012:

CREATE EVENT e_Borra2012
ON SCHEDULE AT now() + INTERVAL 6 HOUR
DO DELETE cuentas WHERE year = 2012

Y en estos tres ejemplos sólo hemos utilizado sentencias de SQL simples, pero imagina la potencia (y los riesgos de joderlo todo si la cagas, claro está) si los combinamos con procedimientos almacenados y con disparadores… Me imagino una bombillita alumbrando tu cabeza, y todas las cuestiones de mantenimiento y actualización que se te están ocurriendo.

Seleccionar filas aleatoriamente en MySQL

Existen varias opciones a la hora de seleccionar filas de forma aleatoria en MySQL, haciendo uso de la función RAND(). Vamos a imaginar que quieres obtener 3 filas aleatorias de una base de datos. Lo más sencillo es usar la siguiente sintaxis:

SELECT * FROM tabla ORDER BY RAND() LIMIT 3;

El problema de este método es que tiene que generar una tabla temporal completa con todos los datos de la tabla original reordenados aleatoriamente… en fin, que es una sangría de recursos. Existe una opción, que es generar sólo una tabla con los registros que queramos, mediante una subconsulta. Tal que así:

SELECT * FROM tabla WHERE RAND()<(SELECT ((3/COUNT(*))*10) FROM tabla) ORDER BY RAND() LIMIT 3;

Un método que sigue gastando muchos recursos, pero menos al crear sólo una tabla temporal con la cantidad de filas que necesitamos (cantidad que necesitamos / total * 10).

Pero si tenemos un índice autonúmerico en nuestra tabla podemos ahorrar más recursos:

SELECT t.* FROM tabla AS t JOIN (SELECT ROUND(RAND() * (SELECT MAX(id) FROM tabla)) AS id) AS x WHERE t.id >= x.id LIMIT 3;

Este método no genera un valor aleatorio para cada fila consultada, por lo que ahorra muchos recursos en el servidor. Eso sí, no te dará los registros ordenados aleatoriamente, sino que será registros secuenciales, pero comenzando en un valor aleatorio. Es decir, los dos primeros podrían devolverte las filas 1, 21 y 42, este en cambio te devolvería 1,2,3 – 41,42,43… si quieres que sea un resultado aleatorio de verdad deberías realizar la consulta varias veces con limit 1… con lo que el ahorro de recursos se va al carajo. Además, puede fallar si hay algún hueco en la secuencia del campo autonumérico (por ejemplo, si has borrado un valor).

Una última opción, en lugar de generar el valor aleatorio a nivel de base de datos generarlo antes, en el código del servidor. Un ejemplo en PHP (que también tiraría de id autonumérica y que también daría problemas si tuviera huecos, ojo):

$result = $mysqli->query("SELECT * FROM tabla WHERE id in ROUND(".lcg_value()."*(SELECT COUNT(*) FROM tabla)) LIMIT 1")

El ejemplo de arriba nos devolvería una fila aleatoriamente, por lo que bastaría con repetirla en un bucle tantas veces como necesitemos (en este caso el problema vendría de la cantidad de conexiones que hay que abrir a la base de datos). Puedes intentar implementar lcg_value() en los otros métodos citados, y comprobar si el rendimiento mejora.

Evitar SQL-injection en PHP

Los ataques SQL-Injection son unos de los más habituales en el mundo web. Aquí vamos a ver una serie de consejos para evitar estos agujeros en la seguridad:

Lo primero es seguir una serie de consejos a nivel de administración, como limitar los permisos del usuario a nivel de base de datos. Por ejemplo, en la mayoría de aplicaciones web lo habitual es que no tenga que utilizarse DROP, por lo que por seguridad sería mejor no permitir ya al usuario hacerlo. También sería interesante no dar información extra al atacante evitando sacar en pantalla los errores de la base de datos. En ese caso lo ideal es capturar el error haciendo uso de exception. Tampoco hay que confiarlo todo a las validaciones por javascript, porque el atacante puede saltárselas desactivándolo desde el navegador, por lo que mejor hacer las validaciones del lado del servidor. Y finalmente escapar las comillas con msqli_real_scape_string (en caso de que usemos MySQL), pg_scape_string (en caso de PostgreSQL) o addslashes (por si utilizamos otro SGBD). También podemos utilizar htmlentities para convertir los textos en entidades html, como un plus a la seguridad. Abajo un simple ejemplo:


<?php

try{
  $query = sprintf("SELECT * FROM users WHERE id=%d", mysqli_real_escape_string($id));
  $query = htmlentities($query);
  mysqli_query($query);
}catch(Exception $e){
    echo('Lo sentimos, ha habido un error en la conexión');
}
?>

Como medida extra se podrían utilizar expresiones regulares para evitar la inserción de ciertas palabras (SELECT, DROP, UNION…), si bien puede resultar poco práctico, sobre todo si tu software está destinado al mercado británico.

Pero si todo esto te parece lioso, hay una alternativa: la clase PDO. Dicha clase nos facilitará mucho la vida a la hora de trabajar con bases de datos, ya que nos permite abstraernos del SGDB que estemos utilizando. Si por ejemplo, en una página donde no utilices PDO o algo similar sino el mysql_connect simple, decides migrar tu web de MySQL a PostgreSQL tendrías que cambiar todos los métodos del conector de MySQL por los métodos de PostgreSQL. Con PDO bastaría con que cambiaras una sola línea de código, concretamente la de la creación del objeto PDO, y el resto de la aplicación seguiría funcionando. PDO además te permitirá usar consultas parametrizadas (como los Prepared Statements de java) o realizar transacciones. En fin, en el enlace de arriba tenéis todo el manual de PDO para estudiarlo si queréis. Ahora vamos con un simple ejemplo de Prepared Statement, para que veáis lo sencillo que es (dando por sentado para el ejemplo que ya hemos creado el objeto PDO, tal cual está explicado en el manual del enlace).


<?php
  $prepared_statement = $pdo->prepare("SELECT name FROM usuarios WHERE id = :id");/*preparamos la consulta*/
  $prepared_statement->bindParam(':id', $_GET['id'], PDO::PARAM_INT); /*Le pasamos el parámetro, asociado al parámetro de la consulta y definiendo su tipo (si no, por defecto lo trata como string)*/
  $prepared_statement->execute(); /*ejecutamos*/
  $prepared_statement = $statement->fetch(); /*recogemos los resultados, como un array. Se pueden utilizar parámetros para especificar otro tipo de respuesta, como por ejemplo PDO::FETCH_ASSOC para obtener un array asociativo*/
?>

Y con estos breves consejos lograrás que tu página sea más segura. El consejo: utiliza PDO, por ahorrarte comeduras de cabeza, por seguridad y por portabilidad de tu código.

Añadir columna a una tabla en MySQL (y MariaDB)

Una pequeña entrada sobre SQL básico, porque me lo han preguntado hace un rato, así que aprovecho para contestar por aquí.

Muy bien, tienes una tabla y quieres añadir una columna o campo que se te olvidó al crearla, o que por cambios en la aplicación necesitas añadir. Si te vas a la guía de referencia de MySQL puedes leer todas las posibilidades que tienes, pero como se puede hacer largo y pesado mejor unos ejemplillos de código rápidos aquí:

La sintaxis básica es ALTER TABLE nombreDeLaTabla add nombreDeLaColumna tipodedatos(longitud)

ALTER TABLE tabla1 add colNueva varchar(2);

Vamos con más ejemplos. Por ejemplo, queremos que la columna nueva no permita valores nulos (ojo, esto puede dar problemas si la tabla ya tiene valores añadidos):

ALTER TABLE tabla1 add colNueva varchar(2) NOT NULL;

O por ejemplo queremos colocarlo específicamente después de una columna que ya existe (si no especificamos nada, añadirá la nueva al final):

ALTER TABLE tabla1 add colNueva varchar(2) NOT NULL AFTER col1;

O al revés, queremos insertarla antes de una columna concreta:

ALTER TABLE tabla1 add colNueva varchar(2) NOT NULL BEFORE col2;

También puede venir con un valor por defecto:

ALTER TABLE tabla1 add colNueva varchar(35) DEFAULT 'Ni de ajo';

¿Y si en vez de una quieres insertar varias? Sin problema:

ALTER TABLE tabla1 add (
colNueva varchar(2) NOT NULL,
colMásNueva tinyint(1) default 0
)

Como ves, es sencillo. SQL básico. Como siempre, todo lo aplicable en MySQL lo es también en MariaDB.

Limitar el número de filas en la salida de un consulta en Oracle

En fin, hoy primer contacto con el SGBD de Oracle (sí, ese privativo tan caro y a la vez tan extendido en la administración), del cual no puedo decir mucho porque con una clase, sobre fundamentos de SQL además (que no es por ir de sobrado, pero la primera semana me da que me voy a aburrir repasando lo más básico de siempre), pues no da para haber testado mucho. Lo que sí comprobé, tonteando un poco, es que la forma de forma de limitar el número de filas en la salida de una consulta no tiene nada que ver ni con SQL-Server, PostgreSQL o MySQL.

Porque claro, tú quieres por ejemplo sacar los 10 que más cobran y en MySQL o en PostgreSQL lo haces tal que así

SELECT nombre FROM empleados ORDER BY salario LIMIT 10

Y si eres de los de tito Bill te apañarías con:

SELECT TOP 10 nombre FROM empleados ORDER BY salario 

Total, que andaba trasteando un rato después de hacer los ejercicios, tipo «me ha sobrado un huevo de tiempo, vamos a probar si otras cosas van igual que en algunos de los sistemas gestore que he usado» y ahí me encuentro que esto cambia, que ni es como en Microsoft ni como en los otros dos SGBD libres. Aunque curiosamente la palabra limit aparezca como reservada (todavía no se para qué, una de las cosas que espero aprender en el susodicho curso). Tras un poco de investigación entre la (vasta) documentación de Oracle me ecuentro con que la cosa va así:

SELECT nombre FROM empleados ORDER BY salario WERE rownum<=10

Conclusión/explicación: Oracle nos ofrece una pseudocolumna (iba a llamarlo variable, pero acabo de leer que este es el término más correcto) llamada rownum (número de fila) que nos servirá, mediante una condición where, para limitar la salida de resultados de la consulta (también puede valer para realizar consultas paginadas en una web, pero igual te chupas demasiadas conexiones al motor si lo haces así en vez de bajar todo de vez y manejarlo en el cliente… ahí ya depende del proyecto). Si quieres 10 filas le dices «que el número de fila sea menor o igual que diez», que quieres 20… lo mismo.

Crear una función en MySQL

Aunque se trate de algo muy básico a la hora de programar bases de datos, creo que no está de más hablar de la sintáxis para la creación de funciones definidas por el usuario en MySQL. Dicha sintaxis es la siguiente:

CREATE [AGGREGATE] FUNCTION function_name RETURNS {STRING|INTEGER|REAL}
       SONAME shared_library_name

Explicado rápidamente: function_name es el nombre con el que se va a invocar dicha función. RETURNS nos indica, por otra parte, qué tipo de dato recibiremos como respuesta. Y shared_library_name es el nombre del fichero del objeto compartido que guarda el código de la función. El modificador opcional AGGREGATE permite definir la función como una función de agregado (como SUM() o COUNT()).

Para poder crear una función se necesita tener permiso de INSERT en la base de datos, mientras que para eliminarla se necesitan permisos de DELETE. La sintaxis de borrado de una función es:

DROP FUNCTION function_name

MySQL además del uso de funciones SQL permite también el uso de funciones de C y C++ (como SQL-Server permite el uso de funciones contenidas en una .dll u Oracle el uso de Java). En caso de querer usar una función de C hay que recordar que los tipos de datos en C no se llaman igual que en SQL, para definir el retorno de la función. STRING sería char *, INTEGER sería long long y REAL sería double. También es interesante, aunque no obligatorio, definir una función nombredelafuncion_init() y nombredelafuncion_deinit(), el primero para reservar memoria y el segundo para liberarla. Recuerda que C no reserva memoria automáticamente, así que puede ser indispensable para el uso de la función si esta requiere algo de RAM. Las funciones en C o C++ deben compilarse e instalarse en el equipo donde corre el servidor.