Como comenté anteriormente ahora para XAMPP viene MaríaDB, la mayoría de los comandos que vamos a utilizar aquí deberían funcionar bien tanto para MaríaDB como para MySQL sin mayor inconveniente, igual es importante que sepan que estos dos productos no son lo mismo pueden releer mi comentario al final de esta publicación.
Recuerden que todo el curso está destinado para Windows y Linux, pero recomiendo enormemente instalar y utilizar Linux como describo aquí.
Este laboratorio nos introduce en:
- Crear una base de datos
- Crear Schema de la base de datos
- Plus: Crear schemas con MySQL Workbench
Utilizaremos las herramientas que solicité instalar en el capítulo anterior:
- PhpMyAdmin
- SquirrelSQL
- MySQL Workbench
- CLI (viene con la base de datos, nativamente).
Además nos prepara para el próximo laboratorio donde se integrará el desarrollo web con los conceptos de base de datos.
Bien, a darle átomos…
Sin una estructura, no podemos almacenar datos
Imagino que muchos ya estaban listos para comenzar a hacer «INSERT…» o agregar información en la base de datos… pero ¿Cómo lo harían si aún no tenemos ninguna?
Con las RDBMS hay un tema importante, hay que pensar antes de hacer. El viejo paradigma de programación en muchas empresas, es crear las bases de datos relacionales primero y luego hacer la aplicación para que guarde los datos en la estructura definida en la base.
Sin embargo, esa forma de trabajo causa muchos problemas debido a que mientras desarrollamos la web, tal vez queramos aplicar algún cambio nuevo o implementar una funcionalidad para la cual la base no estaba preparada.
Sin embargo, para los efectos prácticos de este curso, nuestra introducción será al estilo viejo, primero la base y luego la aplicación web.
Vamos a crear una base vacía con el nombre «dominio_test» (Este nombre debido a que, «dominio.com.ar» es lo que usamos en el Laboratorio 1 para la aplicación Web y «test» porque es el ambiente de pruebas) así, si tuvieramos otras bases de datos será fácil reconocerla.
Podemos hacerlo de 3 formas diferentes, vamos a explorarlas:
CLI – Windows (MaríaDB)
La interfaz de línea de comandos es mi herramienta favorita. Es simple, rápida y es la herramienta nativa de la base de datos, otras soluciones como phpMyAdmin, Squirrel o MySQL Workbench simplifican algunos procesos, pero todos ellos hacen exactamente lo mismo que hacemos a través del CLI.
Windows
Para acceder en Windows con nuestra instalación de XAMPP a María DB:
Inicio > Ejecutar > cmd y una vez allí ejecutar:
En este directorio se encuentran los ejecutables de María DB. Nuestro paso siguiente es ejecutar mysql.exe (que como mencioné antes es MaríaDB) y le pasamos el parámetro «-u» para indicar el usuario «root» que es el usuario administrador de la base de datos, de esa forma tendremos los permisos necesarios para hacer cualquier operación con la base.
Lo que pueden ver ahora en su ventana CMD es el «prompt» que dice «MariaDB [<none>] _» y está a la espera de la ejecución de cualquier comando para interactuar con la base.
La parte que dice significa que aún no hemos elegido ninguna base para trabajar. Pueden por ejemplo listar todas las bases de datos con el siguiente comando «show databases;» y pulsan enter (el punto y coma al final es necesario para indicar el final de una sentencia SQL) :
Verán un listado de todas las bases que existen. Por default podremos ver que están phpmyadmin (que obviamente pertenece a PhpMyAdmin), mysql, information_schema y performance_schema que son propias del motor, luego están test y testo que son mías.
Ahora sí, creemos la nuestra:
Como podrán ver, he vuelto a listar las bases con show databases y la veo en la lista, también lean el mensaje «Query OK, 1 row affected <0.00 sec>»
En realidad, todos los comandos (show databases, create database, etc…) que ejecutamos en el CLI se llaman Querys y es así como las vamos a llamar de aquí en adelante. Este mensaje nos dice que nuestro Query terminó bien, solo realizó un cambio y tardó 0.00 segundos, el cambio que realizó, fue crear nuestra base dominio_test.
CLI – Linux (MySQL)
Si le echaron un vistazo al procedimiento en Windows, en Linux es prácticamente igual. La única diferencia es que no necesitamos ir al directorio donde está el binario de mysql para ejecutarlo, ya que en Linux (como una estación de desarrollo decente) exporta por defecto variables de entorno que nos permiten llamar el ejecutable desde cualquier ubicación.
Primero ejecutamos «mysql -u root -p» para iniciar el CLI, el cual requiere la contraseña que definimos en la instalación de MySQL.
Utilizaremos el comando «show databases» para listar las bases de datos y posteriormente «create database» para crear la base.
Si no les gusta usar comandos a través de CLI, pueden utilizar la interfaz web que simplifica todo en «lindos botones» (al final, por detrás terminará ejecutando comandos del mismo modo que en el CLI). Digamos que, una vez que se dominan los conceptos de MySQL utilizar este tipo de herramientas resulta conveniente.
PhpmyAdmin – A través de interfaz web
Primero ingresen a phpmyAdmin a través del navegador:
Habiendo ingresado, es tan fácil como hacer clic en «Nueva/New» elegir un nombre y hacer clic en el botón «crear»
Debido a la simplicidad que esto representa, no creo que sea necesario profundizar mucho sobre esta herramienta.
Creación del Schema para la base de datos
Si bien hemos utilizado «create database» en el paso anterior para crear la base de datos. Lo único que hemos logrado es establecer un «contenedor», ahora tenemos que crear la estructura dentro de ése contenedor (dominio_test).
Ya mencioné las RDBMS antes en este capítulo, pero vamos a reforzar un poco el conocimiento para entender qué vamos a hacer a continuación.
Imaginen a nuestra base de datos como un gran cajón con el nombre (dominio_test). Eso es lo que logramos justo con el paso anterior crear un cajón vacío.
Ahora debemos crear una estructura dentro de ese cajón para almacenar la información, veamos esta serie de imágenes para entender el concepto.
Creamos la base de datos (dominio_test), un contendor vacío:
Posteriormente crearemos las tablas, que serán divisiones internas para almacenar distintos tipos de datos (usuarios, publicaciones, artículos, contraseñas, otros contenidos, etc…)
Y finalmente, en cada tabla almacenaremos los datos que deseamos:
De este modo se constituye la totalidad de la instancia de base de datos.
Ahora, pasemos a la práctica, vamos a realizar nuestro esquema con la ayuda de MySQL-Workbench para ahorrar tiempo, aunque también encontrarán instrucciones para hacer lo mismo desde phpmyAdmin o desde el CLI.
Creación del Schema con MySQL-Workbench
La herramienta es la misma para Linux y para Windows, visualmente hay algunas diferencias, pero nada realmente tan relevante.
Es importante saber que, para quienes instalaron MySQL Workbench sobre Windows, tendrán una advertencia al iniciar la aplicación «Incompatible/Non Standard Version» ya que con XAMPP, como les he comentado en varias oportunidades viene «MaríaDB y no MySQL». A pesar de esto, si le damos «Continue Anyway» podremos utilizar MySQL Workbench sin problema.
En Windows adicionalmente no pedirá contraseña para ingresar a nuestras bases de datos, pero en Linux sí debemos autenticarnos con la contraseña que definimos en la instalación.
En Linux, hacemos doble clic en la Instancia local, que corre en el puerto que ya conocemos «3306» (puerto por defecto de MySQL)
Y nos autenticamos:
Para llegar a la siguiente vista:
Que en Windows luce casi igual:
Ahora vamos a ir a File > New Model (en el panel superior), se abrirá una nueva pestaña:
Por defecto tendrá el nombre «mydb», debemos cambiarlo a «dominio_test», hagan doble clic en el icono de base de datos «mydb», cambien el nombre y pulsen la tecla enter:
Ahora creemos nuestras dos primeras tablas: «usuarios» y «servicios». El tipo de relación entre tablas será «uno a muchos» es decir, un usuario puede tener más de un servicio.
Vamos a hacer clic en el icono «crear tabla» y en la cuadricula hacemos clic para crear la tabla. Verán que se crea como «table1» por lo cual hacemos doble clic en la misma «en el título de la tabla» y se abrirá un panel de opciones inferior donde podremos cambiar el nombre a «usuarios»
En el campo «Name:» colocamos «usuarios». Posteriormente pasamos a «Columns» para crear las columnas donde se almacenará cada dato de los posibles usuarios. En este paso simplemente hacemos clic en los espacios en blanco de esta pestaña y comenzamos a escribir los nombres de cada campo. (Sugiero utilizar siempre minúsculas para facilitar las cosas más adelante en las consultas vía aplicación web).
Como verán, dentro de la tabla usuarios he creado los campos id_email, nombre, apellido, genero y edad. A continuación una breve descripción de las cosas que se aprecian en la imagen:
- Particularmente «id_email» la he nombrado así, para identificar que es el «id» de la tabla. Es decir, un campo único e irrepetible para identificar a cada usuario.
- VARCHAR(45): Indica que ese campo almacenará valores Alfanuméricos y hasta 45 caracteres de longitud.
- INT: Almacenará un valor numérico (Entero).
- PK: Primary Key (llave primaria, valor único)
- NN: Not Null (El campo no puede estar vacío)
Ahora bien, del mismo modo crearemos la tabla servicios y estableceremos la relación entre ambas tablas (para lo cual usamos el botón «1:n» (n = un valor indefinido, es decir, muchos) «uno a muchos».
Habiendo creado la tabla servicios con sus respectivos campos, entonces procedemos a hacer clic en el botón «1:n», primero hacemos clic en «servicios» y luego en «usuarios» de este modo se creará la relación y la «Foreign Key» (el enlace entre ambas tablas, conocido como llave foránea, lo que hace es apuntar a una «PK» Primary Key)
Ahora está todo listo para incluir estos cambios visuales de forma real en nuestra base de datos, para lo cual vamos al menú «Database» > «Forward Engineer» seguimos los pasos sin hacer modificaciones:
Si todo ha salido bien, vamos a comprobar que se aplicaron los cambios en nuestra base, tanto desde phpmyadmin como desde el CLI de MySQL:
¡Finalmente tenemos un lugar para almacenar los datos de nuestra aplicación web!
Crear tablas desde el CLI
Opcionalmente podemos crear las tablas desde el CLI, tan solo necesitamos las sentencias de SQL correctas en un archivo (script) para que las tablas sean creadas. Podemos crear el archivo «tablas_dominio_test.sql» con el siguiente contenido:
-- MySQL Workbench Forward Engineering SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0; SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0; SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='TRADITIONAL,ALLOW_INVALID_DATES'; -- ----------------------------------------------------- -- Schema dominio_test -- ----------------------------------------------------- -- ----------------------------------------------------- -- Schema dominio_test -- ----------------------------------------------------- CREATE SCHEMA IF NOT EXISTS `dominio_test` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci ; USE `dominio_test` ; -- ----------------------------------------------------- -- Table `dominio_test`.`usuarios` -- ----------------------------------------------------- CREATE TABLE IF NOT EXISTS `dominio_test`.`usuarios` ( `id_email` VARCHAR(45) NOT NULL, `nombre` VARCHAR(45) NULL, `apellido` VARCHAR(45) NULL, `genero` VARCHAR(45) NULL, `edad` INT NULL, PRIMARY KEY (`id_email`)) ENGINE = InnoDB; -- ----------------------------------------------------- -- Table `dominio_test`.`servicios` -- ----------------------------------------------------- CREATE TABLE IF NOT EXISTS `dominio_test`.`servicios` ( `id_servicio` INT NOT NULL, `internet` VARCHAR(45) NULL, `agua` VARCHAR(45) NULL, `abl` VARCHAR(45) NULL, `metrogas` VARCHAR(45) NULL, `usuarios_id_email` VARCHAR(45) NOT NULL, PRIMARY KEY (`id_servicio`), INDEX `fk_servicios_usuarios_idx` (`usuarios_id_email` ASC), CONSTRAINT `fk_servicios_usuarios` FOREIGN KEY (`usuarios_id_email`) REFERENCES `dominio_test`.`usuarios` (`id_email`) ON DELETE NO ACTION ON UPDATE NO ACTION) ENGINE = InnoDB; SET SQL_MODE=@OLD_SQL_MODE; SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS; SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;
Y desde nuestro CLI insertar el archivo:
mysql -u root -p dominio_test < tablas_dominio_test.sql
Y el resultado será exactamente el mismo.
Saludos.
Excelente tutorial (incluidos los anteriores), encontré tu página luego de dos años de ser escrita.
Entendí conceptos importantes, pero tengo dudas en cuanto:
¿Por qué se necesita una conexión?
¿Entre que se realiza la conexión, entre el motor MySQL y el cliente Workbench?
¿Que define el root, y el localhost y la misma conexión?
Lo que para otros es fácil de entenderlo para mi se ha vuelto complicado luego de rodar por diversas fuentes de información.
Con tu manera de explicar lo entiendo casi como si dibujaras la clase.
Te quedo eternamente agradecido.
Éxitos.!
Hola Oscar, gracias por el comentario.
¿Por qué se necesita una conexión?
Esto es necesario hacerlo para poder realizar cambios, así como otros sistemas las bases de datos también requieren autenticación.
Puedes realizar conexiones de solo lectura (para extraer información) o conexiones como administrador (para agregar, borrar o modificar datos).
¿Entre que se realiza la conexión, entre el motor MySQL y el cliente Workbench?
En este ejemplo sí. Usamos Workbench como cliente para conectarnos al motor de base de datos y poder hacer cambios en la base, en este caso crear los schemas.
¿Que define el root, y el localhost y la misma conexión?
El root es el usuario default (por defecto) para la base. Eso lo define el que mantiene el producto (en este caso como hablamos de MySQL sería Oracle) y si fuera MaríaDB pues lo definen los que mantienen ese fork.
Localhost es definido a nivel de arquitectura de redes y es un estándar. Cualquier dispositivo con un conector de red (cableado, wifi, etc…) tiene este nombre reservado para identificarse a sí mismo.
Usamos localhost en la conexión porque la base está instalada en nuestra máquina y no en un lugar remoto.
Al juntar el usuario de la base «root» y nuestra pc «localhost» el cliente se conectará al puerto de la base de datos (3306 por defecto), básicamente la conexión sería algo del estilo:
root -> localhost:3306
Donde luego nos pedirá la contraseña para autenticarnos como «root».
Un abrazo.