A partir de MySQL 5.1 el motor de almacenamiento en CSV (Valores separados por comas) viene instalado por defecto en el servidor MySQL, lo que nos facilita un método para exportar datos de tablas en este formato, utilizándolo de forma nativa.
También es posible exportar datos en este formato directamente a través de una sola consulta, podéis verlo aquí.

¿cómo se si el método de almacenamiento en CSV está activado?

Si la versión instalada es 5.1 o superior, normalmente viene por defecto, para comprobarlo, nos conectamos con un usuario administrador:

mysql -u root
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.1.30 MySQL Community Server (GPL)

Y listamos los engines disponibles, mediante el comando SHOW engines o show variables like 'have_csv':

mysql> SHOW ENGINES\G;
*************************** 1. row ***************************
Engine: MyISAM
Support: DEFAULT
Comment: Default engine as of MySQL 3.23 with great performance
Transactions: NO
XA: NO
Savepoints: NO
*************************** 2. row ***************************
Engine: MRG_MYISAM
Support: YES
Comment: Collection of identical MyISAM tables
Transactions: NO
XA: NO
Savepoints: NO
*************************** 3. row ***************************
Engine: BLACKHOLE
Support: YES
Comment: /dev/null storage engine (anything you write to it disappears)
Transactions: NO
XA: NO
Savepoints: NO
*************************** 4. row ***************************
Engine: CSV
Support: YES
Comment: CSV storage engine
Transactions: NO
XA: NO
Savepoints: NO
*************************** 5. row ***************************
Engine: MEMORY
Support: YES

MySQL es un sistema de gestión de bases de datos claramente orientado a la web, y una de los síntomas en su arquitectura ha venido siendo que la creación de los usuarios se realiza en la misma sentencia que el permiso (grant) de acceso a una o varias bases de datos. La orientación de MySQL va cambiando con el tiempo y el uso que se le da a las bases de datos cada vez trasciende más el entorno web, actualmente hay tres formas de crear un usuario:

la forma clásica, con la sentencia GRANT

Utilizando la sentencia GRANT podemos crear un usuario a la par que otorgarle uno o varios privilegios sobre los objetos de una base de datos, o la base de datos completa.
Al encontrarse una sentencia de tipo GRANT, el motor de MySQL revisa si el usuario existe previamente para el contexto que estamos asignándole permisos, y si dicho usuario no está presente en el sistema, lo crea.
No entraré en detalles sobre todas las opciones que nos permite ejecutar la sentencia GRANT, sino solo en las que se refieren a la creación del usuario.
Pongamos un ejemplo, queremos crear el usuario adolfo para la base de datos test:

- Nos conectamos con un usuario que tenga privilegios, root, como propietario de la base de datos, los tiene.

$ mysql -u root
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 17
Server version: 5.0.67 Source distribution

Nos conectamos utilizando -u para indicarle el usuario y si quisieramos indicarle un password, deberiamos poner -p (sin añadirle la contraseña), en este caso la cuenta root, al ser una máquina de desarrollo, está desprotegida.

- Lanzamos la sentencia GRANT, indicando los permisos que otorgamos, la base de datos y los objetos de la misma sobre los que estamos asignando privilegios, el nombre del usuario y el password:

Un poco de historia

La empresa MySQL AB (originalmente TCX DataKonsultAB) nace en 1995, en Suecia, fundada por David Axmark, Allan Larsson, y Michael "Monty" Widenius. Monty llevaba varios años desarrollando un sistema había que ofrecía una forma optimizada y flexible para acceder a bases de datos SQL utilizando el método ISAM, ya que ninguna de las interfaces existentes le resultaba adecuada, así surgió una nueva API de acceso a SQL que podía y puede ser accedida y modificada por terceras partes, esta api se llamó MySQL.

El prefijo My tiene dos posibles orígenes, uno es corporativo, ya que llevaban tiempo llamando a todas sus aplicaciones con este prefijo, o también familiar, ya que el primer hijo de Monty se llama My.
Personalmente, yo me quedo con esta segunda explicación, ya que el segundo hijo de Monty, Max, da nombre al interfaz de datos para SAP MaxDB y la tercera hija se llama María, y da nombre al nuevo motor relacional de MySQL que substuirá a InnoDB.

El origen del delfín que MySQL usa como logo

MySQL sufrió un rediseño drástico en 2001, y uno de los puntos clave del cambio fue el logo, un delfín que representa la simbología de una especie en peligro y fue diseñado por el finlandés Renne Angelvuo (lo cierto es que apenas he encontrado información del diseñador y no estoy seguro de que sea la misma persona).

La pseudocolumna ROWNUM sirve, en Oracle, fundamentalmente para dos cosas:

  • Numerar por órden de visualización los registros recuperados por una consulta.
  • Limitar el número de registros devueltos por una consulta

Para realizar lo segundo en MySQL, la cláusula LIMIT es mucho más simple y efectiva que el método para limitar con ROWNUM en Oracle, sin embargo lo primero, es decir, mostrar un contador de registros en MySQL no tiene un equivalente directo, aún así, se puede emular de la siguiente forma:

Pongamos la siguiente consulta, que devuelve los registros de una tabla de ejemplo:

mysql> SELECT * FROM frutas;
+-----------+----------+
| nombre    | color    |
+-----------+----------+
| fresa     | rojo     |
| platano   | amarillo |
| manzana   | verde    |
| uva       | verde    |
| pera      | verde    |
| mandarina | naranja  |
| melocoton | marron   |
| limon     | amarillo |
+-----------+----------+
8 rows in set (0,00 sec)

Utilizando variables podemos conseguir mostrar el número de fila en MySQL:

SELECT @rownum:=@rownum+1 AS rownum, frutas.*
FROM (SELECT @rownum:=0) r, frutas;

mysql> SELECT @rownum:=@rownum+1 AS rownum, frutas.*
    -> FROM (SELECT @rownum:=0) r, frutas;
+--------+-----------+----------+
| rownum | nombre    | color    |
+--------+-----------+----------+
|      1 | fresa     | rojo     |
|      2 | platano   | amarillo |
|      3 | manzana   | verde    |
|      4 | uva       | verde    |
|      5 | pera      | verde    |
|      6 | mandarina | naranja  |
|      7 | melocoton | marron   |
|      8 | limon     | amarillo |
+--------+-----------+----------+
8 rows in set (0,00 sec)

Desgraciadamente no es posible usar variables dentro del código de las vistas, por lo que si intentamos crear una vista con el código anterior, nos devolverá un error:

mysql> CREATE VIEW vw_frutas AS SELECT @rownum:=@rownum+1 AS rownum, frutas.*
    ->  FROM (SELECT @rownum:=0) r, frutas;
ERROR 1351 (HY000): View's SELECT contains a variable or parameter

Gracias a Albert por la idea del post ;-)

En MySQL, cuando intentamos realizar una carga de datos sobre una instancia ya existente, existe la posibilidad de obtener un error parecido a este:

ERROR 1153 (08S01) at line 625: Got a packet bigger than 'max_allowed_packet' bytes

Esto pasa porque el cliente desde que estamos cargando los datos envía un paquete mayor de lo que el servidor está configurado para soportar, la instalación por defecto configura esta variable de sistema a 1Mb.
Es necesario que tanto el cliente de mysql como el servidor (mysqld) estén configurados para aceptar paquetes de datos mayores.

Configurar el servidor

Debemos modificar el fichero de configuración de MySQL, en el caso de sistemas Windows, el fichero my.ini de la carpeta donde hayamos instalado el servidor. Para sistemas *nix, el fichero /etc/my.cnf.
En ambos casos deberemos añadir/modificar el parámetro max_allowed_packet que se encuentra en la sección [mysqld], por ejemplo, para ponerlo a 16M

max_allowed_packet=16M

Y después reiniciar el servidor MySQL.

Configurar el cliente

La configuración del cliente puede no ser necesaria, pero se puede abrir una sesión indicando el valor para el parámetro max_allowed_packet, por ejemplo:

mysql --max_allowed_packet=16M

A partir de la versión 4 de MySQL, este parámetro puede ser de hasta 1 Gb.
Más información de la configuración de este parámetro en la documentación oficial.

MySql game es un juego que me ha recordado mucho a los viejos MUD con una mezcla de juegos modernos estilo trivian u ogame.

La gran diferencia es que está dedicado a geeks de las bases de datos, en lugar de fundar un poblado o un planeta, empiezas insertando un registro en una tabla. Desde este registro puedes atacar a los registros de tus malvados rivales, y también debes defender el tuyo. Para ello cuentas con unidades de ataque y de defensa, multiplicadores, combustible (porque moverte de un registro de una base de datos es costoso) o dinero para comprar todo lo anterior.

Lo mas curioso, lo que hace distinto al juego, es que todas las órdenes que le das, son sentencias SQL, por ejemplo, para comprar unidades de ataque:

UPDATE rows SET attackers = attackers+1 WHERE row_id = 882;

Cada 10 segundos se actualiza el estado de tu registro y ganas dinero y combustible, y con el dinero compras unidades, o más defensa. Y todos los eventos que pasan alrededor de tu registro y de los demás, se pueden ver en el log de querys, los ataques contra tu registro son sentencias UPDATE que te quitan dinero e unidades, y se visualizan en color rojo (en el WHERE del ataque puedes ver el registro ofensor, para devolversela más tarde). Los ataques que tú realizas se marcan en naranja y las actualizaciones en azul. ¡Hasta el chat funciona con sentencias SQL!

Está dentro del motor de aplicaciones de google, por lo que, con una cuenta de gmail puedes crear tu propio registro para dominar la tabla completa BWAHAHA

Hace unos días que lo leí en Propiedad Privada, y parece que, como excepción, este caso de ayuda no es scam ni una estafa, es totalmente real y muy urgente.


Ivan, el hijo de dos años de de Andrii Nikitin, ingeniero de soporte para MySQL en Ukraina, necesita urgentemente un transplante de médula ósea, ya que los largos tratamientos a los que está siendo sometido en su país no están dando el resultado que los médicos esperaban. Los hospitales de su pais no están preparados para realizar una operación tan delicada a un niño tan jóven, por lo que tienen que trasladarlo a Alemania, y el coste de todo esto es algo que la familia de Andrii no puede afrontar, aún vendiendo su casa y todas sus posesiones.

Ivan ya está en Alemania y está siendo sometido a vigilancia y análisis. Por lo que parece, en el mejor de los casos, la operación se realizaría en dos meses.

Hasta ahora han reunido unos 90.000€ (unos 20.000€ proceden de la comunidad de MySQL), pero la clínica alemana ha previsto otros 150.000€ de gastos durante el proceso.

Si queréis ayudar a Ivan, podéis hacer donaciones desde la propia web que MySQL ha habilitado
: http://www.mysql.com/about/help-ivan.html

Detalles sobre el estado actual de Ivan aquí y aquí

MySQL nos proporciona dos maneras de "clonar" una tabla, tanto su estructura como su estructura y sus datos, podemos querer duplicar una tabla para hacer algún tipo de backup rápido, mantener un histórico, o migrar la tabla a un esquema o base de datos diferentes, entre otras cosas.

Clonar una tabla usando SELECT

La sentencia de creación CREATE TABLE (..) SELECT nos permite crear la tabla con los registros que devuelva la consulta de selección, pero tiene las siguientes limitaciones:

  • No traspasa las constraints de tipo PRIMARY KEY
  • No traspasa las definiciones de AUTO_INCREMENT
  • No traspasa las definiciones de DEFAULT CURRENT_TIMESTAMP
  • Utiliza el storage engine por defecto y no el de la tabla (en caso de que sean distintos)
  • Solamente traspasa los registros afectados por la SELECT, que podría no devolver ninguno y crear la tabla vacía

Normalmente los sistemas de programación y bases de datos nos proveen con una función relativamente simple cuya utilidad consiste en transformar la primera letra de una frase o palabra a mayúsculas, en php es ucfirst(), en Oracle es initcap (en el caso de transformar una frase, la función de Oracle pone cada primera palabra en mayúsculas), pero parece ser que MySQL no la tiene, por lo que tenemos que explorar un poco más y usar una solución más creativa.

Pongamos como ejemplo esta frase:

mysql> SET @frase = 'bienvenidos a cambrico.net';
Query OK, 0 rows affected (0.00 sec)
mysql> SELECT @frase;
+----------------------------+
| @frase                     |
+----------------------------+
| bienvenidos a cambrico.net |
+----------------------------+
1 row in set (0.00 sec)

Nota: He utilizado una variable de mysql con SET y @ para hacer las siguientes operaciones un poco mas simples.

Tenemos funciones como UPPER/UCASE y LOWER/LCASE para transformar a mayúsculas o minúsculas la cadena:

mysql> SELECT UPPER(@frase);
+----------------------------+
| UPPER(@frase)              |
+----------------------------+
| BIENVENIDOS A CAMBRICO.NET |
+----------------------------+
1 row in set (0.00 sec)

Y para obtener la primera letra de la cadena en mayúsculas podemos utilizar un encadenado de las siguientes funciones: LEFT, para tomar el primer caracter de la izquierda y SUBSTR para coger los restantes, de esta forma tenemos aislada la primera letra. Aplicamos UPPER para transformarla en mayúsculas y unimos la cadena de nuevo con CONCAT (si tenemos sql_mode en ANSI_QUOTES, podemos usar ||)

mysql> SELECT CONCAT(UPPER(LEFT(@frase,1)),SUBSTR(@frase,2));
+------------------------------------------------+
| CONCAT(UPPER(LEFT(@frase,1)),SUBSTR(@frase,2)) |
+------------------------------------------------+
| Bienvenidos a cambrico.net                     |
+------------------------------------------------+
1 row in set (0.00 sec)

Actualizo: Para hacer lo que comenta Roberto, es decir, poner todas las palabras con la primera letra en mayúscula, tienes que hacer un procedimiento o una función (esto solo es posible a partir de MySQL 5.0). Os dejo un ejemplo:

Tras superar el examen Certified MySQL Developer - I, he pensado que sería útil para aquellos que se estén planteándo empezar a estudiar para obtener la certificación publicar algunos consejos o ideas que he usado.

Esta lista está orientada a Mysql 5.0, pero hay muchos puntos que podrían ser genéricos para otros exámenes / sistemas / versiones.

  1. El primer paso a tomar para empezar el camino de la certificación es adquirir la guía oficial de estudio: MySQL 5.0 Certification Study Guide, cuesta entre 20 y 35 euros (según pilléis la oferta de Amazon), y es realmente útil por cuatro motivos:
    • Os permitirá acostumbraros a la terminología en inglés, ya que los exámenes están en este idioma.
    • Cubre los cuatro exámenes principales, los dos de desarrollador y los dos de DBA, por lo que con un solo libro lo abarcáis todo.
    • Trae un CD con muchísimas preguntas (con sus respuestas), separadas por tema y exámen.
    • Viene con un 25% de descuento para un exámen, y puesto que los examenes rondan los 180€, solamente esto ya amortiza el libro. Parece que ya no viene tal descuento en los libros.


  2. Fijad una fecha de examen en cuanto empecéis a estudiar (pero después de recibir el libro, para aprovechar el descuento del examen). La idea de tener una fecha límite ayuda mucho a no procrastinar con el estudio. Y si finalmente la fecha que habéis escogido os viene realmente mal, podéis cambiarla online hasta 24 horas antes.