Introducción

1

Manejo de Datos en Node.js con Postgres y MySQL

2

Persistencia de Datos con Node.js y PostgreSQL

Base de datos

3

Programación de Servidores con Node.js y Docker para Principiantes

4

Ejecuta Postgres en Docker: Configuración y Persistencia de Datos

5

Conexión de Node.js a una Base de Datos PostgreSQL

6

Conexión de Node.js a PostgreSQL usando Driver PG

7

Conexiones eficientes en Node.js con pool de PostgreSQL

8

Variables de Entorno en Node.js: Seguridad y Configuración

Sequelize

9

ORMs: Uso de Sequelize para Conectar y Consultar en PostgreSQL

10

Creación de Modelos y Esquemas con ORM SQLAlchemy

11

CRUD con ORM en JavaScript: Crear, Leer, Actualizar y Eliminar

12

Conexión a MySQL usando Docker y manejo de errores con ORM

Migraciones

13

Migraciones de Bases de Datos con SQLite: Configuración y Uso

14

Migraciones en SQLite: Creación y Ejecución de Scripts

15

Migraciones en SQL: Agregar Campos a Tablas Existentes

Relaciones

16

Relaciones uno a uno en bases de datos relacionales

17

Relaciones uno a uno con Sequelize: asociaciones y restricciones únicas

18

Manejo de Relaciones Uno a Muchos en SQLite con JavaScript

19

Relaciones Uno a Muchos con Sequelize en Node.js

Consultas

20

Relaciones Muchos a Muchos en Base de Datos con SQL

21

Relaciones Muchos a Muchos en SQLite: Creación y Configuración

22

Manipulación de Relaciones Muchos a Muchos en SQLite

23

Paginación en SQL: Uso de LIMIT y OFFSET para Consultas Eficientes

24

Filtros avanzados en SQLite: rangos y operadores numéricos

Despliegue

25

Configuración Heroku y PostgreSQL: Deployment Productivo

26

Buenas prácticas para migraciones en bases de datos de producción

Próximos pasos

27

Migraciones avanzadas en bases de datos con PostgreSQL

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Migraciones de Bases de Datos con SQLite: Configuración y Uso

13/27
Recursos

¿Qué son las migraciones en bases de datos y por qué son importantes?

Las migraciones de bases de datos son un aspecto crucial en el manejo de bases de datos relacionales, especialmente cuando trabajamos con frameworks. Básicamente, son un método que permite implementar y gestionar cambios en la estructura de una base de datos de manera controlada. Diferentes frameworks, como Django en Python, Laravel en PHP y SQLite, definen las migraciones como un sistema de control de versiones para los esquemas de bases de datos.

¿Cómo funcionan las migraciones en distintos frameworks?

  • Django: Propaga cambios en los modelos y los refleja en el esquema de la base de datos.
  • Laravel: Funcionan como un sistema de control de versiones para la base de datos.
  • SQLite: También son un sistema de control de versiones que maneja los cambios desde el código y permite hacer un seguimiento de los mismos en la base de datos.

¿Por qué utilizar un sistema de migraciones?

  1. Mantener un historial: Se lleva un registro del historial del esquema en la base de datos, lo que es esencial para comprender en qué punto se encuentran las modificaciones hechas.

  2. Replicación precisa: Permite replicar configuraciones y cambios con exactitud en entornos productivos sin reescribir datos innecesarios o crear tablas duplicadas.

  3. Lanzamientos controlados: Facilita el envío de "releases" de software al asegurar que la estructura de la base de datos se actualiza de manera coherente y controlada cada vez que se lanza un nuevo feature.

¿Cómo implementar migraciones con SQLite?

Implementar un sistema de migraciones con SQLite requiere ciertos pasos y configuraciones. Debemos ser cautelosos, ya que hacer cambios directamente en un entorno de producción sin un sistema de migraciones puede conllevar riesgos significativos.

¿Cómo configurar el entorno para migraciones?

Para empezar a trabajar con migraciones en SQLite, debemos seguir los siguientes pasos:

  1. Instalación del CLI de SQLite: Este proporciona las herramientas necesarias para generar el boilerplate de migraciones. Se puede instalar y guardar como una dependencia de desarrollo.

  2. Creación de archivos y carpetas necesarias:

    • Crear un archivo de configuración llamado .sequelizerc.
    • Configurar los paths de modelos, migraciones y semillas de datos.
  3. Configuración de la conexión a la base de datos:

    • Crear un archivo config.js que contenga las credenciales y detalles de la conexión a la base de datos, reutilizando la configuración existente.
    • Definir ambientes de desarrollo y producción para una mayor flexibilidad y control.

¿Qué son las semillas de datos y cuál es su utilidad?

Las semillas de datos son conjuntos de información que se cargan en la base de datos, frecuentemente usadas para pruebas unitarias o de integración. Son una forma eficiente de proveer a la base de datos de datos iniciales o de prueba.

¿En qué consisten las configuraciones adicionales para migraciones?

Una vez que el entorno inicial está configurado, podemos avanzar para generar y correr migraciones eficientemente. Aquí es donde realmente vemos los beneficios de haber configurado nuestras rutas y conexiones de manera adecuada. Esto nos permite:

  • Gestionar los cambios: Asegurarnos de que cualquier modificación en la estructura de la base de datos sea controlada y rastreada.
  • Ejecutar migraciones en producción: Importante para trabajar con servicios de despliegue como Heroku, asegurando una integración y adaptación fluida al entorno productivo.

¡Con todas estas herramientas y conocimientos, estás preparado para gestionar bases de datos de manera efectiva y profesional! Si bien puede parecer complicado al principio, el uso de un sistema de migraciones aporta un nivel de seguridad y control que es invaluable en el desarrollo de software. Continúa explorando y practicando para dominar esta habilidad crítica.

Aportes 20

Preguntas 13

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Ya he visto varios archivos que terminan en rc, solo para satisfacer mi curiosidad lo investigue y les comparto:
rc: “run commands”, se usa en sistemas unix como pre-ejecutador de un archivo, carga esos comandos antes de proceder con la rutina normal de ejecución

Las migraciones son:

Las migraciones son la forma en que Django propaga cambios en los modelos y los refleja en el esquema de bases de datos. - Django.

Las migraciones son como un sistema de control de versiones para la base de datos. - Laravel.

Es como un sistema de control de versiones para manejar los cambios desde el código y trackear los cambios en la base de datos. - Sequelize.

Básicamente, las migraciones mantienen el historial del esquema que se lleva en la base de datos. Es un sistema muy usado en ambientes de producción para trackear los cambios sin tener que replicar todo nuevamente (creación de tablas, llaves foráneas, etc). Es decir, permite saber en qué punto estaba para saber qué es lo que se tiene que modificar.

sequelize.sync() empieza a leer los modelos, crea tablas y hace relist (se sobrescribe información), no se aconseja que se corra en producción. Es mejor sincronizar con un sistema de migraciones.

Para correr migraciones se utiliza la librería sequelize-cli y se instala como dependencia de desarrollo con el comando npm i sequelize-cli -D.

Posteriormente, se crea un archivo de configuración .sequelizerc en la carpeta principal.

.sequelizerc:

module.exports = {
  'config': './db/config.js',
  'models-paths: './db/models',
  'migrations-paths: './db/migrations',
  'seeders-path': './db/seeders',
}
  • config → Dónde se encuentra la configuración, esta configuración se encuentra la conexión hacia la BD. El cli tiene su propia conexión, independientemente de la conexión de la aplicación porque esas conexiones corren a nivel de terminal.

  • models-paths → Dónde se encuentran los modelos.

  • migrations-paths → Dónde se encuentran las migraciones.

  • seeders-path → Dónde se encuentran las semillas de información, sirve mucho para pruebas unitarias, end to end, donde se necesitan semillas de información que es como cargar varios datos de información a la BD.


Se crean las carpetas migrations, models, seeders y el archivo config.js dentro de la carpeta db.

Sync se pronuncia como si lo estuvieras leyendo en español, “sinc”.
Therefore no es sin embargo, es POR LO TANTO, cambia un poco el sentido de la definición que da el profe, solo para aclarar

Por lo que entendí

Las migraciones son como un git para bases de datos relacionales, para no tener que reemplazar toda la base de datos sino solo agregar los cambios correspondientes.

Pase por aquí que está explicado a detalle lo de las migraciones en sequelize.

Como cuesta de la clase n°13 a la n°19! 😦 pero a no bajar esos BRAZOS!! 😃

Analogía de las Migraciones de una Base de Datos con Git:
No sobrescriben ni guardan todo (eso es ineficiente), solo guardan los cambios.
·
En el mundo de las bases de datos, una migración se refiere a la transferencia de datos y esquemas de una base de datos a otra, y es un proceso que se utiliza para actualizar o mover datos de una base de datos a otra o para cambiar la estructura de una base de datos ya existente ✨.
·
Las migraciones pueden ser necesarias por diferentes razones, como por ejemplo, cuando se quiere actualizar a una nueva versión de una base de datos o cuando se necesita cambiar la estructura de la base de datos en sí. Sin embargo, las migraciones también pueden ser muy útiles para mantener un “registro” de los cambios realizados en una base de datos, de modo que en lugar de realizar los cambios manualmente o tener que sobrescribir toda la estructura de la base de datos y los datos almacenados en ella cada vez, la migración permite mantener un historial de los cambios que se han ido realizando, mejorando así la eficiencia y la fiabilidad de su gestión 🙏.
·
Esto en cierta forma es similar a cómo Git mantiene un control y registro de versiones a partir de los cambios en el código fuente. Solo que, mientras Git se enfoca en el seguimiento de cambios a nivel de archivo (donde cada cambio realizado en un archivo específico se guarda como una nueva versión del archivo en el repositorio), las Migraciones —en vez de rastrear cambios a nivel de archivo— se enfocan en el seguimiento de los cambios en la estructura y los datos de la base de datos: Guardando series de instrucciones SQL que se aplican a la base de datos para actualizar su estructura y sus datos 😎.

Esto es Django ya esta todo configurado y es automático, ahora veo el trabajo que nos ahorramos al usar frameworks

He tenido muchas dificultades con este curso, en lo personal no me gusta el docente. Deseo comentar: a quienes, después de apagar el computador, estando todo bien y cuando se vuelva aprender no se logra levantar docker en mysql y postgres, se debe cambiar el puerto de acceso, no es problema del firwell y si hay dificultad con pgadmin4, se debe cambiar la ip por el gateway

con el comando: npx sequelize-cli init // te crea en automático la carpeta db ademas de sus otros componentes ya lo otro seria cambiar cosas, yo lo probé porque estuve leyendo la documentación de sequelize.

.sequelizerc

module.exports = {
  'config': './db/config.js',
  'models-path': './db/models/',
  'migrations-path': './db/migrations/',
  'seeders-path': './db/seeders/',
}

Otra manera de realizar la configuracion es la que sugiere la documentacion de sequelize en la parte del archivo .sequelizerc en donde viene sugerida de la siguiente manera:

// .sequelizerc

const path = require('path');

module.exports = {
  'config': path.resolve('config', 'database.json'),
  'models-path': path.resolve('db', 'models'),
  'seeders-path': path.resolve('db', 'seeders'),
  'migrations-path': path.resolve('db', 'migrations')
};

De igual manera se puede editar esa configuracion para personalizar los nombres de las carpetas, tambien el archivo database.json arrojara una configuracion por defecto.

Qué son las Migraciones?

Al igual que utilizas sistemas de control de versiones como Git para gestionar los cambios en tu código fuente, puedes utilizar migraciones para llevar un registro de los cambios en la base de datos. Con las migraciones, puedes transferir tu base de datos existente a otro estado y viceversa: esas transiciones de estado se guardan en archivos de migración, que describen cómo llegar al nuevo estado y cómo revertir los cambios para volver al estado anterior.


Ejemplo

Supongamos que tenemos una aplicación que almacena usuarios en una base de datos. La aplicación comienza con una tabla de usuarios que solo tiene dos campos: id y nombre.

Para agregar un nuevo campo a la tabla de usuarios, podemos crear una migración. El archivo de migración tendrá el siguiente contenido:

// Crear una migración para agregar un campo `email` a la tabla `usuarios`

module.exports = {
  up: (queryInterface) => {
    return queryInterface.addColumn('usuarios', 'email', {
      type: Sequelize.STRING,
      allowNull: false,
    });
  },

  down: (queryInterface) => {
    return queryInterface.removeColumn('usuarios', 'email');
  },
};

Para ejecutar la migración, podemos usar el siguiente comando:

sequelize migration:run

Este comando ejecutará la función up() del archivo de migración, que agregará el campo email a la tabla de usuarios.

Para revertir la migración, podemos usar el siguiente comando:

sequelize migration:revert

Este comando ejecutará la función down() del archivo de migración, que eliminará el campo email de la tabla de usuarios.

En este ejemplo sencillo, la migración solo realiza un cambio simple en la base de datos. Sin embargo, las migraciones se pueden usar para realizar cambios más complejos, como agregar nuevas tablas, modificar el esquema de una tabla o eliminar tablas.

Aquí hay algunos ejemplos más de cómo se pueden usar las migraciones:

  • Agregar una nueva columna a una tabla
  • Modificar el tipo de una columna
  • Agregar una restricción de clave externa
  • Eliminar una columna
  • Eliminar una tabla

Las migraciones son una herramienta poderosa que puede ayudar a los desarrolladores a realizar cambios en la base de datos de forma controlada y segura.

efinitivamente en esta clase me e vuelto experto en leer los errores y bucar la terminal es increible que no bien busco la solucion a una cosa y ya tengo que arreglaro otra

Las migraciones de bases de datos son una forma de gestionar y versionar los cambios en el esquema de la base de datos a lo largo del tiempo. Esto permite mantener una estructura de base de datos consistente y actualizada, especialmente en entornos de desarrollo y producción donde múltiples instancias de la aplicación pueden estar ejecutándose.

En el contexto de Sequelize, las migraciones se utilizan para describir los cambios en el esquema de la base de datos. Cada migración es un archivo que contiene instrucciones para realizar un cambio específico, como agregar una nueva tabla, modificar una columna existente o eliminar una restricción.

Veamos un ejemplo concreto:

Supongamos que tienes un modelo User con las siguientes propiedades:

// models/user.js

const { Sequelize, Model, DataTypes } = require('sequelize');

class User extends Model {}

User.init(
  {
    id: {
      type: DataTypes.INTEGER,
      primaryKey: true,
      autoIncrement: true,
    },
    username: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
    },
    email: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false,
    },
  },
  {
    sequelize, // pasando la instancia de Sequelize
    modelName: 'User',
  }
);

module.exports = User;

Ahora, supongamos que necesitas agregar una nueva columna llamada createdAt a tu modelo User. Puedes lograr esto usando migraciones.

  1. Creación de Migración:

    Ejecutas el siguiente comando para generar una nueva migración:

    npx sequelize-cli migration:generate --name add_createdAt_column_to_users
    

    Esto creará un nuevo archivo en el directorio migrations con un nombre como 20220106123456-add_createdAt_column_to_users.js. Abres este archivo y defines las instrucciones necesarias para realizar el cambio:

    // migrations/20220106123456-add_createdAt_column_to_users.js
    
    'use strict';
    
    module.exports = {
      up: async (queryInterface, Sequelize) => {
        await queryInterface.addColumn('Users', 'createdAt', {
          type: Sequelize.DATE,
          allowNull: false,
          defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
        });
      },
    
      down: async (queryInterface, Sequelize) => {
        await queryInterface.removeColumn('Users', 'createdAt');
      },
    };
    

    La función up describe cómo aplicar el cambio (en este caso, agregar una columna createdAt), mientras que la función down describe cómo revertir el cambio.

  2. Aplicación de Migración:

    Ahora, puedes ejecutar el siguiente comando para aplicar la migración:

    npx sequelize-cli db:migrate
    

    Esto ejecutará la función up de todas las migraciones pendientes y aplicará los cambios en la base de datos.

  3. Reversión de Migración:

    En caso de que necesites revertir la migración, puedes ejecutar:

    npx sequelize-cli db:migrate:undo
    

    Esto ejecutará la función down de la migración más reciente, revirtiendo el último cambio.

Las migraciones ofrecen una forma estructurada de gestionar la evolución de la base de datos, especialmente cuando colaboras con otros desarrolladores o despliegas tu aplicación en diferentes entornos.

Aunque es cierto que es recomendado hacer la sincronización con migraciones, la definición que lee el profesor habla específicamente de las opciones { force: true } y { alter: true } que se pueden usar en el método sync(), ya que, como dice en la misma documentación, estas opciones pueden destruir información existente. Si se usa el método sync() sin opciones, este no destruye la información existente, sin embargo, es mala práctica porque, si la tabla ya existe, no se realizarán los cambios que se requieran en los modelos.

Los últimos minutos del video no se escucha nada

La migraciones están buenísimas, lamentablemente no hay una manera de implementarlas usando TS (hasta donde he podido investigar, pero si alguien conoce una y pudiera compartirla estaría muy agradecido).

a este nivel, me comence a preguntarme… y los backups donde quedan? encontre googleando este aporte de alguien de platzi espero que le sirva: https://platzi.com/tutoriales/1480-postgresql/2252-como-generar-una-backup-de-postgresql-y-como-restaurarla/

https://sequelize.org/docs/v6/other-topics/migrations/ la parte de las migraciones en sequelize