How do I store an array of values using GORM + Postgres?

When developing with GORM and PostgreSQL, if you need to store fields of array data types, you can leverage PostgreSQL's array data type support. GORM, as a robust ORM framework, effectively supports this feature. Below, I will provide a detailed explanation of how to store array values using GORM and PostgreSQL.

Step 1: Define the Model

First, define a field in the GORM model with a Go slice type. For example, to store a string array, define the model as follows:

go
type Product struct {
    gorm.Model
    Name      string
    Features  []string `gorm:"type:text[]"`
}

In this example, the Features field is defined as []string, and the gorm:"type:text[]" tag specifies it as a text array type.

Step 2: Connect to the Database

When connecting to the PostgreSQL database, ensure the database connection string is correct and the database is properly configured.

go
import (
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

func main() {
    // DSN (Data Source Name)
    dsn := "host=localhost user=gorm password=gorm dbname=gorm port=9920 sslmode=disable TimeZone=Asia/Shanghai"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // Auto-migrate
    db.AutoMigrate(&Product{})
}

Step 3: Insert and Query Records with Array Data

Inserting records with array data is straightforward. Simply create a model instance and use the Create method.

go
func main() {
    // Omit initialization and connection code

    // Create record
    db.Create(&Product{Name: "GORM Handbook", Features: []string{"Reliable", "Efficient", "Easy to use"}})

    // Query record
    var product Product
    db.First(&product, "name = ?", "GORM Handbook")
    fmt.Println("Product Features: ", product.Features)
}

In this example, we create a product record containing the name and features array. Then, we query the record by name and print the product features.

Conclusion

Using GORM and PostgreSQL to handle array data types is direct and efficient. Through GORM's data type tags, Go slice types can be easily mapped to PostgreSQL array data types. This approach allows developers to focus on business logic implementation without worrying about data storage details.