Desde su introducción, el lenguaje de programación Go (también conocido como Golang) se ha convertido cada vez más popular. Es conocido por su simplicidad y rendimiento eficiente, similar a un lenguaje de bajo nivel como C++.

Mientras se trabaja con una base de datos, la migración de esquema es una de las tareas más importantes que los desarrolladores hacen a lo largo del ciclo de vida del proyecto. En este artículo, te explicaré qué es una migración de base de datos y cómo hacerlo usando go-migrate.

¿Qué es una Migración de Base de Datos?

Una migración de base de datos, también conocido como una migración de esquema, es un conjunto de cambios que serán hechos a una estructura de objetos dentro de una base de datos relacional.

Es una forma de realizar e implementar cambios incrementales a la estructura de datos de una forma controlada y programática. Estos cambios son frecuentemente reversibles, lo que significa que se pueden deshacer o retrotraerse si se requiere.

El proceso de migración ayuda en cambiar el esquema de la base de datos desde su estado actual a un nuevo estado deseado, ya sea que implique agregar tablas y columnas, remover elementos, separar campos, o cambiar tipos y restricciones.

Al manejar estos cambios de una forma programática, se vuelve más fácil de mantener la consistencia y la precisión en la base de datos, así también como mantener un registro del historial de modificaciones que se le hizo.

Configuración e Instalación

migrate es una herramienta CLI que puedes usar para ejecutar migraciones. Puedes instalarlo fácilmente en varios sistemas operativos tales como Linux, Mac y Windows usando gestores de paquetes como curl, brew, y scoop, respectivamente.

Para más información en cómo instalar y usar la herramienta, puedes referirte a la documentación oficial.

Para instalar la herramienta CLI de migrate usando scoop en Windows, puedes seguir estos pasos:

$ scoop install migrate

Para instalar la herramienta CLI de migrate usando curl en Linux, puedes seguir estos pasos:

$ curl -L https://packagecloud.io/golang-migrate/migrate/gpgkey| apt-key add -
$ echo "deb https://packagecloud.io/golang-migrate/migrate/ubuntu/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/migrate.list
$ apt-get update
$ apt-get install -y migrate

Para instalar la herramienta CLI de migrate usando brew en Mac, puedes seguir estos pasos:

$ brew install golang-migrate

Cómo crear una nueva migración

Crear un directorio como database/migration para almacenar todos los archivos de migración.

Luego, crea archivos de migración usando el siguiente comando:

$ migrate create -ext sql -dir database/migration/ -seq init_mg

Usas -seq para generar una versión secuencial y init_mg es el nombre de la migración.

Una migración típicamente consiste de dos archivos distintos, uno para mover la base de datos a un nuevo estado (denominado como "up") y otro para revertir los cambios hechos al estado previo (denominado como "down").

El archivo "up" se usa para implementar los cambios deseados a la base de datos, mientras que el archivo "down" se usa para deshacer esos cambios y volver a la base de datos a su estado previo.

El formato de esos archivos para SQL son:

{version}_{título}.down.sql
{version}_{título}.up.sql

Cuando creas archivos de migración, estarán vacíos por defecto. Para implementar los cambios que quieres, necesitarás rellenarlos con las solicitudes SQL apropiadas.

Cómo ejecutar la Migración Up

Para ejecutar sentencias de SQL en los archivos de migración, la migración requiere de una conexión válida a una base de datos Postgres.

Para lograr esto, necesitarás proveer una cadena de conexión en el formato apropiado.

$ migrate -path database/migration/ -database "postgresql://username:secretkey@localhost:5432/database_name?sslmode=disable" -verbose up

Ahora, en tu terminal de Postgres, puedes verificar las nuevas tablas creadas usando los siguientes comandos:

\d+

\d+ nombre_tabla DESCRIBE TABLE

Cómo retrotraer migraciones

Si quieres revertir la migración, puedes hacerlo usando la siguiente etiquta down:

$ migrate -path database/migration/ -database "postgresql://username:secretkey@localhost:5432/database_name?sslmode=disable" -verbose down

Eliminará la columna email de ambas tablas como se menciona en el archivo 000002_init_mg.up.sql.

Ahora, verifiquemos la base de datos y veamos si email ha sido eliminado o no:

Cómo resolver Errores de Migración

Si una migración contiene un error y se ejecuta, migrate evitará que cualquier migración se ejecute en la misma base de datos.

Un mensaje de error como Dirty database version 1. Fix and force version se mostrará, incluso después que se arregle el error de migración. Esto indica que la base de datos está "sucio" y necesita ser investigado.

Es necesario determinar si la migración fue aplicado parcialmente o no. Una vez que has determinado esto, la versión de la base de datos debería ser forzado a reflejar su estado verdadero usando el comando force.

$ migrate -path database/migration/ -database "postgresql://username:secretkey@localhost:5432/database_name?sslmode=disable" force <VERSION>

Cómo agregar comandos en un archivo Makefile

migration_up: migrate -path database/migration/ -database "postgresql://username:secretkey@localhost:5432/database_name?sslmode=disable" -verbose up

migration_down: migrate -path database/migration/ -database "postgresql://username:secretkey@localhost:5432/database_name?sslmode=disable" -verbose down

migration_fix: migrate -path database/migration/ -database "postgresql://username:secretkey@localhost:5432/database_name?sslmode=disable" force VERSION

Ahora, puedes ejecutar $ make migration_up para 'up', $ make migration_down para 'down', y $ make migration_fix para arreglar el problema de migración.

Antes de ejecutar el makefile, asegúrate que el número correcto de la versión está incluido en el comando migration_fix.

Conclusión

Los sistemas de migración típicamente generan archivos que pueden ser compartidos entre desarrolladores y múltiples equipos. También pueden ser aplicados a múltiples bases de datos y mantenidos en control de versiones.

Mantener un registro de los cambios a la base de datos hace posible el poder rastrear el historial de modificaciones que se le hicieron. De esta forma, el esquema de la base de datos y el entendimiento de la aplicación de esa estructura pueden evolucionar juntos.

Eso concluye nuestra discusión en migración de base de datos. Espero que la información te haya resultado útil e informativo.

Si disfrutaste leer este artículo, por favor considera compartirlos con tus colegas y con tus amigos en las redes. Adicionalmente, por favor considera seguirme en Twitter para más actualizaciones sobre tecnología y programación. ¡Gracias por leer!

Se propuso incluir genéricos en el lenguaje de programación Go hace unos años, y finalmente se aceptó la propuesta formal en el 2021. La versión de G0 1.18 en marzo de 2022 fue el que incluyó, por primera vez, soporte para genéricos.

Pero, ¿cómo se verá afectado Go por los genéricos? ¿Cambiará nuestra manera de escribir el código?

Para poder responder a estas preguntas, tenemos que analizar detalladamente cómo funciona la programación genérica. Afortunadamente, el equipo de Go nos ha proporcionado un compilador de web donde podemos experimentar con genéricos.

Pero, ¿qué es lo que realmente cambia con la introducción de genéricos en Go?

Los genéricos permiten que nuestras funciones o estructuras de datos acepten varios tipos, que se definen en su forma genérica.

Para entender bien lo que significa esta frase, veamos un caso muy simple:

Imaginemos que tienes que hacer una función que tome un fragmento y la imprima. Así, podrías escribir este tipo de función:

func Print(s []string) {
	for _, v := range s {
		fmt.Print(v)
	}
}

Sencillo, ¿verdad? Y, ¿qué pasaría si quisiéramos que ese fragmento sea un entero? Para esto, tendrías que crear un nuevo método:

func Print(s []int) {
	for _, v := range s {
		fmt.Print(v)
	}
}

Estas soluciones podrían parecer redundantes, ya que solo estamos cambiando el parámetro. Sin embargo, así es como lo solucionamos ahora mismo en Go sin tener que recurrir a convertirlo en alguna interfaz.

Ahora con los genéricos, nos permitirán declarar nuestras funciones de esta manera:

func Print[T any](s []T) {
	for _, v := range s {
		fmt.Print(v)
	}
}

En la función de arriba, estamos declarando dos cosas:

1. Por un lado, tenemos T, que es el tipo de la palabra clave any (esta palabra clave se define específicamente como parte de un genérico, lo que indica cualquier tipo)
2. Y nuestro parámetro, donde tenemos la variable s cuyo tipo es una fragmento de T.

Ahora podremos hacer una llamada a nuestro método de esta manera:

func main() {
	Print([]string{"Hello, ", "playground\n"})
	Print([]int{1,2,3})
}

Un método para cualquier tipo de variable: genial, ¿verdad?

Esta es solo una de las implementaciones muy básicas que hay para genéricos. Aun así, ya tiene buena pinta.

Exploremos un poco más y veamos hasta dónde nos pueden llevar los genéricos.

Limitaciones de los genéricos

Hemos visto lo que se puede hacer con los genéricos. Nos permiten especificar una función que puede aceptar cualquier tipo de parámetro.

Pero el ejemplo de antes era muy simple. Existen limitaciones al uso de los genéricos. Imprimir, por ejemplo, es bastante sencillo, ya que Go puede imprimir cualquier tipo de variable que se le agregue.

¿Pero qué pasa si queremos hacer algo más complejo? Vamos a imaginar que hemos definido nuestros propios métodos para una estructura y queremos hacer una llamada:

package main

import (
	"fmt"
)

type worker string

func (w worker) Work(){
	fmt.Printf("%s is working\n", w)
}


func DoWork[T any](things []T) {
    for _, v := range things {
        v.Work()
    }
}

func main() {
	var a,b,c worker
	a = "A"
	b = "B"
	c = "C"
	DoWork([]worker{a,b,c})	
}

Y esto devolvería lo siguiente:

type checking failed for main
prog.go2:25:11: v.Work undefined (type bound for T has no method Work)

No se ejecuta porque la fragmento procesada dentro de la función es de tipo any y no implementa el método Work, lo que hace que no se ejecute.

Podríamos hacer que funcionara usando una interfaz:

package main

import (
	"fmt"
)

type Person interface {
    Work()
}

type worker string

func (w worker) Work(){
	fmt.Printf("%s is working\n", w)
}

func DoWork[T Person](things []T) {
    for _, v := range things {
        v.Work()
    }
}

func main() {
	var a,b,c worker
	a = "A"
	b = "B"
	c = "C"
	DoWork([]worker{a,b,c})
}

Imprimiría lo siguiente:

A is working
B is working
C is working

Funcionaría bien con la interfaz, pero también lo haría con una interfaz sin el genérico:

package main

import (
	"fmt"
)

type Person interface {
    Work()
}

type worker string

func (w worker) Work(){
	fmt.Printf("%s is working\n", w)
}

func DoWorkInterface(things []Person) {
    for _, v := range things {
        v.Work()
    }
}

func main() {
	var d,e,f worker
	d = "D"
	e = "E"
	f = "F"
	DoWorkInterface([]Person{d,e,f})
}

Imprimiría lo siguiente:

D is working
E is working
F is working

El uso de los genéricos solo añade un extra de lógica a nuestro código. Cuando usar solo la interfaz sea suficiente, no habría ningún motivo para añadir genéricos al código.

Los genéricos aún se encuentran en sus primeras fases de desarrollo y todavía tienen límites a la hora de realizar procesamientos complejos.

Jugando con las restricciones

Antes, usamos el tipo any para nuestra restricción genérica. Además de ese tipo, hay algunas otras restricciones que podemos usar.

Una de las restricciones es comparable. Vamos a ver cómo funciona:

func Equal[T comparable](a, b T) bool {
    return a == b
}

func main() {
	Equal("a","a")
}

Aparte de eso, también podemos intentar crear nuestra propia restricción de la siguiente manera:

package main

import(
	"fmt"
)

type Number interface {
    type int, float64
}

func MultiplyTen[T Number](a T) T{
	return a*10
}

func main() {
	fmt.Println(MultiplyTen(10))
	fmt.Println(MultiplyTen(5.55))
}

Y me parece bastante bueno: podemos tener una función para una expresión matemática simple. Por lo general, terminaremos haciendo dos funciones para incorporarlo o usaremos la reflexión, por lo que solo escribiremos una función.

Si bien todo esto es bastante interesante, aún tenemos que experimentar un poco para crear nuestras propias restricciones. Todavía es pronto para conocer todas las limitaciones de los genéricos. Y debemos tener cuidado de no abusar de ellos y usarlos solo si estamos realmente seguros de que sean necesarios.

Otras formas de usar los genéricos

Además de usar los genéricos como parte de una función, también puedes declararlos como variables de la siguiente manera:

type GenericSlice[T any] []T

Y puedes usar esto como un parámetro en una función o puedes crear un método de ese tipo:

func (g GenericSlice[T]) Print() {
	for _, v := range g {
		fmt.Println(v)
	}
}

func Print [T any](g GenericSlice[T]) {
	for _, v := range g {
		fmt.Println(v)
	}
}

func main() {
	g := GenericSlice[int]{1,2,3}
	
	g.Print() //1 2 3
	Print(g) //1 2 3
}

El uso cambiaría según tus necesidades. Diría que todavía tenemos que experimentar más con genéricos para ver qué casos de uso funcionan mejor.

Mi opinión sobre los genéricos

Los genéricos están todavía en sus fases iniciales, pero estoy bastante impresionado con la forma en la que se gestionan. No hace falta saber muchos términos complicados ni muchas librerías para implementar genéricos, y esta simplicidad es lo que hace que sean geniales.

Hay varios casos de uso en los que ya puedo intuir que usar genéricos será mejor, como por ejemplo en el caso con el método de multiplicación. Una cosa que a lo mejor confunde a la gente es que los genéricos podrían ser un sustituto para el uso de interfaces (tanto el tipo de interfaz{} como la implementación de la interfaz).

Mi consejo es no pensar en los genéricos como un sustituto de nada. Los genéricos son simplemente una herramienta más al alcance de los desarrolladores. Por otro lado, aunque los genéricos te parezcan elegantes y geniales, y quieras usarlos en cada bloque de tu código, te aconsejo que no los uses en exceso; úsalos cuando realmente los necesites y no los metas en todos los sitios en donde puedan encajar.

Eso es todo. Gracias por leer mi artículo, y espero sinceramente que los genéricos te puedan resultar útiles.

¡Qué disfrutéis de los genéricos!