How to delete range of items from database with gorm

When using GORM for deletion operations, ensure that your operations are both safe and aligned with business logic. Below is a step-by-step guide and considerations for deleting records within a specific range from a database.

1. Define the Model

First, ensure you have a Go struct that maps to the database table. For example, consider a Product model corresponding to the products table:

go
type Product struct {
    gorm.Model
    Code  string
    Price uint
}

2. Initialize GORM and Database Connection

Before performing any database operations, initialize GORM and establish a database connection. Here's an example of connecting to an SQLite database using GORM:

go
package main

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

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

    // Other operations...
}

3. Deletion Operations

Deleting a Single Item

To delete a specific entry, first query it and then use the Delete method. For example, to delete a product with code "T1234":

go
var product Product
db.Where("code = ?", "T1234").First(&product)
db.Delete(&product)

Deleting Within a Range

If you need to delete multiple items that meet specific conditions, you can directly use conditions in the Delete method. For example, to delete all products with a price less than 100:

go
db.Where("price < ?", 100).Delete(&Product{})

4. Soft Delete and Hard Delete

GORM natively supports soft deletes. If your model includes the DeletedAt field (which is already included in gorm.Model), using the Delete method will only set the DeletedAt value, rather than permanently removing the record from the database.

If you need to perform a hard delete (permanently removing the record from the database), you can use the Unscoped method:

go
db.Unscoped().Where("price < ?", 100).Delete(&Product{})

5. Error Handling

When executing deletion operations, you should check for potential errors and handle them appropriately:

go
result := db.Where("price < ?", 100).Delete(&Product{})
if result.Error != nil {
    // Handle error
    fmt.Println(result.Error)
}
fmt.Println(result.RowsAffected, "rows affected")

Summary

Using GORM to delete records within a range is a straightforward process, but you should pay attention to properly handling database connections, error handling, and the distinction between soft and hard deletes. Additionally, before performing large-scale deletions, it's advisable to have data backup and recovery strategies to prevent data loss in case of unexpected issues.