Abajo se muestra una gráfica circular generada mediante (una única consulta) SQL. Recorreré los pasos para producirla, y concluiré con, espero que estén de acuerdo conmigo, algunos ejemplos útiles para el mundo real.

+----------------------------------------------------------------------+
| pie_chart                                                            |
+----------------------------------------------------------------------+
|                                                                      |
|                         ;;;;;;;;;;;;;;;;;;;;;                        |
|                  oooooooo;;;;;;;;;;;;;;;;;;;;;;;;;;;                 |
|             oooooooooooooo;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;            |
|          ooooooooooooooooo                 ;;;;;;;;;;;;#####         |
|        oooooooooooooo                           ;#############       |
|       oooooooooooo                                 ############      |
|      oooooooooooo                                   ############     |
|      ooooooooooo                                     ###########     |
|      oooooooooooo                                   ::::::::::::     |
|       oooooooooooo                                 ::::::::::::      |
|        ooooooooo:::::                           ::::::::::::::       |
|          o::::::::::::::::                 :::::::::::::::::         |
|             :::::::::::::::::::::::::::::::::::::::::::::            |
|                  :::::::::::::::::::::::::::::::::::                 |
|                         :::::::::::::::::::::                        |
|                                                                      |
| ##  red: 1 (10%)                                                     |
| ;;  blue: 2 (20%)                                                    |
| oo  orange: 3 (30%)                                                  |
| ::  white: 4 (40%)                                                   |
+----------------------------------------------------------------------+

Requisitos

Necesitamos generar una consulta genérica que devuelva al menos dos columnas: name_column (un nombre) y value_column (un valor). Por ejemplo, la siguiente consulta servirá:

SELECT name AS name_column, value AS value_column FROM sample_values2;
+-------------+--------------+
| name_column | value_column |
+-------------+--------------+
| red         |            1 |
| blue        |            2 |
| orange      |            3 |
| white       |            4 |
+-------------+--------------+

Encontrará los datos de ejemplo en pie_data.sql.

Parte 1: expandir la consulta original

Tomaremos los resultados de la consulta anterior y los expandimos: ¿cuál es el ratio respecto al total, por cada valor? Como primer paso, los valores acumulados:

SELECT
  name_column,
  value_column,
  @accumulating_value := @accumulating_value+value_column AS accumulating_value
FROM (
  SELECT name AS name_column, value AS value_column FROM sample_values2
  ) select_values,
  (SELECT @accumulating_value := 0) select_accumulating_value
;
+-------------+--------------+--------------------+
| name_column | value_column | accumulating_value |
+-------------+--------------+--------------------+
| red         |            1 |                  1 |
| blue        |            2 |                  3 |
| orange      |            3 |                  6 |
| white       |            4 |                 10 |
+-------------+--------------+--------------------+

A continuación, calculamos el ratio del valor acumulado, y lo presentamos tanto en el rango [0..1], como en el [0..2*PI] (radianes):

SELECT
  name_order,
  name_column,
  value_column,
  accumulating_value,
  accumulating_value/@accumulating_value AS accumulating_value_ratio,
  2*PI()*accumulating_value/@accumulating_value AS accumulating_value_radians
FROM (
  SELECT
    name_column,
    value_column,
    @name_order := @name_order+1 AS name_order,
    @accumulating_value := @accumulating_value+value_column AS accumulating_value,
    @aggregated_name_column := CONCAT(@aggregated_name_column, name_column, ',') AS aggregated_name_column
  FROM (
    SELECT name AS name_column, value AS value_column FROM sample_values2
    ) select_values,
    (SELECT @name_order := 0) select_name_order,
    (SELECT @accumulating_value := 0) select_accumulating_value,
    (SELECT @aggregated_name_column := '') select_aggregated_name_column
  ) select_accumulating_values
;
+------------+-------------+--------------+--------------------+--------------------------+----------------------------+
| name_order | name_column | value_column | accumulating_value | accumulating_value_ratio | accumulating_value_radians |
+------------+-------------+--------------+--------------------+--------------------------+----------------------------+
|          1 | red         |            1 |                  1 |                      0.1 |           0.62831853071796 |
|          2 | blue        |            2 |                  3 |                      0.3 |            1.8849555921539 |
|          3 | orange      |            3 |                  6 |                      0.6 |            3.7699111843078 |
|          4 | white       |            4 |                 10 |                        1 |            6.2831853071796 |
+------------+-------------+--------------+--------------------+--------------------------+----------------------------+

El valor de los radianes nos ayudará a decidir dónde estará cada valor en la gráfica circular.

Parte 2: Entre bastidores de la gráfica circular

Ahora explicaremos cómo funciona la gráfica circular. Más tarde, lo combinaremos con la Parte 1, para producir la gráfica final.

Primero, generamos el sistema de coordenadas (ver Dibujos SQL):

SELECT
  GROUP_CONCAT(CONCAT(t2.value,'.',t1.value) order by t1.value separator ' ') as circle
FROM
  tinyint_asc t1,
  tinyint_asc t2,
  (select @size := 10) sel_size,
  (select @radius := (@size/2 - 1)) sel_radius
WHERE
  t1.value < @size
  AND t2.value < @size
GROUP BY t2.value
;
+-----------------------------------------+
| circle                                  |
+-----------------------------------------+
| 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 |
| 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 |
| 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 |
| 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 |
| 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 |
| 5.0 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 |
| 6.0 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 |
| 7.0 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 |
| 8.0 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9 |
| 9.0 9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 9.9 |
+-----------------------------------------+

En lo que es un gran paso adelante, calculamos el ángulo por coordenada, en relación con el centro, del sistema de coordenadas. El cálculo se hace en radianes, pero se muestra en grados para mejor legibilidad. También anotamos en qué cuadrante de la gráfica está cada punto.

SELECT
  group_concat(
    round(radians*180/PI())
    order by col_number separator ' ') as circle
FROM (
  SELECT
    t1.value AS col_number,
    t2.value AS row_number,
    @dx := (t1.value - (@size-1)/2) AS dx,
    @dy := ((@size-1)/2 - t2.value) AS dy,
    @abs_radians := IF(@dx = 0, PI()/2, (atan(abs(@dy/@dx)))) AS abs_radians,
    CASE
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) >= 0 THEN @abs_radians
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) <= 0 THEN PI()-@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) <= 0 THEN PI()+@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) >= 0 THEN 2*PI()-@abs_radians
    END AS radians
  FROM
    tinyint_asc t1,
    tinyint_asc t2,
    (select @size := 15) sel_size,
    (select @radius := (@size/2 - 1)) sel_radius
  WHERE
    t1.value < @size
    AND t2.value < @size) select_combinations
  GROUP BY row_number
;
+-------------------------------------------------------------+
| circle                                                      |
+-------------------------------------------------------------+
| 135 131 126 120 113 106 98 90 82 74 67 60 54 49 45          |
| 139 135 130 124 117 108 99 90 81 72 63 56 50 45 41          |
| 144 140 135 129 121 112 101 90 79 68 59 51 45 40 36         |
| 150 146 141 135 127 117 104 90 76 63 53 45 39 34 30         |
| 157 153 149 143 135 124 108 90 72 56 45 37 31 27 23         |
| 164 162 158 153 146 135 117 90 63 45 34 27 22 18 16         |
| 172 171 169 166 162 153 135 90 45 27 18 14 11 9 8           |
| 180 180 180 180 180 180 180 90 0 0 0 0 0 0 0                |
| 188 189 191 194 198 207 225 270 315 333 342 346 349 351 352 |
| 196 198 202 207 214 225 243 270 297 315 326 333 338 342 344 |
| 203 207 211 217 225 236 252 270 288 304 315 323 329 333 337 |
| 210 214 219 225 233 243 256 270 284 297 307 315 321 326 330 |
| 216 220 225 231 239 248 259 270 281 292 301 309 315 320 324 |
| 221 225 230 236 243 252 261 270 279 288 297 304 310 315 319 |
| 225 229 234 240 247 254 262 270 278 286 293 300 306 311 315 |
+-------------------------------------------------------------+

A esto se le necesita dar formato para una mejor presentación, pero ahora no es el objetivo; sólo lo estoy enseñando para explicar los pasos tomados.

Parte 3: combinando los dos

El siguiente paso es probablemente el más importante, vamos a presentar una tosca gráfica circular cuadrada usando los valores originales:

SELECT
  group_concat(
    (SELECT name_order FROM
      (
      SELECT
        name_order,
        name_column,
        value_column,
        accumulating_value,
        accumulating_value/@accumulating_value AS accumulating_value_ratio,
        2*PI()*accumulating_value/@accumulating_value AS accumulating_value_radians
      FROM (
        SELECT
          name_column,
          value_column,
          @name_order := @name_order+1 AS name_order,
          @accumulating_value := @accumulating_value+value_column AS accumulating_value,
          @aggregated_name_column := CONCAT(@aggregated_name_column, name_column, ',') AS aggregated_name_column
        FROM (
          SELECT name AS name_column, value AS value_column FROM sample_values2
          ) select_values,
          (SELECT @name_order := 0) select_name_order,
          (SELECT @accumulating_value := 0) select_accumulating_value,
          (SELECT @aggregated_name_column := '') select_aggregated_name_column
        ) select_accumulating_values
      ) select_for_radians
    WHERE accumulating_value_radians >= radians LIMIT 1
    )
    order by col_number separator ' ') as circle
FROM (
  SELECT
    t1.value AS col_number,
    t2.value AS row_number,
    @dx := (t1.value - (@size-1)/2) AS dx,
    @dy := ((@size-1)/2 - t2.value) AS dy,
    @abs_radians := IF(@dx = 0, PI()/2, (atan(abs(@dy/@dx)))) AS abs_radians,
    CASE
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) >= 0 THEN @abs_radians
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) <= 0 THEN PI()-@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) <= 0 THEN PI()+@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) >= 0 THEN 2*PI()-@abs_radians
    END AS radians
  FROM
    tinyint_asc t1,
    tinyint_asc t2,
    (select @size := 21) sel_size,
    (select @radius := (@size/2 - 1)) sel_radius
  WHERE
    t1.value < @size
    AND t2.value < @size) select_combinations
  GROUP BY row_number
;
+-------------------------------------------+
| circle                                    |
+-------------------------------------------+
| 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 2 2 2 2 2 2 |
| 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 2 2 2 2 2 |
| 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 2 2 2 2 2 |
| 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 2 2 2 2 1 |
| 3 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 2 2 1 1 |
| 3 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 2 1 1 1 1 |
| 3 3 3 3 3 3 3 3 3 2 2 2 2 2 2 2 1 1 1 1 1 |
| 3 3 3 3 3 3 3 3 3 3 2 2 2 2 2 1 1 1 1 1 1 |
| 3 3 3 3 3 3 3 3 3 3 2 2 2 1 1 1 1 1 1 1 1 |
| 3 3 3 3 3 3 3 3 3 3 2 2 1 1 1 1 1 1 1 1 1 |
| 3 3 3 3 3 3 3 3 3 3 2 1 1 1 1 1 1 1 1 1 1 |
| 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 |
| 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 3 3 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 3 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 3 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
| 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 |
+-------------------------------------------+

El truco SQL es que todo va dentro de la expresión GROUP_CONCAT. En vez de presentar la coordenda, miramos en la tabla de valores modificada, buscando la primera fila que tiene un ángulo mayor (en radianes) que el pixel actual. Entonces mostramos 1, 2, etc. para denotar el valor.

El siguiente paso es realmente muy simple: ¡en vez de dibujar el cuadrado completo, lo limitamos a un círculo!

SELECT
  group_concat(
    IF(round(sqrt(pow(col_number-(@size-1)/2, 2) + pow(row_number-(@size-1)/2, 2))) BETWEEN @radius/2 AND @radius,
    (SELECT name_order FROM
      (
      SELECT
        name_order,
        name_column,
        value_column,
        accumulating_value,
        accumulating_value/@accumulating_value AS accumulating_value_ratio,
        2*PI()*accumulating_value/@accumulating_value AS accumulating_value_radians
      FROM (
        SELECT
          name_column,
          value_column,
          @name_order := @name_order+1 AS name_order,
          @accumulating_value := @accumulating_value+value_column AS accumulating_value,
          @aggregated_name_column := CONCAT(@aggregated_name_column, name_column, ',') AS aggregated_name_column
        FROM (
          SELECT name AS name_column, value AS value_column FROM sample_values2
          ) select_values,
          (SELECT @name_order := 0) select_name_order,
          (SELECT @accumulating_value := 0) select_accumulating_value,
          (SELECT @aggregated_name_column := '') select_aggregated_name_column
        ) select_accumulating_values
      ) select_for_radians
    WHERE accumulating_value_radians >= radians LIMIT 1
    ), '-')
    order by col_number separator ' ') as circle
FROM (
  SELECT
    t1.value AS col_number,
    t2.value AS row_number,
    @dx := (t1.value - (@size-1)/2) AS dx,
    @dy := ((@size-1)/2 - t2.value) AS dy,
    @abs_radians := IF(@dx = 0, PI()/2, (atan(abs(@dy/@dx)))) AS abs_radians,
    CASE
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) >= 0 THEN @abs_radians
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) <= 0 THEN PI()-@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) <= 0 THEN PI()+@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) >= 0 THEN 2*PI()-@abs_radians
    END AS radians
  FROM
    tinyint_asc t1,
    tinyint_asc t2,
    (select @size := 21) sel_size,
    (select @radius := 7) sel_radius
  WHERE
    t1.value < @size
    AND t2.value < @size) select_combinations
  GROUP BY row_number
;
+-------------------------------------------+
| circle                                    |
+-------------------------------------------+
| - - - - - - - - - - - - - - - - - - - - - |
| - - - - - - - - - - - - - - - - - - - - - |
| - - - - - - - - - - - - - - - - - - - - - |
| - - - - - - - - 2 2 2 2 2 - - - - - - - - |
| - - - - - - 3 3 3 2 2 2 2 2 2 - - - - - - |
| - - - - - 3 3 3 3 2 2 2 2 2 2 2 - - - - - |
| - - - - 3 3 3 3 3 2 2 2 2 2 2 2 1 - - - - |
| - - - - 3 3 3 3 3 - - - 2 2 2 1 1 - - - - |
| - - - 3 3 3 3 3 - - - - - 1 1 1 1 1 - - - |
| - - - 3 3 3 3 - - - - - - - 1 1 1 1 - - - |
| - - - 3 3 3 3 - - - - - - - 1 1 1 1 - - - |
| - - - 3 3 3 3 - - - - - - - 4 4 4 4 - - - |
| - - - 3 3 3 3 3 - - - - - 4 4 4 4 4 - - - |
| - - - - 3 3 4 4 4 - - - 4 4 4 4 4 - - - - |
| - - - - 3 4 4 4 4 4 4 4 4 4 4 4 4 - - - - |
| - - - - - 4 4 4 4 4 4 4 4 4 4 4 - - - - - |
| - - - - - - 4 4 4 4 4 4 4 4 4 - - - - - - |
| - - - - - - - - 4 4 4 4 4 - - - - - - - - |
| - - - - - - - - - - - - - - - - - - - - - |
| - - - - - - - - - - - - - - - - - - - - - |
| - - - - - - - - - - - - - - - - - - - - - |
+-------------------------------------------+

Esto ya se parece más a una gráfica circular.

Part 4: añadiendo los detalles

Ahora (en un sólo paso) añadiremos:

• Redimensionado en el eje X.
• Eliminación de los espacios.
• Coloreado de las secciones de la gráfica.
• Una leyenda

El  texto en negrita es la consulta original, y es lo único que tendrías que cambiar para crear tus propias gráficas circulares.

SELECT
  group_concat(
    IF(round(sqrt(pow(col_number/@stretch-0.5-(@size-1)/2, 2) + pow(row_number-(@size-1)/2, 2))) BETWEEN @radius*2/3 AND @radius,
    (SELECT SUBSTRING(@colors, name_order, 1) FROM
      (
      SELECT
        name_order,
        name_column,
        value_column,
        accumulating_value,
        accumulating_value/@accumulating_value AS accumulating_value_ratio,
        @aggregated_data := CONCAT(@aggregated_data, name_column, ': ', value_column, ' (', ROUND(100*value_column/@accumulating_value), '%)', '|') AS aggregated_name_column,
        2*PI()*accumulating_value/@accumulating_value AS accumulating_value_radians
      FROM (
        SELECT
          name_column,
          value_column,
          @name_order := @name_order+1 AS name_order,
          @accumulating_value := @accumulating_value+value_column AS accumulating_value
        FROM (
          SELECT name AS name_column, value AS value_column FROM sample_values2 LIMIT 4
          ) select_values,
          (SELECT @name_order := 0) select_name_order,
          (SELECT @accumulating_value := 0) select_accumulating_value,
          (SELECT @aggregated_data := '') select_aggregated_name_column
        ) select_accumulating_values
      ) select_for_radians
    WHERE accumulating_value_radians >= radians LIMIT 1
    ), ' ')
    order by col_number separator '') as pie
FROM (
  SELECT
    t1.value AS col_number,
    t2.value AS row_number,
    @dx := (t1.value/@stretch - (@size-1)/2) AS dx,
    @dy := ((@size-1)/2 - t2.value) AS dy,
    @abs_radians := IF(@dx = 0, PI()/2, (atan(abs(@dy/@dx)))) AS abs_radians,
    CASE
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) >= 0 THEN @abs_radians
      WHEN SIGN(@dy) >= 0 AND SIGN(@dx) <= 0 THEN PI()-@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) <= 0 THEN PI()+@abs_radians
      WHEN SIGN(@dy) <= 0 AND SIGN(@dx) >= 0 THEN 2*PI()-@abs_radians
    END AS radians
  FROM
    tinyint_asc t1,
    tinyint_asc t2,
    (select @size := 23) sel_size,
    (select @radius := (@size/2 - 1)) sel_radius,
    (select @stretch := 4) sel_stretch,
    (select @colors := '#;o:X"@+-=123456789abcdef') sel_colors
  WHERE
    t1.value < @size*@stretch
    AND t2.value < @size) select_combinations
  GROUP BY row_number
UNION ALL
  SELECT
    CONCAT(
      REPEAT(SUBSTRING(@colors, value, 1), 2),
      '  ',
      SUBSTRING_INDEX(SUBSTRING_INDEX(@aggregated_data, '|', value), '|', -1)
    )
  FROM
    tinyint_asc
  WHERE
    value BETWEEN 1 AND @name_order
;
+----------------------------------------------------------------------------------------------+
| pie                                                                                          |
+----------------------------------------------------------------------------------------------+
|                                                                                              |
|                                   ;;;;;;;;;;;;;;;;;;;;;;;;;                                  |
|                          oooooooo;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                         |
|                    ooooooooooooooo;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                   |
|                oooooooooooooooooooo;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;               |
|             oooooooooooooooooooooooo                     ;;;;;;;;;;;;;;;;;;;;;###            |
|           oooooooooooooooooooo                                 ;;;;;;;;;###########          |
|         oooooooooooooooooo                                         ##################        |
|       ooooooooooooooooo                                               #################      |
|      ooooooooooooooooo                                                 #################     |
|      oooooooooooooooo                                                   ################     |
|     oooooooooooooooo                                                     ################    |
|      oooooooooooooooo                                                   ::::::::::::::::     |
|      ooooooooooooooooo                                                 :::::::::::::::::     |
|       ooooooooooooooooo                                               :::::::::::::::::      |
|         oooooooooooooo::::                                         ::::::::::::::::::        |
|           ooooooo:::::::::::::                                 ::::::::::::::::::::          |
|             ::::::::::::::::::::::::                     ::::::::::::::::::::::::            |
|                :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::               |
|                    :::::::::::::::::::::::::::::::::::::::::::::::::::::::                   |
|                          :::::::::::::::::::::::::::::::::::::::::::                         |
|                                   :::::::::::::::::::::::::                                  |
|                                                                                              |
| ##  red: 1 (10%)                                                                             |
| ;;  blue: 2 (20%)                                                                            |
| oo  orange: 3 (30%)                                                                          |
| ::  white: 4 (40%)                                                                           |
+----------------------------------------------------------------------------------------------+

Realizar la leyenda es por si mismo un truco interesante: agregar un número desconocido de filas usando una variable de sesión, para luego volverlas a separar. Por supuesto, esto sólo funciona bien si tenemos un número pequeño de filas (valores), tal y como esperábamos en nuestro caso.

Ejemplos

De acuerdo. ¿Por qué? ¡Por qué?

Aquí hay tres gráficas que espero que convenzan al lector escéptico:

Dada la base de datos sakila, lista las 8 tablas de mayor tamaño (en KB):
[NdT: la base de datos sakila se trata de una base de datos de ejemplo de MySQL]

+------------------------------------------------------------------------------+
| pie_chart                                                                    |
+------------------------------------------------------------------------------+
|                                                                              |
|                            #######################                           |
|                    #######################################                   |
|               #################################################              |
|            ##################                   ##################           |
|         ###############                               ###############        |
|        ;;###########                                     #############       |
|      ;;;;;;;;;;;;;                                         #############     |
|      ;;;;;;;;;;;;                                           ############     |
|     ;;;;;;;;;;;;;                                           #############    |
|      ;;;;;;;;;;;;                                           @@@@@@@@@@@@     |
|      ;;;;;;;;;;;;;                                         """""""""""""     |
|        ;;;;;;;;;;;;;                                     XX"""""""""""       |
|         ;;;;;;;;;;;;;;;                               XXXXXXXXXXXXX""        |
|            ;;;;;;;;;;;;;;;;;;                   ::::::::::XXXXXXXX           |
|               ;;;;;;;;;;;;;;;;;;;;;;;;;;oooooooooo::::::::::::X              |
|                    ;;;;;;;;;;;;;;;;;;;;;;ooooooooooo::::::                   |
|                            ;;;;;;;;;;;;;;ooooooooo                           |
|                                                                              |
| ##  rental: 2850816 (43%)                                                    |
| ;;  payment: 2228224 (34%)                                                   |
| oo  inventory: 376832 (6%)                                                   |
| ::  film_text: 325440 (5%)                                                   |
| XX  film: 278528 (4%)                                                        |
| ""  film_actor: 278528 (4%)                                                  |
| @@  customer: 131072 (2%)                                                    |
| ++  staff: 98304 (1%)                                                        |
+------------------------------------------------------------------------------+

¿Cuánto espacio en disco consume cada motor de base de datos (suma de los tamaños de tabla por motor)?

+------------------------------------------------------------------------------+
| pie_chart                                                                    |
+------------------------------------------------------------------------------+
|                                                                              |
|                            #######################                           |
|                    #######################################                   |
|               #################################################              |
|            ##################                   ##################           |
|         ###############                               ###############        |
|        #############                                     #############       |
|      #############                                         #############     |
|      ############                                           ############     |
|     #############                                           #############    |
|      ############                                           oooooooooooo     |
|      #############                                         ;;;;;;;;;;;oo     |
|        #############                                     ;;;;;;;;;;;;;       |
|         ###############                               ;;;;;;;;;;;;;;;        |
|            ##################                   #;;;;;;;;;;;;;;;;;           |
|               #####################################;;;;;;;;;;;;              |
|                    ###################################;;;;                   |
|                            #######################                           |
|                                                                              |
| ##  InnoDB: 1908732 (84%)                                                    |
| ;;  MyISAM: 284074 (12%)                                                     |
| oo  ARCHIVE: 84276 (4%)                                                      |
+------------------------------------------------------------------------------+

¿Cuáles han sido los tipos de sentencias DML más populares de los últimos 10 segundos?

+------------------------------------------------------------------------------+
| pie_chart                                                                    |
+------------------------------------------------------------------------------+
|                                                                              |
|                            #######################                           |
|                    #######################################                   |
|               #################################################              |
|            ##################                   ##################           |
|         ###############                               ###############        |
|        #############                                     #############       |
|      #############                                         #############     |
|      ############                                           ############     |
|     #############                                           #############    |
|      ############                                           oooo::::::::     |
|      #############                                         ooooooooooooo     |
|        #############                                     ooooooooooooo       |
|         ###############                               ooooooooooooooo        |
|            #################;                   ;;;;;;;;;ooooooooo           |
|               #############;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oo              |
|                    ######;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;                   |
|                            ;;;;;;;;;;;;;;;;;;;;;;;                           |
|                                                                              |
| ##  com_select: 1876 (69%)                                                   |
| ;;  com_insert: 514 (19%)                                                    |
| oo  com_delete: 277 (10%)                                                    |
| ::  com_update: 63 (2%)                                                      |
+------------------------------------------------------------------------------+

Conclusión

Los dibujos en ASCII siempre han parecido bastante raros; algunos dirían lo mismo sobre top, wget,  cal, etc. (¿he mencionado lynx?)

Creo que es posible hacer la mayoría de las gráficas más comunes con SQL: ya he mostrado cómo hacer gráficas horizontales y circulares. Podrían generarse también diagramas de barras. Estos métodos no están pensados como una solución permanente; pero es bueno ser capaz de visualizar algunos valores sin tener que instalar Nagios (junto con Apache, Php, drivers, etc.), o tener que exportar la tabla, copiarla a una máquina de escritorio, cargarla en OpenOffice.org Impress y generar las gráficas.

A veces simplemente necesitas echar un vistazo de manera inmediata. Esto es para lo que encuentro útil generar gráficas con SQL.

Por supuesto, Perl y Python ya tienen soluciones para esto, lo cual se hace de manera bastante fácil. Pero haciéndolo directamente desde el cliente de MySQL proporciona, en mi opinión, un mayor nivel de confianza: siempre podrás generar la gráfica, tengas perl-DBD-MySQL o no, en Linux y en Windows.

Además, ha sido divertido.

SQL no está pensado para generar gráficos, por supuesto, pero veo algunos casos en los que generar salidas no tabulares puede ser útil, tal y como mostraré en futuras entradas.

Me gustaría explicar los fundamentos del funcionamiento de los gráficos SQL: de hecho, es posible hacer todo lo que quieras.  ¿Cómo?

Sistema de coordenadas

Desarrollaremos primero un sistema de coordenadas usando SQL. Generando esto, habré probado mi tesis de que cualquier cosa es posible, y proporcionaré además una prueba de concepto.

Para empezar con la generación de coordenadas, necesitaré una tabla de ayuda: una tabla de números (tinyint_asc, por ejemplo, con números entre 0 y 255).

Intentaremos producir una matriz de coordenadas 10×10. Para hacer esto, haremos un join de la popia tabla numérica sobre sí misma (autojoin o self-join) , y utilizaremos una variable para establecer el tamaño de la matriz.

SELECT
  *
FROM
  tinyint_asc numbers1,
  tinyint_asc numbers2,
  (select @size := 10) sel_size
WHERE
  numbers1.value < @size
  AND numbers2.value < @size
;
+-------+-------+-------------+
| value | value | @size := 10 |
+-------+-------+-------------+
|     0 |     0 |          10 |
|     1 |     0 |          10 |
|     2 |     0 |          10 |
|     3 |     0 |          10 |
|     4 |     0 |          10 |
|     5 |     0 |          10 |
|     6 |     0 |          10 |
|     7 |     0 |          10 |
|     8 |     0 |          10 |
|     9 |     0 |          10 |
|     0 |     1 |          10 |
|     1 |     1 |          10 |
|     2 |     1 |          10 |
|     3 |     1 |          10 |
|     4 |     1 |          10 |
|     5 |     1 |          10 |
|     6 |     1 |          10 |
...
|     7 |     8 |          10 |
|     8 |     8 |          10 |
|     9 |     8 |          10 |
|     0 |     9 |          10 |
|     1 |     9 |          10 |
|     2 |     9 |          10 |
|     3 |     9 |          10 |
|     4 |     9 |          10 |
|     5 |     9 |          10 |
|     6 |     9 |          10 |
|     7 |     9 |          10 |
|     8 |     9 |          10 |
|     9 |     9 |          10 |
+-------+-------+-------------+

El siguiente paso será presentar las coordenadas de una manera ligeramente distinta (esto es sólo para visualizarlo de manera gráfica):

SELECT
  CONCAT(numbers2.value, '.', numbers1.value)
FROM
  tinyint_asc numbers1,
  tinyint_asc numbers2,
  (select @size := 10) sel_size
WHERE
  numbers1.value < @size
  AND numbers2.value < @size
;
+---------------------------------------------+
| CONCAT(numbers2.value, '.', numbers1.value) |
+---------------------------------------------+
| 0.0                                         |
| 0.1                                         |
| 0.2                                         |
| 0.3                                         |
| 0.4                                         |
| 0.5                                         |
| 0.6                                         |
| 0.7                                         |
| 0.8                                         |
| 0.9                                         |
| 1.0                                         |
| 1.1                                         |
| 1.2                                         |
| 1.3                                         |
| 1.4                                         |
| 1.5                                         |
| 1.6                                         |
| 1.7                                         |
...

Ya es hora de convertir esto en un sistema de coordenadas:

SELECT
  GROUP_CONCAT(
    CONCAT(numbers2.value, '.', numbers1.value)
    ORDER BY numbers1.value
    SEPARATOR ' ') AS coordinates
FROM
  tinyint_asc numbers1,
  tinyint_asc numbers2,
  (select @size := 10) sel_size
WHERE
  numbers1.value < @size
  AND numbers2.value < @size
GROUP BY numbers2.value
;
+-----------------------------------------+
| coordinates                             |
+-----------------------------------------+
| 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 |
| 1.0 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 |
| 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 |
| 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 |
| 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 |
| 5.0 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 |
| 6.0 6.1 6.2 6.3 6.4 6.5 6.6 6.7 6.8 6.9 |
| 7.0 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 |
| 8.0 8.1 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9 |
| 9.0 9.1 9.2 9.3 9.4 9.5 9.6 9.7 9.8 9.9 |
+-----------------------------------------+

Esto es todo lo que necesitamos para generar cualquier gráfico que queramos. Usa tu función matemática favorita, aplica la geometría analítica y haz que suceda. En vez de mostrar las coordenadas, úsalas para decidir lo que debería ser mostrado.

Prueba de concepto

Para demostrar que la frase anterior es realmente sencilla, mostraré cómo dibujar un círculo usando las coordendas SQL. La famosa fórmula del círculo es:

(x-x0)² + (y-y0)² = rad²

siendo x0, y0 las coordendas del centro del círculo y rad, el radio.

Para aplicarla:

SELECT
  GROUP_CONCAT(
    IF(
      ROUND(SQRT(POW(numbers1.value-(@size-1)/2, 2) + POW(numbers2.value-(@size-1)/2, 2))) <= @radius,
      '#', '-')
    ORDER BY numbers1.value
    SEPARATOR ' ') AS circle
FROM
  tinyint_asc numbers1,
  tinyint_asc numbers2,
  (select @size := 15) sel_size,
  (select @radius := 6) sel_radius
WHERE
  numbers1.value < @size
  AND numbers2.value < @size
GROUP BY numbers2.value
;
+-------------------------------+
| circle                        |
+-------------------------------+
| - - - - - - - - - - - - - - - |
| - - - - - # # # # # - - - - - |
| - - - # # # # # # # # # - - - |
| - - # # # # # # # # # # # - - |
| - - # # # # # # # # # # # - - |
| - # # # # # # # # # # # # # - |
| - # # # # # # # # # # # # # - |
| - # # # # # # # # # # # # # - |
| - # # # # # # # # # # # # # - |
| - # # # # # # # # # # # # # - |
| - - # # # # # # # # # # # - - |
| - - # # # # # # # # # # # - - |
| - - - # # # # # # # # # - - - |
| - - - - - # # # # # - - - - - |
| - - - - - - - - - - - - - - - |
+-------------------------------+

¡Elimina el espacio separador, juega con el ratio, aplica tu propia fórmula y genera dibujos SQL-ascii!

Si no tenemos cuidado, podemos encontrarnos con una desagradable sorpresa en forma de caracteres extraños.

Cualquier persona que comienza a manejar una base de datos suele encontrarse con problemas a la hora de manejar literales de cadena. Si no se pone el debido cuidado, podemos encontrarnos con errores causados por la utilización o conversión de codificaciones de caracteres. Intentaremos dar una pequeña guía para aclarar cómo manejar los distintos ‘encodings’ y ‘collations’ en una base de datos MySQL.

Conceptos básicos

Definamos, antes de nada, conceptos:

Juego de caracteres, character set o “charset”

Se trata de un subconjunto definido de símbolos de texto. El más ambicioso de todos ellos es UCS (Universal Character Set), el cual permite representar más de 1 millón de símbolos de forma no ambigua (asignándoles un nombre y número diferente a cada uno), aunque en la práctica apenas se usan más de 65.000.

Codificación de caracteres o (character) encoding

Es el algoritmo o la tabla que identifica cada símbolo del juego de caracteres con un valor binario, es decir, indica cómo se almacena de manera digital. Por ejemplo, UCS-2 y UTF-8 son encodings para el mismo juego de caracteres (UCS) [1], pero la forma de asignarlos varía en cada uno. Mientras que en UTF-8 la representación del caracter puede ocupar entre 1 y 4 bytes [2], en UCS-2, el tamaño es fijo, de 2 bytes.
Veamos esto de forma práctica: Creemos una tabla con tres encodings diferentes: UTF-8, UCS-2 y ASCII:

mysql> CREATE TABLE `encoding` (
    -> `utf8` char(1) character set utf8 default NULL,
    -> `ucs2` char(1) character set ucs2 default NULL,
    -> `ascii` char(1) character set ascii default NULL
    -> );

Insertamos los caracteres ‘a’ y ‘ñ’:

mysql> INSERT INTO encoding VALUES ('a', 'a', 'a');
Query OK, 1 row affected (0.00 sec)

mysql> INSERT INTO encoding VALUES ('ñ', 'ñ', 'ñ');
Query OK, 1 row affected, 1 warning (0.00 sec)

Y vemos cómo están guardados en disco realmente:

mysql> SELECT utf8 AS `char`, hex(utf8) AS `utf8`, hex(ucs2) AS `ucs2`, hex(ascii) AS `ascii` FROM encoding;
+------+------+------+-------+
| char | utf8 | ucs2 | ascii |
+------+------+------+-------+
| a    | 61   | 0061 | 61    |
| ñ    | C3B1 | 00F1 | 3F    |
+------+------+------+-------+
2 rows in set (0.00 sec)

Como se puede ver, UTF-8 tiene la ventaja de que para la mayoría de caracteres usados en inglés coincide con la codificación ASCII. Sin embargo, para el resto de caracteres, requiere dos o más bytes [3]).

Algunos de los encodings más usuales son:

• ASCII o US-ASCII: encoding histórico de 7 bits (aunque existen los denominados encodings “ASCII extendidos” que aumentaban el numero de caracteres a 8 bits)
• ISO 8859-1 o Latin 1: utilizaba 1 byte y, siendo compatible con ASCII, incluía símbolos adicionales para la mayoría de idiomas occidentales (incluyendo la ñ, los acentos y la ‘ç’).
• ISO 8859-15 o Latin 9: es una revisión de Latin 1, que añade, entre otros, el símbolo del euro.
• windows-1252: versión ligeramente distinta a Latin 1/9 que utilizaban los sistemas operativos Windows
• UTF-8: encoding de la norma Unicode que, siendo compatible con los caracteres ASCII originales, permite reprentar los caracteres de casi cualquier lengua [4] de manera eficiente (sólo requiere más de 1 byte para caracteres fuera de ASCII)
• UTF-16: también de la norma unicode, sólo que requiere siempre 2 bytes para todos los caracteres UCS básicos. Es lo más eficiente si usamos muchos caracteres CJK (chinos, japoneses o koreanos). Se diferencia de UCS-2 en que éste último no podía representar caracteres más allá del número 65.536.

Collation u ordenación

Es el algoritmo que indica si dos caracteres son equivalentes, o si uno debería ir antes o después en una ordenación. Por ejemplo, en español, si nosotros tuviéramos la siguiente tabla y valores:

mysql> CREATE TABLE `collation` (`a` char(20) character set utf8 collate utf8_spanish_ci);
mysql> INSERT INTO `collation` VALUES ('amapola');
mysql> INSERT INTO `collation` VALUES ('Andorra');
mysql> INSERT INTO `collation` VALUES ('Ávila');
mysql> INSERT INTO `collation` VALUES ('ábaco');
mysql> INSERT INTO `collation` VALUES ('burro');

y ejecutáramos la sentencia que nos permite obtener estos valores de manera ordenada, obtendríamos:

mysql> SELECT * FROM `collation` ORDER BY a;
+---------+
| a       |
+---------+
| ábaco   |
| amapola |
| Andorra |
| Ávila   |
| burro   |
+---------+
5 rows in set (0.00 sec)

o si preguntáramos por cuales de las palabras empiezan por a, obtenemos:

mysql> SELECT * FROM `collation` WHERE a LIKE 'a%';
+---------+
| a       |
+---------+
| amapola |
| Andorra |
| Ávila   |
| ábaco   |
+---------+
4 rows in set (0.02 sec)

Es decir, asume que a == A == á == Á

Esto es así porque, por defecto, el “collate” que se le hemos indicado es utf8_spanish_ci. Podemos forzar que use otro algoritmo de ordenamiento de la siguiente manera:

mysql> SELECT a FROM `collation`ORDER BY a COLLATE utf8_bin;
+---------+
| a       |
+---------+
| Andorra |
| amapola |
| burro   |
| Ávila   |
| ábaco   |
+---------+
5 rows in set (0.00 sec)

mysql> SELECT * FROM `collation` WHERE a LIKE 'a%' COLLATE utf8_bin;
+---------+
| a       |
+---------+
| amapola |
+---------+
1 row in set (0.00 sec)

Lo cual le indica que utilice exclusivamente para comparaciones el valor binario de su codificación UTF-8.

Aplicación

Una vez que ya conocemos los conceptos básicos alrededor de las codificación, vamos a ver cómo los utilizamos en una base de datos.

Existen tres lugares, a distinto nivel, donde podemos configurar el encoding que estamos utilizando para distintas tareas:

• Variables de sesión
• Variables globales
• Schemas
• Aplicación final cliente

La diferencia entre variables globales y de sesión es que las globales se configuran a nivel de servidor y son las que establecen el valor por defecto de las variables de sesión, las cuales pueden modificarse desde el cliente para cada conexión. Las variables de sesión se configuran por conexión, y sólo son válidas mientras ésta esté activa. Si existen variables de sesión y globales con el mismo nombre, las de sesión tienen precedencia.

También podemos asignar encodings y collations a bases de datos, tablas y columnas de manera independiente.

Por último, y aunque no lo trataremos aquí, debemos asegurarnos de que la aplicación que finalmente muestra los resultados lo hace en la misma codificación que hemos recibido los datos. Por ejemplo, si estamos en una sesión con mysql-cliente, tendremos que cambiar la codificación de salida del terminal de manera adecuada.

Veámos más en profundidad a qué afecta y cómo modificarlas en cada nivel.

Variables

Son las siguientes:

mysql> show session variables like '%character\_set\_%';
+--------------------------+--------+
| Variable_name            | Value  |
+--------------------------+--------+
| character_set_client     | utf8   |
| character_set_connection | utf8   |
| character_set_database   | utf8   |
| character_set_filesystem | binary |
| character_set_results    | utf8   |
| character_set_server     | utf8   |
| character_set_system     | utf8   |
+--------------------------+--------+
7 rows in set (0.00 sec)

mysql> show variables like '%collation\_%';
+----------------------+-----------------+
| Variable_name        | Value           |
+----------------------+-----------------+
| collation_connection | utf8_general_ci |
| collation_database   | utf8_general_ci |
| collation_server     | utf8_general_ci |
+----------------------+-----------------+
3 rows in set (0.00 sec)

• character_set_client
  Es el encoding en el que el servidor asume que le envías los datos. Por defecto es latin1.
• character_set_connection y collation_connection
  character_set_connection es el encoding al que convierte los comandos enviados por el cliente (desde el encoding definido por character_set_client). Por defecto es latin1. collation_connection es el ordenamiento que asume para los literales enviados por el cliente. Es ignorado cuando se trabaja con columnas de tablas, ya que éstos ya tienen definida un “collate” propio, el cual tiene prioridad sobre el de la conexión. Como la collation por defecto de latin1 es latin1_swedish_ci, éste es el valor que toma por defecto.
• character_set_results
  Es el encoding al que el servidor convierte los resultados y mensajes de error antes de enviarlos al cliente
• character_set_server y collation_server
  Es el encoding y collation que usa el servidor por defecto (si no los cambiamos: latin1/latin1_swedish_ci).
• character_set_database y collation_database
  Es el encoding/collation del schema que está en uso actualmente. El servidor la actualiza cada vez que cambiamos la base de datos actual. Podemos cambiarla, pero eso no cambia el encoding por defecto de la base de datos actual. Sus valores por defecto (no tenemos una base de datos selecionada) son los mismos que character_set_server y collation_server (latin1/latin1_swedish_ci, si no los hemos cambiado).
• character_set_system
  Es el encoding interno usado para los identificadores. Siempre es utf8 (es de sólo lectura).
• character_set_filesystem
  Es el encoding al que convierte (desde character_set_client para) los nombres de archivo usados en sentencias SELECT…INTO OUTFILE o LOAD DATA INFILE. Por defecto es binary, con el que no se hace ninguna conversión.

Alterando las opciones de sesión y globales

Podemos establecer los siguientes valores para alterar el comportamiento por defecto:

character_set_client
character_set_connection
character_set_filesystem
character_set_results
character_set_server

Podemos hacerlo de varias manera:

• Cambiar la variable de sesión en caliente, desde un cliente mysql

SET LOCAL character_set_client='utf8';
SET @@local.character_set_client='utf8';

Es la opción adecuada si sólo queremos que tenga efecto para la sesión actual. No se mantiene entre sesiones, ni siquiera para el mismo usuario.

• Cambiar la variable global en caliente, desde un cliente mysql:

SET GLOBAL character_set_client='utf8';
SET @@global.character_set_client='utf8';

Todas las nuevas conexiones tendrán ese valor por defecto. Tiene el inconveniente de que al reiniciar el servidor, los cambios se perderán.

• SET NAMES  / SET CHARACTER SET

Una forma alternativa -más corta- de cambiar estas variables es utilizando:

SET NAMES 'x';

Lo cual es equivalente a hacer:

SET character_set_client = 'x';
SET character_set_results = 'x';
SET character_set_connection = 'x';

O bien, de forma muy parecida:

SET CHARACTER SET 'x';

Lo cual es equivalente a hacer:

SET character_set_client = 'x';
SET character_set_results = 'x';
SET character_set_connection = @@collation_database;

• Añadir la opción al ejecutar mysqld/mysqld_safe

mysqld --character_set_client='utf8'

Es necesario hacerlo manualmente (o con algún script) cada vez que iniciemos el servidor.

• Recompilar el servidor para que por defecto tome un encoding distinto

Es muy engorroso sólo para poner una opción

• Añadir la opción a my.cf o my.ini:

[mysqld]
character_set_client='utf8'

Es la opción recomendada si queremos que el cambio sea persistente.

Para ver los valores que pueden tomar estas varaibles disponibles, podemos ejecutar:

SHOW CHARACTER SET [LIKE 'pattern']

Schemas

Podemos cambiar también cómo se guardan los datos en las tablas de la siguiente manera:

CREATE DATABASE ... DEFAULT CHARACTER SET 'X' COLLATE 'Y' [5]
ALTER DATABASE ... DEFAULT CHARACTER SET 'X' COLLATE 'Y'

Establece el encoding y collation por defecto para esa base de datos. El cambiarla no altera automáticamente las tablas y columnas dentro de esa base de datos, sino sólo de las que creemos por defecto (sin explicitarlo) a partir de ahora. Por defecto utiliza character_set_server.

CREATE TABLE ... DEFAULT CHARACTER SET 'X' COLLATE 'Y'
ALTER TABLE ... DEFAULT CHARACTER SET 'X' COLLATE 'Y'

Establece el encoding y collation por defecto para esa tabla. El cambiarla no altera automáticamente columnas dentro de esa base de datos, sino sólo de las que creemos por defecto (sin explicitarlo) a partir de ahora. Por defecto utiliza el character set de la base de datos a la que pertenece (no de la base de datos actual).

ALTER TABLE ADD COLUMN ... DEFAULT CHARACTER SET 'X' COLLATE 'Y'
ALTER TABLE ADD MODIFY ... DEFAULT CHARACTER SET 'X' COLLATE 'Y'
ALTER TABLE ADD CHANGE ... DEFAULT CHARACTER SET 'X' COLLATE 'Y'

Establece el encoding y collation que tendrá realmente la columna. Por defecto utiliza el character set de la tabla a la que pertenece.

Más información

• http://dev.mysql.com/doc/refman/5.0/en/charset-syntax.html
• http://dev.mysql.com/doc/refman/5.0/en/server-system-variables.html
• http://dev.mysql.com/doc/refman/5.0/en/charset-connection.html
• http://en.wikipedia.org/wiki/Character_encoding
• http://en.wikipedia.org/wiki/Unicode

Notas

1. UCS-2 no permite, siendo estrictos, representar todos los caracteres UCS usados actualmente, por lo que tiende a reemplazarse por UTF-16
2. MySQL sólo permite caracteres multibyte UTF-8 de hasta 3 caracteres, lo cual es suficiente para los caracteres que se usan en la práctica
3. Es necesario remarcar que tenemos dos funciones en MySQL para ver el tamaño de una cadena: lenght(), que es el tamaño en bytes y char_lenght(), que es el tamaño en caracteres. Ambos pueden diferir.
4. Se propuso la adición de los caracteres Klingon a UCS, pero finalmente fue rechazado
5. Una sintaxis equivalente, pero más corta para poner un determinado encoding es:

   CREATE DATABASE ... CHARSET 'X'

Pero, ¿cuál es la penetración real de Internet en tu barrio? A partir de un comentario que hizo Golo en la barbacoa del sábado sobre geolocalización a partir de redes WIFI, se me ha ocurrido probar un programa llamado Kismet. He salido esta tarde a dar un paseo cargado con mi AsusEEE y la antena GPS, ambos encendidos, y he dado unas vueltas por un parque cercano.

El resultado de este pequeño experimento es el siguiente:

Mapa Wireless

Cada círculo de color corresponde a la posición aproximada de un “Access Point” o router wifi, y el tamaño del mismo es su cobertura calculada. Para construirlo, se han registrado varias lecturas de intensidad de las redes (algo completamente legal, ya que se trata de un rango de frecuencias no regulado) y se han renderizado sobre un mapa de OpenStreetMap. En total se han detectado casi 300 redes WIFI (sólo algunas de ellas se han podido representar), y eso que sólo di una vuelta a la manzana. Si a alguien le interesa el proceso, puedo escribir un nuevo post explicando cómo lo he hecho, con más detalle.

Luego la respuesta es que sí, parece que, pese a tener la banda ancha más cara de Europa, ésta ha llegado al hogar de manera considerable.

Google Maps no está mal, pero tiene los siguientes inconvenientes:

1. Sus términos de uso prohíben explícitamente estas prácticas
2. Los datos de Teleatlas (usados por el callejero de Google) dan mucha penita a veces (mirad dónde han puesto la Alameda Cervantes, en Soria, o la pinta que tiene la Plaza del Pilar de Zaragoza). Además, se centran mucho en información útil para automóviles y poco o nada en peatones y bicicletas
3. Sólo ofrecen públicamente imágenes (“tiles”) de los mapas, no los datos originales vectoriales. Eso hace imposible el crear rutas sin estar conectado a internet.

Así que decidí probar Navit, un programa de navegación GPS libre que permite utilizar los datos de OpenStreetMap para mostar mapas y calcular rutas. Aunque está todavía en desarrollo y hay cosas que no funcionan muy bien, tiene todo lo que yo quería: mostrar mapas vectoriales, buscar direcciones y calcular rutas.

Primer paso: descargar e instalar el programa. En Debian es muy fácil, ya que existe un repositorio:

# navit repository
deb http://navit.latouche.info/debian lenny main

Que simplemente tenmos que añadir a nuestro /etc/apt/sources.list, seguido del clásico:

$ sudo aptitude update
$ sudo aptitude install navit

Paso 2: conectar el GPS Buetooth al EeePC. Es necesario activar el Bluetooth desde la BIOS (todavía no he encontrado la manera de desactivarlo/activarlo desde el sistema operativo). También necesitaremos tener instaladas las utilidades para gestionar el GPS y la conexión inalámbrica, principalmente bluez-utils y gpsd. Después, emparejaremos la antena bluetooth a nuestro dispositivo y finalmente configuraremos el demonio de GPS para que utilice esta señal:

$ sudo aptitude install gpsd bluez-utils # instalacion de paquetes
$ sudo hcitool dev # permite ver los dispositivos BT
Devices:
        hci0    00:11:22:33:44:55
$ sudo hciconfig hci0 up # levanta el interfaz bluetooth
$ sudo hcitool scan # permite ver los dispositivos al alcance
Scanning ...
        00:99:88:77:66:55       BT GPS # <- este es el GPS

Editamos el archivo /etc/bluetooth/rfcomm.conf y lo rellenamos con la dirección hardware que hemos obtenido en el paso anterior:

#
# RFCOMM configuration file.
#

rfcomm0 {
        # Automatically bind the device at startup
        bind no;

        # Bluetooth address of the device
        device 00:99:88:77:66:55;

        # RFCOMM channel for the connection
        channel 1;

        # Description of the connection
        comment "Antena GPS Bluetooth";
}

Lo vinculamos:

$ sudo rfcomm bind rfcomm0

Y ahora lo configuramos para que lo reconozca gpsd, ejecutando:

$ sudo dpkg-reconfigure gpsd

Y escribiendo /dev/rfcomm0 cuando pregunte por el dispositivo.
Podemos comprobar que funciona así:

$ telnet localhost 2947
r # escribir r + intro
$GPGSA,A,1,,,,,,,,,,,,,,,*1E
$GPRMC,132515.936,V,XXXXX,N,XXXXXX,W,0.00,0.00,060309,,,N*6C
$GPVTG,0.00,T,,M,0.00,N,0.00,K,N*32
$GPRMC,132515.936,V,XXXXX,N,XXXXXX,W,0.00,0.00,060309,,,N*6C
$GPGSV,1,1,01,23,,,19*71
[...]

Paso 3: descargar los mapas y programa

Por alguna razón, ejecutar navit sin configurar antes GPS y mapas hace que este falle. Los mapas que utiliza navit (.bin) pueden obtenerse a partir de archivos de datos de  OpenStreetMap (.osm) -existe una utilidad online que lo hace automáticamente- o bien descargarse directamente ya convertidos al formato binario de Navit desde sitios como Cloudmade. Yo he optado por esto último y he bajado el archivo spain.navit.bin.zip (que tiene todos los datos de España), lo he descomprimido y lo he guardado en la memoria flash del EEE.

Por último, he editado el archivo /etc/navit/navit.xml para que lo use:

<!-- Mapset template for openstreetmaps -->
<mapset enabled="yes">
    <map type="binfile" enabled="yes" data="/home/jynus/osm/spain.navit.bin"/>
</mapset>

¡Y ya está! Ejecutamos navit y estas son algunas de las capturas de pantalla que he obtenido navegando por Zaragoza:

De Tenor Fleta a Sagasta

Navegando por la Plaza Paraíso

$ sudo echo test > /etc/deleteme
bash: /etc/deleteme: Permiso denegado

¿Cómo? ¿Pero sudo no proporciona privilegios de superusuario cuando se ejecutan comandos?

Sí, pero es necesario comprender bien el funcionamiento de una shell para ver lo que está pasando: sudo trata (salvo opciones) todo lo que viene a continuación como un comando; sin embargo es el programa intérprete de órdenes (bash o aquél que estemos ejecutando en ese momento) el que gestiona previamente las redirecciones de las salidas y entradas como ">", "2>", "<" o "|". Debemos, por tanto, evitar que nuestra shell las trate antes de ejecutar el sudo.

Por supuesto,  hacer un sudo su[-c], nos libraría de estos problemas, pero no es nada elegante y le quita toda la razón de ser a utilizar sudo. Para evitarlo tenemos varias opciones:

$ sudo sh -c 'echo "test" > /etc/deleteme'
$ echo test | sudo tee /etc/deleteme
test

(Éste último permite, adicionalmente, escribir al fichero y visualizar la salida simultáneamente).

¿Alguien sugiere más maneras?

Dibujo inspirado en OSM. Creative Commons (¿?). Autor: Constantin Litvak

¿Qué es OpenStreetMap?

Para los que no lo conozcan, el proyecto OSM es algo así como la Wikipedia de los mapas. Se trata de una iniciativa colaborativa a través de internet para recoger, crear y difundir información geográfica libre. En España se empezó relativamente poco a generar mapas (los ingleses y alemanes nos llevan mucha ventaja), pero aún así puede echarse un vistazo a lo que se lleva ya hecho en la página www.openstreetmap.org. Mucha gente se pregunta qué sentido tiene hacer algo que ya está disponible gratuitamente en Google Maps. La razón es que, pese a ser gratis, ese tipo de servicios ponen trabas a la forma en que puedes usar la información geográfica (no puedes, por ejemplo, modificar las imágenes para arreglar errores). Como se suele decir: Free as in freedom, not as in free beer.

¿Qué es lo que se pretendía hacer en Soria?

El generar datos para crear el plano de todo el mundo (entre nosotros, informalmente, “mapear”) no es una actividad que se haga siempre en solitario. De vez en cuando, se queda en un determinado lugar para socializar, y de paso completar un hueco que falte en los datos. Aprovechando que se celebran los dos años aproximadamente desde las primeras iniciativas de OSM en España, se decidió quedar en Soria y hacer una “mapping party” nacional (el año pasado fue en Zaragoza).

Además, y como gran novedad, se ha aprovechado que hemos confluido algunos de los voluntarios más activos para crear una asociación (con el “original” nombre de “OpenStreetMap España”), federada de la fundación internacional que ya existe, con el ánimo de que se transforme en un ente oficial para ayudar al proyecto a conseguir sus objetivos (contactar con instituciones públicas, coordinación, etc.).

¿Qué es lo que finalmente se ha hecho?

Se han firmado los estatutos y elegido los cargos (¡Iván for president! ), se han hablado de los próximos objetivos (¡trunks are red! ). Se ha socializado alrededor de unas cuantas cervezas. E, incluso, ha habido tiempo para hacer un poco de mapping. Lo cierto es que no había mucho que hacer en Soria. Y es que desde que se propuso el lugar hasta esta semana muchos otros contribuidores ya habían dibujado buena parte de las calles y carreteras de la ciudad castellano-leonesa. La buena (y mala) noticia es que el mapa nunca está completo, por lo que siempre hay cosas que añadir y que mejorar en el mapa.

Celso ha escrito un resumen detallado de las actividades que llevamos a cabo durante estos tres días.

Por último, animaros desde aquí, si estáis interesados, a conocer más cosas sobre el proyecto pasándoos por el wiki o la lista de correo.

[*] Desde que lo escribí hasta que lo publiqué, han pasado ya dos días

Logo de Warp Networks S.L.

Empecé el martes, y ya se puede decir oficialmente que soy un Warper de pleno derecho. La empresa, creada inicialmente por varios ex-compañeros de la carrera, se dedica principalmente al desarrollo de proyectos de software relacionados con tecnologías “Open Source”. Actualmente ha crecido hasta convertirse en uno de los referentes aragoneses y españoles en nuevas tecnologías, teniendo como clientes administraciones públicas y empresas privadas tanto a nivel nacional como internacional.

En concreto, yo no trabajaré en el departamento de ingeniería, sino en el de formación, como instructor MySQL. Y es que Warp Networks S.L. es uno de los dos únicos partnes españoles de formación MySQL.

De momento, la experiencia está siendo muy positiva, sobre todo por el buen rollo que se respira dentro de la oficina, principalmente por el trato con mis compañeros. He descubierto que la profesionalidad  con que se trabaja (y todos mis compañeros son grandes profesionales) no está reñida con un trato desenfadado.

Tú quizá todavía estés a tiempo de convertirte también en un Warper…

jynus@clonmel2:~> cat ~/bin/resize.sh
#!/bin/sh
SIZE=1280
QUALITY=90

for FILE in "$@"; do
   convert "$FILE" -quality $QUALITY -resize 1280x1280\> \
"`dirname "$FILE"`/${SIZE}px-`basename "${FILE%.[^.]*}"`.jpg"
done

Sin embargo, podemos facilitarnos la vida aún más añadiendo esta utilidad a los menús contextuales en Konqueror y Dolphin, que aparecen al pulsar con el botón derecho > submenú acciones, para hacer más accesible la ejecución de ciertas tareas sobre determinados tipos de archivo. Para ello debemos crear una nueva entrada en los denominados “ServiceMenus”. Es relativamente fácil: para definir una nueva acción, tenemos que generar un archivo de extensión .desktop en el directorio ServiceMenus que se encuentrará en:

/usr/share/kde4/services/ (para todos los usuarios)
~/.kde4/share/kde4/services/ (sólo para el usuario actual)

El lugar exacto puede variar ligeramente entre distribuciones (ejecutar kde4-config --path services para averiguar el lugar exacto). Si dicho directorio no existe, lo cual ocurrirá el caso de utilizar el directorio de usuario, tendremos que crearlo nosotros mismos.
Este archivo tendrá la siguiente pinta (se pueden definir más de una acción por archivo), que explicaré poco a poco:

jynus@clonmel2:~> cat /usr/share/kde4/services/ServiceMenus/resize.desktop
[Desktop Entry]
Encoding=UTF-8
ServiceTypes=KonqPopupMenu/Plugin,image/*
Type=Service
Actions=resizeImages;
TryExec=convert

[Desktop Action resizeImages]
Name=Redimensionar
Icon=image-jpeg
Exec=/home/jynus/bin/resize.sh %F

“ServiceTypes=” define sobre qué tipo de archivos vamos a poder realizar la acción (tipo mime). Por ejemplo, para vídeos sería video/*; para vídeos en formato avi, video/x-msvideo, etc. Para casos especiales como “todos los archivos UNIX” (incluido dispositivos, pipes, etc.), sería all/all, para los archivos “normales”, all/allfiles y para los directorios, inode/directory.
“Actions=” marca, separados por punto y coma, los nombres de las acciones que definiremos a continuación. En este caso sólo definiremos una, denominada resizeImages.
En la definición de la acción, le asignaremos un nombre (que será el que aparezca en el menú contextual), un icono ver los disponibles en /usr/share/icons/default.kde4/*/actions/ y el comando que finalmente se ejecutará. En esta orden, podremos indicar mediante %f o %F, respectivamente, el archivo o conjunto de varios archivos (si el comando acepta varios parámetros) sobre los cuales se aplica esta función. En nuestro caso, tan sólo llamamos al script que mostrábamos antes para obtener el resultado final:

Servicemenus

A más de uno le sonará, aunque sólo sea por su aparición en los logs de programas gráficos como K3B o GnomeBaker, las utilidades cdrecord o growisofs, las cuales aparecen en la mayoría de guías similares a ésta. Lo que muchos quizá no sepáis es que estas utilidades han sido sustituidas por varios forks, aunque afortunadamente de parámetros similares y funcionalidades superiores (además, suele venir instalado paquetes de compatibilidad que crean enlaces simbólicos desde las antiguas nomenclaturas):

jynus@clonmel2:~> ls -la `which cdrecord`
lrwxrwxrwx 1 root root 5 dic 16 20:24 /usr/bin/cdrecord -> wodim

Empecemos: los paquetes necesarios, que suelen estar preinstalados por defecto por las distribuciones son:

wodim genisoimage icedax

Mediante el comando siguiente comando veremos cuáles son los dispositivos de grabación disponibles (olvidaros del anticuado -scanbus y la utilización de ids SCSI):

jynus@clonmel2:~> wodim --devices
wodim: Overview of accessible drives (1 found) :
-------------------------------------------------------------------------
 0  dev='/dev/scd0'     rwrw-- : 'HL-DT-ST' 'DVD-ROM GDRH20N'
-------------------------------------------------------------------------

Generar una imagen iso:

jynus@clonmel2:~> genisoimage -l -R -J -o nombre_de_la_imagen.iso /ruta/a/grabar

Con estos parámetros por defecto, seguirá enlaces simbólicos y generará extensiones Rockridge y Jouliet, lo cual permite relajar las restricciones restricciones en cuanto a nombres de archivo y directorios en sistemas que permiten nombres largos, como Windows y Linux.

Puede probarse la imagen generada antes de ser grabada haciendo:

jynus@clonmel2:~> sudo mount -o loop nombre_de_la_imagen.iso /mnt

Grabar la imagen generada:

jynus@clonmel2:~> wodim -v -eject dev=/dev/scd0 nombre_de_la_imagen.iso

Detectará automáticamente la velocidad más adecuada para grabar el CD, aunque podemos forzar una velocidad con el parámetro -speed=16, por ejemplo

Ambos comandos (generación de imagen y grabación de CD) pueden, por supuesto, concatenarse para hacer la grabación “al vuelo”):

jynus@clonmel2:~> genisoimage -l -R -J -o nombre_de_la_imagen.iso /ruta/a/grabar \
| wodim -v -eject dev=/dev/scd0 -

Borrar un medio regrabable:

jynus@clonmel2:~> wodim -v dev=/dev/scd0 blank=fast

Copiar un disco:

jynus@clonmel2:~> dd if=/dev/cdrom of=nombre_de_la_imagen.iso
jynus@clonmel2:~> wodim -v -eject dev=/dev/scd0 nombre_de_la_imagen.iso

Extraer las pistas y grabar un disco de audio:

jynus@clonmel2:~> icedax -B -D /dev/cdrom -L 1
jynus@clonmel2:~> wodim -v -eject dev=/dev/scd0 -audio audio_*.wav