/var/log/jynus » MySQL

Gráficas circulares SQL

jynus — Sat, 15 Aug 2009 11:50:19 +0000

Este es el segundo post de creación de gráficos con SQL de Shlomi Noach. Puedes leer también el original en inglés en su blog y mi post anterior.

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.

Dibujos SQL

jynus — Sat, 15 Aug 2009 10:08:22 +0000

Shlomi Noach es también un Instructor, desarrollador y DBA Certificado de MySQL, que vive en Israel. Le he pedido permiso para traducir al español algunas de sus entradas acerca de maneras creativas de usar SQL que leí a través del Planet MySQL. Éste es el primer post de la serie. Podéis leer la entrada original en inglés en su blog.

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!

MySQL y los dichosos “encodings”

jynus — Fri, 22 May 2009 12:53:30 +0000

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

Notas

UCS-2 no permite, siendo estrictos, representar todos los caracteres UCS usados actualmente, por lo que tiende a reemplazarse por UTF-16
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
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.
Se propuso la adición de los caracteres Klingon a UCS, pero finalmente fue rechazado
Una sintaxis equivalente, pero más corta para poner un determinado encoding es:
```
CREATE DATABASE ... CHARSET 'X'
```