PostgreSQL vs MySQL vs MariaDB con Docker

Buenos días a todos y bienvenidos a una nueva entrada de TodoPostgreSQL, tu portal formativo en PostgreSQL.

Existen muchas Bases de Datos relacionales de código libre, pero hay tres que destacan sobre las demás, estamos hablando de PostgreSQL, MySQL y MadriaDB. Cada uno de estos Sistemas se han ganado el respeto durante estos años, por lo tanto es complicado decantarse por uno. En esta entrada haremos una comparación en cuanto a rendimiento de estos tres RDBMS teniendo en cuenta la configuración por defecto incluida en la imagen oficial del repositorio Docker,  por lo tanto vamos a realizar la instalación en diferentes contenedores en una misma máquina virtual.

Acompáñanos, en esta entrada tendrás todos los pasos que hemos dado para realizar este maravilloso experimento.

Descargar las imágenes.

Lo primero de todo es descargar las imágenes oficiales de Docker con cada uno de los Sistemas Gestores de Base de Datos.

Empecemos por obtener la última imagen oficial de PostgreSQL con Docker.
docker pull postgres

Hacemos lo mismo para descargar la última imagen oficial de MySQL.

docker pull mysql

Por último obtenemos la última imagen oficial de MariaDB.

docker pull mariadb

Iniciar los servidores de BD.

Una vez que ya disponemos de las imágenes, lo siguiente es iniciar cada uno de los contenedores levantando cada servidor de Bases de Datos.

Con el siguiente comando se le da un nombre al contenedor de PostgreSQL y una dirección ip con su puerto por defecto, con ello se inicia una instancia de Postgres.
docker run --name postgres10 -d -p 127.0.0.1:5432:5432 postgres

 

Con el siguiente comando le ponemos un nombre al contenedor de MySQL, una dirección ip con su puerto por defecto y una contraseña para el usuario root. De esta forma se inicia una instancia de MySQL.
docker run --name mysql -p 127.0.0.1:3306:3306 -e MYSQL_ROOT_PASSWORD="pass_mysql" mysql

 

Para iniciar una instancia de MariaDB, utilizamos otro puerto para que no haya conflicto con el de MySQL.

docker run --name mariadb -p 127.0.0.1:3307:3307 -e MYSQL_ROOT_PASSWORD="pass_mariadb" mariadb

 

 

Conexión con el Server DB.

Una vez que ya tenemos los tres RDBMS realizamos la conexión mediante la consola a cada uno de ellos.

Para conectarse con el Servidor de PostgreSQL, lo hacemos mediante un link con el nombre del contenedor (postgres10) y la imagen (postgres).
docker run -it --rm --link postgres10:postgres postgres psql -h postgres -U postgres

Para conectarnos al Servidor de MySQL, lo realizamos utilizando las variables de entono.
docker run -it --link mysql:mysql --rm mysql sh -c 'exec mysql -h"$MYSQL_PORT_3306_TCP_ADDR" -P"$MYSQL_PORT_3306_TCP_PORT" -uroot -p"$MYSQL_ENV_MYSQL_ROOT_PASSWORD"'

De igual forma realizamos la conexión con el Servidor de MariaDB.
docker run -it --link mariadb:mysql --rm mariadb sh -c 'exec mysql -h"$MYSQL_PORT_3306_TCP_ADDR" -P"$MYSQL_PORT_3306_TCP_PORT" -uroot -p"$MYSQL_ENV_MYSQL_ROOT_PASSWORD"'

 

Procedimiento.

Para medir el rendimiento de una forma rápida y sencilla se crea una tabla con tan solo una columna y se realiza una inserción de 1000 registros en dicha tabla. Teniendo previamente creada dicha tabla, se crea un procedimiento o función para que al ejecutarse en cada uno de los RDBMS inserte en la tabla las 1000 filas. Medimos el tiempo que toman en completar la inserción de esos 1000 registros.

 

El código para insertar las 1000 filas en PostgreSQL es el siguiente:
CREATE FUNCTION add_filas() RETURNS void AS $$
DECLARE i int;
BEGIN
for i in 1..1000 loop
insert into filas(id) values (i);
end loop;
return;
END;
$$ LANGUAGE plpgsql;


 

Para MySQL y MariaDB el código para insertar las 1000 filas es el siguiente:
delimiter //
CREATE PROCEDURE ADD_FILES()
BEGIN
DECLARE i INT default 1;
miloop:LOOP
INSERT INTO filas VALUES (i);
SET i=i+1;
IF i=1000 THEN
LEAVE miloop;
END IF;
END LOOP miloop;
END //


 

Conclusión.

Al llamar a la función / procedimiento para que se inserten las 1000 filas, vemos el tiempo que demoran cada Servidor de Bases de Datos:

Este es tiempo que ha tardado el Servidor de PostgreSQL en insertar las 1000 filas, dado que esta en mili-segundos, la conversión a segundos es de 0,075 Segundos.

El servidor de MySQL ha tardado 4,83 Segundos en insertar las 1000 filas.

Al insertar 1000 filas en un Servidor de MariaDB, se ha demorado al rededor de 2 segundos (1,91 segundos).

 

A partir de estos resultados las conclusiones pueden ser claras, sin embargo nos gustaría resaltar lo que dijimos al principio de esta entrada; para este experimento se ha utilizado la configuración por defecto incluida en el repositorio oficial de Docker. Se puede realizar diferentes configuraciones para optimizar estos resultados, tanto para PostgreSQL así como para MySQL y MariaDB, por lo tanto animamos a que realicéis vuestros propios experimentos y saquéis vuestras propias conclusiones.

Si quieres conocer nuestra recomendación para optimizar PostgreSQL, suscríbete y ponte en contacto con nosotros.