Tipos y Uso de Variables en MySQL

En el ámbito de la gestión de bases de datos, especialmente en sistemas como MySQL, la capacidad de almacenar y manipular información de manera temporal es fundamental. Aquí es donde entran en juego las Variables en MySQL. Al igual que en los lenguajes de programación, las variables actúan como contenedores que guardan datos que pueden ser referenciados y modificados a lo largo de la ejecución de un programa o una sesión. Su valor puede cambiar según sea necesario, y cada variable, aunque en MySQL la declaración explícita del tipo no siempre es obligatoria como en otros lenguajes (dependiendo del tipo de variable), internamente maneja un tipo de dato específico.

A diferencia de lenguajes como Java o C++, donde debes declarar explícitamente el tipo de dato antes de asignar un valor, o Python, que infiere el tipo, MySQL ofrece flexibilidad. Principalmente, las variables pueden definirse y asignarles un valor directamente utilizando la sentencia SET, aunque también se pueden asignar valores mediante SELECT.

El propósito principal de una variable es etiquetar una ubicación en la memoria para almacenar datos, permitiendo que estos datos sean utilizados y manipulados a lo largo de una secuencia de operaciones o dentro de un contexto específico.

En MySQL, existen tres tipos principales de variables, cada una con su propósito, alcance y sintaxis particulares:

Variables de Usuario

Las Variables de Usuario son quizás el tipo más sencillo y directo de variables en MySQL. Permiten almacenar un valor en una sentencia SQL y luego referenciar ese valor en sentencias posteriores dentro de la misma sesión de cliente. Son útiles para pasar valores entre sentencias o para almacenar resultados temporales.

Las variables de usuario se distinguen por llevar el símbolo "@" como prefijo en su nombre (por ejemplo, @nombre_variable). Para declarar (implícitamente) y asignar un valor a una variable de usuario, se pueden utilizar las sentencias SET o SELECT. Los operadores de asignación permitidos son = y :=.

Aunque no se declara explícitamente un tipo de dato al definirlas (MySQL infiere el tipo del valor asignado), pueden contener valores de tipos como entero, decimal, booleano, cadenas de caracteres, etc.

Sintaxis y Ejemplos de Variables de Usuario

La sintaxis básica para asignar un valor usando SET es:

SET @nombre_variable = valor;

O usando SELECT:

SELECT @nombre_variable := valor;

Es importante notar la diferencia en el operador: = se usa comúnmente con SET, mientras que := es más flexible y funciona tanto con SET como con SELECT para asignación.

Veamos algunos ejemplos prácticos:

Para asignar una cadena de texto a una variable de usuario:

SET @Name = 'Michael';

Una vez asignado el valor, puedes recuperarlo o mostrarlo usando SELECT:

SELECT @Name;

La salida de esta consulta sería:

+---------+| @Name |+---------+| Michael |+---------+

También puedes asignar valores numéricos o resultados de expresiones usando SELECT y el operador :=:

SELECT @test := 10;

La salida mostraría el valor asignado:

+-----------+| @test := 10 |+-----------+| 10 |+-----------+

Las variables de usuario son particularmente útiles cuando necesitas almacenar un resultado de una consulta para usarlo en otra. Considera el siguiente ejemplo, donde usamos una variable de usuario para encontrar el salario máximo de una tabla y luego seleccionar los registros con ese salario:

Primero, creamos una tabla simple CUSTOMERS y le insertamos algunos datos (basado en el ejemplo proporcionado):

CREATE TABLE CUSTOMERS( ID INT AUTO_INCREMENT PRIMARY KEY, NAME VARCHAR(20) NOT NULL, AGE INT NOT NULL, ADDRESS CHAR (25), SALARY DECIMAL (18, 2) ); INSERT INTO CUSTOMERS (NAME, AGE, ADDRESS, SALARY) VALUES ('Ramesh', 32, 'Ahmedabad', 2000.00), ('Khilan', 25, 'Delhi', 1500.00), ('Kaushik', 23, 'Kota', 2000.00), ('Chaitali', 25, 'Mumbai', 6500.00), ('Hardik', 27, 'Bhopal', 8500.00), ('Komal', 22, 'Hyderabad', 4500.00), ('Muffy', 24, 'Indore', 10000.00);

La tabla CUSTOMERS se vería así:

Ahora, asignamos el salario máximo a una variable de usuario @max_salary:

SELECT @max_salary := MAX(SALARY) FROM CUSTOMERS;

Finalmente, usamos esta variable para seleccionar a los clientes con ese salario máximo:

SELECT * FROM CUSTOMERS WHERE SALARY = @max_salary;

La salida mostraría el registro con el salario más alto:

+----+-------+-----+---------+----------+| ID | NAME | AGE | ADDRESS | SALARY |+----+-------+-----+---------+----------+| 7 | Muffy | 24 | Indore | 10000.00 |+----+-------+-----+---------+----------+

Este ejemplo ilustra cómo una variable de usuario puede capturar un resultado de una consulta para ser reutilizado en otra, facilitando operaciones multi-paso.

Variables Locales

Las Variables Locales en MySQL tienen un alcance más limitado que las variables de usuario. Son declaradas utilizando la palabra clave DECLARE y se utilizan principalmente dentro de bloques de código procedurales, como procedimientos almacenados, funciones, triggers o eventos. A diferencia de las variables de usuario, las variables locales no utilizan el prefijo "@".

Una característica distintiva de las variables locales es que son variables fuertemente tipadas. Esto significa que, al declararlas, es obligatorio especificar su tipo de dato (INT, VARCHAR, DECIMAL, etc.).

Además, al declarar una variable local, se le puede asignar un valor predeterminado opcional utilizando la palabra clave DEFAULT. Si no se especifica un valor por defecto, la variable se inicializará con el valor NULL.

Sintaxis y Ejemplo de Variables Locales

La sintaxis para declarar una variable local es:

DECLARE nombre_variable DATA_TYPE [DEFAULT valor_predeterminado];

Se pueden declarar múltiples variables del mismo tipo en una sola sentencia DECLARE separándolas por comas:

DECLARE variable1, variable2, ... DATA_TYPE [DEFAULT valor_predeterminado];

Una vez declarada, una variable local puede ser asignada con la sentencia SET (o SELECT en algunos contextos procedurales, aunque SET es más común para asignaciones simples):

SET nombre_variable = valor;

El siguiente ejemplo muestra el uso de variables locales dentro de un procedimiento almacenado para calcular la suma de varios salarios:

DELIMITER // CREATE PROCEDURE salaries() BEGIN DECLARE Ramesh INT; DECLARE Khilan INT DEFAULT 30000; DECLARE Kaushik INT; DECLARE Chaitali INT; DECLARE Total INT; SET Ramesh = 20000; SET Kaushik = 25000; SET Chaitali = 29000; SET Total = Ramesh + Khilan + Kaushik + Chaitali; SELECT Total, Ramesh, Khilan, Kaushik, Chaitali; END // DELIMITER ;

En este procedimiento, se declaran varias variables locales (Ramesh, Khilan, Kaushik, Chaitali, Total). A Khilan se le asigna un valor por defecto de 30000 durante la declaración. Las otras variables se inicializan a NULL por defecto. Luego, se asignan valores a Ramesh, Kaushik y Chaitali usando SET. Finalmente, se calcula el Total sumando los valores de las variables y se muestran los resultados usando SELECT.

Para ejecutar este procedimiento almacenado, se usa la sentencia CALL:

CALL salaries();

La salida de esta llamada sería:

+-------+--------+--------+---------+----------+| Total | Ramesh | Khilan | Kaushik | Chaitali |+-------+--------+--------+---------+----------+| 104000| 20000 | 30000 | 25000 | 29000 |+-------+--------+--------+---------+----------+

Este ejemplo demuestra cómo las variables locales proporcionan un espacio de trabajo temporal dentro de un bloque de código procedural, permitiendo realizar cálculos y manipulaciones complejas antes de devolver un resultado.

Variables de Sistema

Las Variables de Sistema son variables predefinidas por el propio servidor MySQL. Contienen información de configuración y estado que controla el comportamiento del servidor y de las conexiones de cliente. Cada variable de sistema tiene un valor por defecto, pero muchos de ellos pueden ser modificados.

Estas variables son esenciales para ajustar el rendimiento, la seguridad y otras características operativas del servidor MySQL.

Las variables de sistema tienen dos ámbitos principales:

• GLOBAL: Afectan la operación general del servidor MySQL y son visibles y aplicables a todas las conexiones de cliente activas y futuras (después de ser establecidas). Permanecen activas durante todo el ciclo de vida del servidor (hasta que se reinicie, a menos que se persistan).
• SESSION: Afectan la operación solamente para la conexión de cliente actual. Se inicializan al conectar el cliente, generalmente tomando el valor de la variable global correspondiente en ese momento. Los cambios a variables de sesión solo afectan a la conexión actual.

Puedes ver todas las variables de sistema disponibles y sus valores actuales utilizando la sentencia SHOW VARIABLES:

SHOW [GLOBAL | SESSION] VARIABLES;

Si no se especifica GLOBAL ni SESSION, SHOW VARIABLES muestra los valores de sesión.

Para filtrar la lista de variables, puedes usar una cláusula LIKE con patrones. Por ejemplo, para ver todas las variables relacionadas con tablas:

SHOW VARIABLES LIKE '%table%';

Esto producirá una lista de variables y sus valores, similar a esta (la salida exacta depende de la versión de MySQL y la configuración):

Para obtener el valor actual de una variable de sistema específica dentro de una consulta, puedes prefijar su nombre con @@. Por ejemplo, para ver el tamaño del búfer de claves:

SELECT @@key_buffer_size;

La salida sería el valor actual de esa variable:

+-------------------+| @@key_buffer_size |+-------------------+| 8388608 |+-------------------+

Configuración de Variables de Sistema

Los valores de las variables de sistema se pueden establecer de diferentes maneras:

• Al iniciar el servidor: Usando opciones en la línea de comandos o en un archivo de opciones (como my.cnf o my.ini). La sintaxis es --nombre_variable=valor en la línea de comandos o nombre_variable=valor en el archivo de opciones dentro de la sección apropiada (ej. [mysqld]). Las variables de sistema implementadas por plugins o componentes usan sus nombres completos (ej. dragnet.log_error_filter_rules). Es importante notar que al configurar en el inicio, se pueden usar guiones o guiones bajos indistintamente en el nombre de la variable (ej. --general_log=ON es igual a --general-log=ON). También se permiten sufijos para valores numéricos (K, M, G, T, P, E) para indicar múltiplos de 1024 (KB, MB, GB, etc.), por ejemplo, --sort-buffer-size=256K.
• En tiempo de ejecución: Usando la sentencia SET. Esto permite cambiar dinámicamente el comportamiento del servidor o de la sesión actual sin necesidad de reiniciar. Al usar SET, los nombres de las variables deben escribirse usando guiones bajos. La sintaxis es SET [GLOBAL | SESSION] nombre_variable = valor; o SET @@[GLOBAL | SESSION.]nombre_variable = valor;. Si no se especifica GLOBAL ni SESSION, por defecto se establece la variable de sesión. A diferencia de la configuración de inicio, al usar SET no se permiten los sufijos de tamaño (K, M, G), pero sí se pueden asignar valores usando expresiones (ej. SET GLOBAL max_allowed_packet = 16*1024*1024;).
• Persistencia: Desde MySQL 8.0, se pueden hacer que los cambios a variables globales sean persistentes a través de reinicios del servidor usando SET PERSIST nombre_variable = valor; o SET @@PERSIST.nombre_variable = valor;. Esto escribe la configuración en un archivo llamado mysqld-auto.cnf en el directorio de datos. SET PERSIST_ONLY solo escribe el valor en el archivo sin cambiar el valor actual en tiempo de ejecución.

Es posible restringir el valor máximo al que una variable de sistema puede ser establecida en tiempo de ejecución usando la opción --maximum-nombre_variable=valor al iniciar el servidor.

Tabla Comparativa de Tipos de Variables

Preguntas Frecuentes sobre Variables en MySQL

Aquí respondemos algunas preguntas comunes sobre el manejo de variables en MySQL:

¿Cuál es la diferencia principal entre = y := al asignar variables?

Ambos operadores se pueden usar para asignar valores a variables de usuario. Sin embargo, := es el operador de asignación estándar en MySQL y funciona en casi cualquier contexto donde se permite una expresión, incluyendo la sentencia SELECT. El operador = se usa principalmente con SET y también en la cláusula WHERE para comparaciones (donde := no funcionaría como asignación). Para evitar ambigüedades, := es generalmente preferible para asignaciones, especialmente en SELECT.

¿Las variables de usuario persisten entre diferentes conexiones?

No. Las variables de usuario tienen un alcance de sesión. Cuando una conexión de cliente finaliza, todas las variables de usuario definidas dentro de esa sesión se pierden. Una nueva conexión comenzará sin variables de usuario predefinidas (a menos que se configuren al inicio de la conexión).

¿Puedo usar variables de usuario dentro de un procedimiento almacenado?

Sí, puedes definir y usar variables de usuario dentro de un procedimiento almacenado. Sin embargo, su alcance seguirá siendo la sesión. Si el procedimiento es llamado desde una sesión, las variables de usuario definidas o modificadas dentro del procedimiento afectarán a las variables de usuario con el mismo nombre en esa sesión.

¿Cómo puedo ver el valor actual de una variable de sistema?

Puedes usar SELECT @@nombre_variable_sistema; para ver el valor de sesión de una variable, o SELECT @@GLOBAL.nombre_variable_sistema; para ver el valor global. Alternativamente, SHOW VARIABLES LIKE 'nombre_variable%'; te mostrará las variables que coinciden con el patrón, incluyendo su ámbito (si se especifica GLOBAL o SESSION).

¿Cómo hago que un cambio en una variable de sistema sea permanente?

Cambiar una variable de sistema con SET GLOBAL solo afecta al servidor en ejecución hasta el próximo reinicio. Para que el cambio sea permanente, debes configurarlo en el archivo de opciones de MySQL (como my.cnf) o usar la sentencia SET PERSIST (disponible desde MySQL 8.0), que guarda el valor en el archivo mysqld-auto.cnf para que se aplique automáticamente en futuros inicios.

¿Cuál es el alcance exacto de una variable local?

Una variable local existe y es accesible únicamente dentro del bloque de código procedural (como un procedimiento almacenado, función, trigger o evento) donde fue declarada. Una vez que la ejecución de ese bloque finaliza, la variable local y su valor dejan de existir.

Conclusión

Comprender los diferentes tipos de variables en MySQL (de usuario, locales y de sistema) es fundamental para escribir consultas y rutinas eficientes, así como para administrar y optimizar el servidor de base de datos. Cada tipo tiene su propio propósito y alcance, y saber cuándo y cómo usar cada uno te permitirá aprovechar al máximo las capacidades de MySQL, desde la manipulación temporal de datos en una sesión hasta la configuración fina del rendimiento del servidor.

Si quieres conocer otros artículos parecidos a Tipos y Uso de Variables en MySQL puedes visitar la categoría MySQL.