ORM for Go (Golang): Comparison and Examples of Popular Libraries

ORM for Go (Golang): Overview, Comparison, and Practical Examples

Go (Golang) is renowned for its performance and simplicity, but working with databases often requires writing a lot of boilerplate SQL code. ORM (Object-Relational Mapping) libraries are designed to simplify interaction with databases by automating the mapping of Go structures to tables. In this article, we will look at the three most popular ORMs for Go: GORM, Ent, and SQLBoiler, compare them by key parameters, and provide working examples.

1. GORM — The Most Popular ORM for Go

GORM is a full-featured ORM with an active community and a huge number of features: migrations, hooks, eager loading of associations, transactions, and much more. It works on the "convention over configuration" principle and supports most popular DBMS (PostgreSQL, MySQL, SQLite).

Advantages:

• Quick start: minimal setup, automatic table creation.
• Rich ecosystem: plugins, loggers, validators.
• Support for associations (Belongs To, Has Many, Many2Many).

Disadvantages:

• Average performance due to reflection and on-the-fly SQL generation.
• Difficulties with optimizing complex queries (N+1 problem).

Example of using GORM:

package main

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

type User struct {    ID   uint   `gorm:"primaryKey"`    Name string `gorm:"size:100"`    Age  int}

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

    // Auto-migration — create table    db.AutoMigrate(&User{})

    // Create record    db.Create(&User{Name: "Ivan", Age: 30})

    // Read    var user User    db.First(&user, 1) // find by ID    db.First(&user, "name = ?", "Ivan") // find by condition

    // Update    db.Model(&user).Update("Age", 31)

    // Delete    db.Delete(&user)}

2. Ent — ORM from Facebook with Code Generation

Ent is a modern ORM that generates typed Go code based on a data schema described in Go structures. It offers strict typing, excellent performance, and a powerful graph API for queries. Ent is actively developed and used in large projects (e.g., at Facebook itself).

Advantages:

• Code generation: errors at compile time, not runtime.
• High performance due to static SQL.
• Convenient API for building complex queries with filtering and sorting.

Disadvantages:

• Need to install a CLI tool and generate code.
• Steeper learning curve compared to GORM.

Example of using Ent:

package main

import (    "context"    "log"

    "entgo.io/ent/dialect/sqlite"    "github.com/yourproject/ent"    "github.com/yourproject/ent/user")

func main() {    // Connect to SQLite    client, err := ent.Open("sqlite3", "file:ent.db?cache=shared&_fk=1")    if err != nil {        log.Fatalf("failed opening connection to sqlite: %v", err)    }    defer client.Close()

    // Auto-migration    if err := client.Schema.Create(context.Background()); err != nil {        log.Fatalf("failed creating schema resources: %v", err)    }

    // Create user    createdUser, err := client.User.Create().        SetName("Pyotr").        SetAge(25).        Save(context.Background())    if err != nil {        log.Fatalf("failed creating user: %v", err)    }

    // Query with filtering    users, err := client.User.Q