MySQL Tutorial
MySQL

VERSION()

Cada versión de MySQL introduce funcionalidades nuevas, corrige comportamientos y, en ocasiones, depreca características que antes eran habituales. Conocer la versión exacta del servidor sobre el que trabajas no es un detalle trivial: determina qué sintaxis puedes usar, qué optimizaciones están disponibles y qué precauciones debes tomar. La función VERSION() te proporciona esta información de forma directa, devolviendo una cadena con el número de versión del servidor MySQL al que estás conectado.

Esta función es especialmente valiosa cuando desarrollas scripts o procedimientos almacenados que deben funcionar en múltiples servidores con versiones diferentes, o cuando necesitas documentar el entorno exacto de una instalación para diagnóstico y soporte técnico.

Sintaxis de VERSION()

La función no recibe parámetros y devuelve una cadena de texto que representa la versión del servidor MySQL.

SELECT VERSION();

El resultado típico tiene el formato mayor.menor.parche, opcionalmente seguido de un sufijo que indica la distribución o el tipo de compilación.

SELECT VERSION();
-- Resultado: 8.0.35

En servidores gestionados por proveedores cloud o distribuciones específicas, el resultado puede incluir sufijos adicionales como 8.0.35-0ubuntu0.22.04.1 en Ubuntu o 8.0.35-cloud en servicios gestionados. El núcleo siempre son los tres primeros números separados por puntos.

La variable @@version como alternativa

MySQL también expone la versión del servidor a través de la variable de sistema @@version. Ambas formas devuelven el mismo valor, pero @@version puede resultar más cómoda en ciertos contextos porque no requiere paréntesis.

-- Ambas devuelven lo mismo
SELECT VERSION();
SELECT @@version;
 
-- También puedes consultarla con SHOW VARIABLES
SHOW VARIABLES LIKE 'version';

La elección entre VERSION() y @@version es puramente estilística. En procedimientos almacenados y expresiones condicionales, VERSION() suele integrarse mejor con la sintaxis SQL, mientras que @@version es habitual en scripts de diagnóstico rápido.

Además de la versión principal, existen variables relacionadas que proporcionan información complementaria sobre el servidor.

-- Información detallada del servidor
SELECT
  @@version AS version,
  @@version_comment AS comentario,
  @@version_compile_os AS sistema_operativo,
  @@version_compile_machine AS arquitectura;

Este conjunto de variables te ofrece un perfil completo del servidor: versión exacta, tipo de compilación (Community, Enterprise), sistema operativo y arquitectura del hardware.

Formato del resultado y extracción de componentes

El resultado de VERSION() es una cadena de texto, lo que significa que no puedes compararlo directamente con operadores numéricos. Para extraer los componentes individuales (mayor, menor, parche) y realizar comparaciones fiables, necesitas procesar la cadena.

-- Extraer componentes de la versión
SELECT
  VERSION() AS version_completa,
  SUBSTRING_INDEX(VERSION(), '.', 1) AS mayor,
  SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 2), '.', -1) AS menor,
  SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 3), '.', -1) + 0 AS parche;

El + 0 en el componente de parche fuerza la conversión a número, eliminando cualquier sufijo de texto que pueda acompañar al último número (como -ubuntu0.22.04.1). Con estos componentes separados, puedes construir comparaciones precisas.

-- Verificar si la versión es 8.0 o superior
SELECT
  CASE
    WHEN SUBSTRING_INDEX(VERSION(), '.', 1) + 0 >= 8 THEN 'MySQL 8.x o superior'
    ELSE 'Versión anterior a MySQL 8.0'
  END AS categoria_version;

Detectar funcionalidades según la versión

MySQL 8.0 fue una versión transformadora que introdujo numerosas funcionalidades que antes requerían soluciones alternativas. Conocer la versión te permite decidir si puedes aprovechar estas características o si necesitas recurrir a enfoques compatibles con versiones anteriores.

Las expresiones de tabla comunes (CTEs) están disponibles desde MySQL 8.0. Si tu servidor es anterior, necesitarás reescribir las consultas recursivas con subconsultas anidadas o tablas temporales.

-- Verificar soporte de CTEs
SELECT
  CASE
    WHEN SUBSTRING_INDEX(VERSION(), '.', 1) + 0 >= 8
    THEN 'CTEs disponibles (WITH ... AS)'
    ELSE 'CTEs no soportadas - usar subconsultas'
  END AS soporte_cte;

Las funciones de ventana como ROW_NUMBER(), RANK() y LAG() también llegaron con MySQL 8.0. En versiones anteriores, la alternativa habitual era usar variables de usuario con ORDER BY dentro de subconsultas, un patrón mucho más frágil y difícil de mantener.

-- Verificar múltiples funcionalidades
SELECT
  VERSION() AS version,
  IF(SUBSTRING_INDEX(VERSION(), '.', 1) + 0 >= 8,
    'Sí', 'No') AS cte_disponible,
  IF(SUBSTRING_INDEX(VERSION(), '.', 1) + 0 >= 8,
    'Sí', 'No') AS window_functions,
  IF(SUBSTRING_INDEX(VERSION(), '.', 1) + 0 >= 8
    AND SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 3), '.', -1) + 0 >= 16,
    'Sí', 'No') AS check_constraints,
  IF(SUBSTRING_INDEX(VERSION(), '.', 1) + 0 >= 8
    AND SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 3), '.', -1) + 0 >= 18,
    'Sí', 'No') AS explain_analyze;

La restricción CHECK se introdujo en MySQL 8.0.16. Antes de esa versión, MySQL aceptaba la sintaxis CHECK pero la ignoraba silenciosamente, un comportamiento que provocó confusión durante años. La herramienta EXPLAIN ANALYZE, que ejecuta la consulta y muestra el plan real de ejecución con tiempos, llegó en MySQL 8.0.18.

Uso en scripts de migración

Los scripts de migración que deben ejecutarse en servidores con diferentes versiones de MySQL se benefician enormemente de VERSION(). Puedes incluir verificaciones al inicio del script que aborten la ejecución si la versión no cumple los requisitos mínimos.

-- Verificación al inicio de un script de migración
DELIMITER //
 
CREATE PROCEDURE ejecutar_migracion()
BEGIN
  DECLARE v_mayor INT;
  DECLARE v_menor INT;
  DECLARE v_parche INT;
 
  SET v_mayor = SUBSTRING_INDEX(VERSION(), '.', 1) + 0;
  SET v_menor = SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 2), '.', -1) + 0;
  SET v_parche = SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 3), '.', -1) + 0;
 
  -- Requiere MySQL 8.0.16 o superior
  IF v_mayor < 8 OR (v_mayor = 8 AND v_menor = 0 AND v_parche < 16) THEN
    SIGNAL SQLSTATE '45000'
      SET MESSAGE_TEXT = 'Esta migración requiere MySQL 8.0.16 o superior';
  END IF;
 
  -- Crear tabla con CHECK constraints (solo funciona desde 8.0.16)
  CREATE TABLE IF NOT EXISTS productos (
    id INT AUTO_INCREMENT PRIMARY KEY,
    nombre VARCHAR(200) NOT NULL,
    precio DECIMAL(10,2) NOT NULL,
    stock INT NOT NULL DEFAULT 0,
    CONSTRAINT chk_precio CHECK (precio > 0),
    CONSTRAINT chk_stock CHECK (stock >= 0)
  );
 
  SELECT CONCAT('Migración completada en MySQL ', VERSION()) AS resultado;
END //
 
DELIMITER ;

Este procedimiento comprueba que el servidor cumple la versión mínima antes de ejecutar DDL que depende de funcionalidades específicas. Si la versión es insuficiente, lanza un error claro en lugar de fallar de forma impredecible.

Comparar versiones de forma robusta

Para comparaciones de versión más complejas, puedes crear una función auxiliar que convierta la cadena de versión en un número entero comparable. Esta técnica simplifica las verificaciones posteriores.

DELIMITER //
 
CREATE FUNCTION version_numerica()
RETURNS INT
DETERMINISTIC
BEGIN
  DECLARE v_mayor INT;
  DECLARE v_menor INT;
  DECLARE v_parche INT;
 
  SET v_mayor = SUBSTRING_INDEX(VERSION(), '.', 1) + 0;
  SET v_menor = SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 2), '.', -1) + 0;
  SET v_parche = SUBSTRING_INDEX(SUBSTRING_INDEX(VERSION(), '.', 3), '.', -1) + 0;
 
  -- Formato: 80035 para 8.0.35
  RETURN v_mayor * 10000 + v_menor * 100 + v_parche;
END //
 
DELIMITER ;
 
-- Ahora las comparaciones son triviales
SELECT
  CASE
    WHEN version_numerica() >= 80016 THEN 'CHECK constraints soportadas'
    WHEN version_numerica() >= 80000 THEN 'MySQL 8.0 sin CHECK'
    ELSE 'Versión anterior a 8.0'
  END AS soporte;

Con esta función, cada versión se convierte en un número entero donde 8.0.35 se representa como 80035 y 5.7.44 como 50744. Las comparaciones numéricas son directas e inequívocas.

Registrar la versión en tablas de diagnóstico

En entornos de producción con múltiples servidores, es habitual mantener un registro centralizado que documente la versión de cada servidor. Esto facilita el seguimiento de actualizaciones y la planificación de migraciones.

CREATE TABLE IF NOT EXISTS registro_servidores (
  id INT AUTO_INCREMENT PRIMARY KEY,
  nombre_servidor VARCHAR(100) NOT NULL,
  version_mysql VARCHAR(50) NOT NULL,
  sistema_operativo VARCHAR(100),
  fecha_registro TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
 
INSERT INTO registro_servidores (nombre_servidor, version_mysql, sistema_operativo)
VALUES (
  @@hostname,
  VERSION(),
  @@version_compile_os
);
 
SELECT * FROM registro_servidores;

Este registro te permite ver de un vistazo qué servidores necesitan actualización y planificar las migraciones de forma coordinada.

Uso con SHOW VERSION

Además de la función VERSION(), puedes consultar la versión del servidor con el comando SHOW, que devuelve la información en un formato tabular junto con otras variables del servidor.

-- Mostrar versión y variables relacionadas
SHOW VARIABLES LIKE 'version%';

Este comando devuelve varias filas con version, version_comment, version_compile_machine y version_compile_os, proporcionando un panorama completo del servidor en una sola consulta.

Errores comunes

El error más habitual es intentar comparar el resultado de VERSION() directamente con un número. La expresión WHERE VERSION() > 8.0 no funciona como se espera porque VERSION() devuelve una cadena, no un número. MySQL realizará una conversión implícita que solo considerará el primer componente numérico, dando resultados engañosos. Siempre extrae los componentes y compáralos individualmente o utiliza una función auxiliar como la que se mostró anteriormente.

Otro error frecuente es asumir que el formato de VERSION() es siempre tres números separados por puntos. En distribuciones como MariaDB, Percona o servicios cloud, el resultado puede incluir prefijos o sufijos adicionales. Si tu lógica depende de un formato estricto, asegúrate de limpiar la cadena antes de procesarla.

También es común olvidar que VERSION() devuelve la versión del servidor, no del cliente. Si usas un cliente MySQL 8.0 para conectarte a un servidor MySQL 5.7, VERSION() devolverá 5.7.x. La versión del cliente se consulta de forma diferente según la herramienta que utilices.

Cuándo usar VERSION()

Recurre a VERSION() cuando desarrolles scripts de migración que deban validar requisitos mínimos, cuando necesites documentar el entorno de un servidor para diagnóstico, cuando construyas procedimientos almacenados que adapten su sintaxis según las capacidades del servidor, o cuando mantengas un inventario de versiones en una infraestructura con múltiples servidores MySQL. Es una función sin coste de rendimiento que puedes usar libremente en cualquier contexto.

Escrito por Eduardo Lázaro

AnteriorDATABASE()Funciones de informaciónSiguienteUSER() y CURRENT_USER()Funciones de información