El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Usando ORM

Siguiente ►
►

En este módulo, aprenderemos a utilizar un ORM (Object-Relational Mapping) en Go para interactuar con bases de datos de manera más eficiente y con menos código repetitivo. Un ORM permite mapear estructuras de datos en Go a tablas en una base de datos relacional, facilitando las operaciones CRUD (Crear, Leer, Actualizar, Eliminar).

¿Qué es un ORM?

Un ORM es una técnica de programación que permite convertir datos entre sistemas incompatibles usando lenguajes de programación orientados a objetos. En el contexto de Go, un ORM nos permite trabajar con bases de datos relacionales de una manera más intuitiva y menos propensa a errores.

Ventajas de usar un ORM:

  • Abstracción de SQL: No necesitas escribir consultas SQL manualmente.
  • Mantenimiento: Facilita el mantenimiento del código.
  • Seguridad: Reduce el riesgo de inyecciones SQL.
  • Productividad: Acelera el desarrollo al reducir el código repetitivo.

Configuración del Entorno

Para este módulo, utilizaremos GORM, uno de los ORMs más populares en Go. Asegúrate de tener una base de datos configurada (por ejemplo, PostgreSQL, MySQL, SQLite) y sigue los pasos a continuación para instalar GORM.

Instalación de GORM

  1. Instalar GORM y el controlador de la base de datos:

    go get -u gorm.io/gorm
go get -u gorm.io/driver/sqlite

  2. Importar GORM y el controlador en tu archivo Go:

    import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
)

Conectando a la Base de Datos

Vamos a conectar GORM a una base de datos SQLite para este ejemplo.

Ejemplo de Conexión

package main

import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "log"
)

func main() {
    // Conectar a la base de datos
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        log.Fatal("failed to connect database")
    }

    // Migrar el esquema
    db.AutoMigrate(&Product{})
}

Definiendo Modelos

En GORM, los modelos son estructuras de Go que representan tablas en la base de datos.

Ejemplo de Modelo

type Product struct {
    gorm.Model
    Code  string
    Price uint
}
  • gorm.Model es una estructura que incluye campos como ID, CreatedAt, UpdatedAt, y DeletedAt.

Operaciones CRUD

Crear

func createProduct(db *gorm.DB) {
    product := Product{Code: "D42", Price: 100}
    db.Create(&product)
}

Leer

func getProduct(db *gorm.DB, code string) Product {
    var product Product
    db.First(&product, "code = ?", code)
    return product
}

Actualizar

func updateProduct(db *gorm.DB, code string, newPrice uint) {
    var product Product
    db.First(&product, "code = ?", code)
    product.Price = newPrice
    db.Save(&product)
}

Eliminar

func deleteProduct(db *gorm.DB, code string) {
    var product Product
    db.Delete(&product, "code = ?", code)
}

Ejercicio Práctico

Ejercicio

  1. Configura una base de datos SQLite y conecta GORM a ella.
  2. Define un modelo User con los campos ID, Name, y Email.
  3. Implementa funciones para crear, leer, actualizar y eliminar usuarios.

Solución

package main

import (
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "log"
)

type User struct {
    gorm.Model
    Name  string
    Email string
}

func main() {
    db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
    if err != nil {
        log.Fatal("failed to connect database")
    }

    db.AutoMigrate(&User{})

    createUser(db, "John Doe", "[email protected]")
    user := getUser(db, "[email protected]")
    log.Println("User:", user)

    updateUser(db, "[email protected]", "John Smith")
    user = getUser(db, "[email protected]")
    log.Println("Updated User:", user)

    deleteUser(db, "[email protected]")
}

func createUser(db *gorm.DB, name, email string) {
    user := User{Name: name, Email: email}
    db.Create(&user)
}

func getUser(db *gorm.DB, email string) User {
    var user User
    db.First(&user, "email = ?", email)
    return user
}

func updateUser(db *gorm.DB, email, newName string) {
    var user User
    db.First(&user, "email = ?", email)
    user.Name = newName
    db.Save(&user)
}

func deleteUser(db *gorm.DB, email string) {
    var user User
    db.Delete(&user, "email = ?", email)
}

Conclusión

En este módulo, hemos aprendido a utilizar GORM para interactuar con una base de datos en Go. Hemos cubierto la configuración del entorno, la conexión a la base de datos, la definición de modelos y las operaciones CRUD básicas. Con estos conocimientos, puedes empezar a utilizar GORM en tus proyectos para simplificar el manejo de bases de datos.

En el próximo módulo, exploraremos cómo realizar migraciones de base de datos para gestionar cambios en el esquema de manera eficiente.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados