Crear Bases de Datos MySQL con PHP

La integración de PHP con bases de datos es fundamental para construir aplicaciones web dinámicas y robustas. MySQL es uno de los sistemas de gestión de bases de datos más populares utilizado junto a PHP. Poder crear y estructurar bases de datos directamente desde tus scripts PHP te da un control total sobre el entorno de tu aplicación. En este artículo, exploraremos cómo realizar estas tareas esenciales: conectar a la base de datos, crear una nueva base de datos, seleccionarla para su uso y, finalmente, definir las tablas que almacenarán tu información.

Históricamente, la extensión `mysql_*` fue la forma principal de interactuar con MySQL desde PHP. Aunque encontrarás ejemplos antiguos que la utilizan, es crucial entender que esta extensión está obsoleta (deprecada) desde PHP 5.5.0 y ha sido eliminada por completo en PHP 7. Por razones de seguridad, rendimiento y funcionalidad, siempre debes utilizar extensiones modernas como MySQLi (MySQL Improved) o PDO (PHP Data Objects). Aunque el material de referencia original utiliza las funciones antiguas, te mostraremos cómo realizar las mismas acciones con las alternativas recomendadas.

Estableciendo la Conexión con MySQL

Antes de poder crear una base de datos o una tabla, tu script PHP debe establecer una conexión con el servidor de base de datos MySQL. Para ello, necesitas conocer la dirección del servidor (host), el nombre de usuario y la contraseña. Es vital que el usuario tenga los permisos adecuados para realizar las operaciones que necesitas (en este caso, crear bases de datos y tablas).

La forma antigua (y NO recomendada) era usar `mysql_connect()`:

<?php $dbhost = 'localhost:3036'; $dbuser = 'root'; $dbpass = 'rootpassword'; // Conexión usando la extensión mysql_* (NO USAR EN CÓDIGO NUEVO) $conn = mysql_connect($dbhost, $dbuser, $dbpass); if(! $conn ) { die('No se pudo conectar: ' . mysql_error()); } echo 'Conectado exitosamente usando mysql_*'; mysql_close($conn); ?>

Este código, aunque funcional en versiones antiguas de PHP, es vulnerable y carece de características modernas. La forma correcta y segura de conectar es usando MySQLi o PDO.

Conexión con MySQLi (Orientado a Objetos)

MySQLi ofrece una interfaz orientada a objetos que es más intuitiva y potente:

<?php $dbhost = 'localhost'; // El puerto 3036 usualmente no va aquí, sino en el puerto por defecto o configurado $dbuser = 'root'; $dbpass = 'rootpassword'; $dbname = 'test_db'; // Opcional, si quieres conectar y seleccionar la BD al mismo tiempo // Conexión usando MySQLi (Orientado a Objetos) $conn = new mysqli($dbhost, $dbuser, $dbpass, $dbname); // Verificar conexión if ($conn->connect_error) { die('Error de Conexión (' . $conn->connect_errno . ') ' . $conn->connect_error); } echo 'Conectado exitosamente usando MySQLi (OO)'; // Cerrar conexión $conn->close(); ?>

Observa cómo la verificación de errores es más explícita y la sintaxis es orientada a objetos.

Conexión con PDO (PHP Data Objects)

PDO es una capa de abstracción de bases de datos que te permite usar el mismo código para diferentes sistemas de bases de datos (MySQL, PostgreSQL, SQLite, etc.). Es altamente recomendable por su flexibilidad y características de seguridad como las sentencias preparadas.

<?php $dbhost = 'localhost'; $dbport = '3036'; // El puerto se especifica en el DSN para PDO $dbuser = 'root'; $dbpass = 'rootpassword'; $dbname = 'test_db'; // Opcional, si quieres conectar y seleccionar la BD al mismo tiempo $dsn = "mysql:host=$dbhost;port=$dbport;dbname=$dbname;charset=utf8"; // DSN (Data Source Name) try { // Conexión usando PDO $conn = new PDO($dsn, $dbuser, $dbpass); // Configurar el modo de error para lanzar excepciones (recomendado) $conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); echo 'Conectado exitosamente usando PDO'; } catch (PDOException $e) { die('Error de Conexión: ' . $e->getMessage()); } // La conexión se cierra automáticamente cuando el objeto PDO se destruye (por ejemplo, al final del script) // Opcionalmente, puedes forzarlo: $conn = null; ?>

PDO utiliza bloques `try...catch` para manejar errores, lo que es una práctica moderna en PHP.

Creando una Nueva Base de Datos

Una vez conectado al servidor MySQL, puedes crear una nueva Base de Datos utilizando el comando SQL `CREATE DATABASE`. Este comando se ejecuta a través de la función o método de ejecución de consultas de la extensión que estés utilizando.

Con la extensión `mysql_*` (NO USAR):

<?php // ... código de conexión mysql_connect ... $sql = 'CREATE DATABASE test_db'; $retval = mysql_query( $sql, $conn ); if(! $retval ) { die('No se pudo crear la base de datos: ' . mysql_error()); } echo "Base de datos test_db creada exitosamente\n"; mysql_close($conn); ?>

Con MySQLi (Orientado a Objetos):

<?php // ... código de conexión mysqli (sin especificar DBName en new mysqli) ... $sql = "CREATE DATABASE test_db"; if ($conn->query($sql) === TRUE) { echo "Base de datos test_db creada exitosamente\n"; } else { echo "Error al crear la base de datos: " . $conn->error; } $conn->close(); ?>

Con PDO:

<?php // ... código de conexión PDO (sin especificar DBName en el DSN) ... $sql = "CREATE DATABASE test_db"; try { $conn->exec($sql); // Usar exec() para comandos que no retornan resultados (CREATE, DROP, ALTER) echo "Base de datos test_db creada exitosamente\n"; } catch (PDOException $e) { echo "Error al crear la base de datos: " . $e->getMessage(); } $conn = null; ?>

Es fundamental verificar siempre el resultado de la operación para saber si fue exitosa o si ocurrió algún error.

Seleccionando la Base de Datos Activa

En muchos casos, después de conectar al servidor, necesitas especificar con qué base de datos específica vas a trabajar, especialmente si tu conexión inicial no la seleccionó. Esto asegura que las operaciones posteriores (como crear tablas o insertar datos) se realicen en la base de datos correcta.

Con la extensión `mysql_*` (NO USAR):

<?php // ... código de conexión mysql_connect ... mysql_select_db( 'test_db' ); echo 'Base de datos test_db seleccionada exitosamente'; mysql_close($conn); ?>

Con MySQLi:

Puedes seleccionar la base de datos al momento de la conexión inicial (`new mysqli($host, $user, $pass, $dbname)`) o después de conectar usando el método `select_db()`:

<?php // ... código de conexión mysqli (sin especificar DBName inicialmente) ... $dbname = 'test_db'; if ($conn->select_db($dbname)) { echo "Base de datos {$dbname} seleccionada exitosamente\n"; } else { echo "Error al seleccionar la base de datos {$dbname}: " . $conn->error; } $conn->close(); ?>

Con PDO:

La forma más común de seleccionar la base de datos con PDO es especificándola directamente en el DSN al momento de conectar (`dbname=test_db`). Una vez conectado a una base de datos específica, no necesitas una función separada para seleccionarla, ya que la conexión ya está en el contexto de esa base de datos.

Creando Tablas para Almacenar Datos

Una vez que tienes tu base de datos, el siguiente paso es definir la estructura donde se almacenarán tus datos. Esto se hace creando Tablas. Las tablas se definen utilizando el comando SQL `CREATE TABLE`, especificando los nombres de las columnas, sus tipos de datos y restricciones (como `NOT NULL`, `PRIMARY KEY`, `AUTO_INCREMENT`, etc.).

Con la extensión `mysql_*` (NO USAR):

<?php // ... código de conexión mysql_connect ... mysql_select_db('test_db'); // Asegurarse de que la BD está seleccionada $sql = 'CREATE TABLE employee( '. 'emp_id INT NOT NULL AUTO_INCREMENT, '. 'emp_name VARCHAR(20) NOT NULL, '. 'emp_address VARCHAR(20) NOT NULL, '. 'emp_salary INT NOT NULL, '. 'join_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, '. 'primary key ( emp_id ))'; $retval = mysql_query( $sql, $conn ); if(! $retval ) { die('No se pudo crear la tabla: ' . mysql_error()); } echo "Tabla employee creada exitosamente\n"; mysql_close($conn); ?>

Nota: El tipo `timestamp(14)` es obsoleto en MySQL 5.6.4+. El tipo `TIMESTAMP` sin longitud es el estándar actual y `DEFAULT CURRENT_TIMESTAMP` es común para asignar la fecha/hora actual por defecto.

Con MySQLi (Orientado a Objetos):

<?php // ... código de conexión mysqli (asegurarse de que la BD está seleccionada, ya sea en la conexión o con select_db) ... $sql = "CREATE TABLE employee(" . "emp_id INT NOT NULL AUTO_INCREMENT, " . "emp_name VARCHAR(20) NOT NULL, " . "emp_address VARCHAR(20) NOT NULL, " . "emp_salary INT NOT NULL, " . "join_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, " . "primary key ( emp_id ))"; if ($conn->query($sql) === TRUE) { echo "Tabla employee creada exitosamente\n"; } else { echo "Error al crear la tabla: " . $conn->error; } $conn->close(); ?>

Con PDO:

<?php // ... código de conexión PDO (asegurarse de que la BD está seleccionada en el DSN) ... $sql = "CREATE TABLE employee(" . "emp_id INT NOT NULL AUTO_INCREMENT, " . "emp_name VARCHAR(20) NOT NULL, " . "emp_address VARCHAR(20) NOT NULL, " . "emp_salary INT NOT NULL, " . "join_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, " . "primary key ( emp_id ))"; try { $conn->exec($sql); // Usar exec() para comandos que no retornan resultados echo "Tabla employee creada exitosamente\n"; } catch (PDOException $e) { echo "Error al crear la tabla: " . $e->getMessage(); } $conn = null; ?>

Si necesitas crear múltiples tablas o ejecutar un script SQL más complejo, es una buena práctica almacenar el código SQL en un archivo de texto (`.sql`) y leerlo desde PHP para ejecutarlo. Esto mantiene tu código PHP más limpio.

Ejemplo leyendo de un archivo (aplicable a MySQLi y PDO):

<?php // ... código de conexión mysqli o PDO (asegurarse de que la BD está seleccionada) ... $query_file = 'sql_schema.sql'; // Archivo con los comandos CREATE TABLE, etc. if (file_exists($query_file)) { $sql = file_get_contents($query_file); // Para MySQLi (puede necesitar dividir el script si contiene varios comandos separados por ;) // $conn->multi_query($sql); // O ejecutar comando por comando tras dividir el string $sql // Para PDO (puede necesitar dividir el script si contiene varios comandos separados por ;) // $conn->exec($sql); // Similarmente, exec() sólo ejecuta la primera consulta si hay varias separadas por ; // Una forma más robusta es dividir el script en consultas individuales si contiene múltiples comandos CREATE TABLE, etc. $sql_commands = explode(';', $sql); foreach ($sql_commands as $command) { $command = trim($command); if ($command) { // Evitar ejecutar comandos vacíos try { // Usar exec para PDO, query para MySQLi, dependiendo de tu conexión // Ejemplo con PDO: $conn->exec($command); echo "Comando ejecutado: " . substr($command, 0, 50) . "... <br>\n"; // Mostrar parte del comando ejecutado } catch (PDOException $e) { echo "Error al ejecutar comando: " . substr($command, 0, 50) . "... Error: " . $e->getMessage() . "<br>\n"; // O manejar el error de forma más sofisticada } } } echo "Script SQL ejecutado.\n"; } else { die("Error: Archivo SQL no encontrado."); } // ... cerrar conexión (si no usas PDO y no estás al final del script) ... ?>

Este enfoque de leer un archivo SQL es especialmente útil para scripts de instalación o actualización de bases de datos complejas.

Cerrando la Conexión

Aunque PHP generalmente cierra las conexiones de base de datos al finalizar la ejecución del script, es una buena práctica cerrarlas explícitamente cuando ya no son necesarias. Esto libera recursos del servidor de base de datos.

Con la extensión `mysql_*` (NO USAR):

<?php // ... código con conexión y operaciones ... mysql_close($conn); ?>

Con MySQLi (Orientado a Objetos):

<?php // ... código con conexión y operaciones ... $conn->close(); ?>

Con PDO:

La conexión PDO se cierra estableciendo la variable que contiene el objeto a `null`. Esto destruye el objeto y cierra la conexión subyacente.

<?php // ... código con conexión y operaciones ... $conn = null; ?>

Comparativa de Extensiones

Preguntas Frecuentes

¿Por qué insisten tanto en no usar mysql_*?

Porque es una extensión antigua que no recibe actualizaciones, carece de características de seguridad modernas como las sentencias preparadas de forma nativa y fue completamente eliminada en PHP 7. Usarla expone tu aplicación a graves vulnerabilidades de seguridad, como la inyección SQL, y no funcionará en entornos PHP modernos.

¿Cuál debo elegir entre MySQLi y PDO?

Si estás seguro de que tu aplicación *siempre* usará MySQL (o MariaDB), MySQLi es una excelente opción, con un rendimiento ligeramente superior en algunos casos específicos de MySQL. Si tu aplicación podría necesitar conectarse a otros tipos de bases de datos en el futuro o si prefieres una capa de abstracción general, PDO es la elección más flexible y portátil.

¿Necesito permisos especiales para crear bases de datos o tablas?

Sí. El usuario de MySQL con el que te conectas desde PHP debe tener los permisos `CREATE DATABASE` para crear bases de datos y `CREATE TABLE` (dentro de la base de datos correspondiente) para crear tablas. El usuario `root` por defecto suele tener estos permisos, pero en entornos de producción es mejor usar usuarios con permisos más restringidos.

¿Puedo ejecutar varios comandos SQL (como múltiples CREATE TABLE) en una sola llamada?

Depende de la extensión y el método. `mysql_query()` (obsoleta) solo ejecutaba una consulta a la vez. MySQLi tiene un método `multi_query()` específicamente para esto. PDO por defecto solo ejecuta la primera consulta con `exec()` o `query()`; para ejecutar múltiples comandos separados por punto y coma desde un script, necesitarías leer el archivo y dividir el contenido en consultas individuales para ejecutarlas una por una, como se mostró en el ejemplo de lectura de archivo.

Conclusión

Crear bases de datos y tablas desde PHP es una habilidad esencial para el desarrollo web. Si bien los ejemplos históricos pueden mostrar el uso de funciones obsoletas, la clave para el desarrollo moderno es utilizar extensiones seguras y eficientes como MySQLi o PDO. Al dominar la conexión, la creación de la Base de Datos y la definición de la Tabla, puedes construir aplicaciones que gestionen y persistan datos de manera efectiva y segura.

Si quieres conocer otros artículos parecidos a Crear Bases de Datos MySQL con PHP puedes visitar la categoría Bases de datos.