Choosing the right Go ORM

If you're building a Go application and need to work with a relational database, chances are you're considering an ORM. But which one is right for your project? In this guide, we’ll break down the most popular Go ORMs, compare their strengths, and help you make an informed decision.

But first let's run through the basics.

What is an ORM? (TL;DR)

An ORM (Object-Relational Mapper) is a tool that simplifies interaction with databases. In Go development, it basically maps Go structs to database tables, making it more intuitive to work with relational data.

For example, we might have this table in our database:

CREATE TABLE users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    first_name VARCHAR(100),
    last_name VARCHAR(100),
);

And you want to use this SQL query:

-- Fetch all users with the last name "Smith"
SELECT * FROM users WHERE last_name = 'Smith';

Which using an ORM (GORM in the example below) can be written like this in your Go program:

// First we create a Go struct that maps to our users table
type User struct {
    ID        uint
    FirstName string
    LastName  string
}

// Using GORM, the equivalent query looks like this
var users []User
result := db.Where("last_name = ?", "Smith").Find(&users)

In this example, db is your GORM database connection. The Where method adds a condition to the query, and Find executes the query, populating the users slice with the results.

This GORM query abstracts away the raw SQL, providing a more idiomatic Go way to interact with the database. It's particularly useful for more complex queries and can significantly improve code readability and maintainability.

When to use an ORM

Typically you'd use an ORM when you need to speed up database-related development, ensure type safety, and make code easier to read and maintain. It's particularly handy for applications with complex data models or when you prefer not to deal with the boilerplate of raw SQL queries.

When to avoid ORMs

It's wise to be cautious about using ORMs in performance-critical systems or where you need direct control over database interactions, as ORMs can add overhead and sometimes obscure what's happening at the database level.

Now let's take a look at the best Go ORMs.

GORM

GORM is a comprehensive ORM tool in Go, offering a code-first approach which allows defining database schemas using struct tags in Go. It's known for its developer-friendly nature, making it suitable for both beginners and experienced users. GORM supports a variety of SQL databases like MySQL, PostgreSQL, and SQLite. It's designed to be flexible, allowing developers to drop down to raw SQL when necessary. However, it's important to be cautious about its performance implications in large-scale applications.

Pros:

• User-Friendly: Ideal for both beginners and experienced developers.
• Flexibility: Allows using raw SQL for complex queries.
• Database Support: Compatible with multiple SQL databases like MySQL, PostgreSQL, SQLite.
• Active Community: Large user base and community support.

Cons:

• Performance: May not be as efficient as some alternatives for large-scale applications.
• Overhead: The abstraction layer can add complexity and overhead.

Try GORM

You can try GORM in any Go project, simply follow the guide in the GORM docs. If you’re looking for a setup that includes automations for database provisioning and migrations out of the box, Encore includes GORM integration as an option. Learn more in the docs.

sqlc

sqlc is not strictly a conventional ORM. It offers a unique approach by generating Go code from SQL queries. This allows developers to write SQL, which sqlc then converts into type-safe Go code, reducing the boilerplate significantly. It ensures that your queries are syntactically correct and type-safe. sqlc is ideal for those who prefer writing SQL and are looking for an efficient way to integrate it into a Go application. Here at Encore we really like sqlc, so much so that we wrote a whole blog post about it.

Pros:

• Type Safety: Generates type-safe Go code from SQL.
• SQL-Centric: Ideal for those who prefer writing raw SQL.
• Reduced Boilerplate: Automates much of the routine coding required for database interactions.

Cons:

• Initial Setup: Can require more setup and configuration initially.

Try sqlc

To try sqlc, you'll need a local database and some SQL files. You can set this up by following the steps in the sqlc get started guide. If you want a quick start with database provisioning handled for you, you can check out this example project using sqlc with the Encore framework.

ent

ent is a fairly recent ORM that uses a code-first approach where you define your schema in Go code. Ent is popular thanks to its ability to handle complex data models and relationships elegantly. It's statically typed, which can help catch errors at compile time. However, the learning curve might be steeper compared to more straightforward ORMs like GORM. It's a good fit for applications where complex data models and type safety are priorities.

Pros:

• Type Safety: Statically typed, reducing runtime errors.
• Complex Models: Efficient at handling complex data models and relationships.

Cons:

• Long Compile Times: Generates a lot of code, leading to longer compile times.
• Monolithic Approach: Can be challenging to integrate in microservices architecture due to its monolithic design.
• Learning Curve: Might require more time to learn compared to more straightforward ORMs.

Try ent

You can try ent in any Go project, simply follow the guide in the ent docs. If you’re looking for a setup that includes automations for database provisioning and migrations out of the box, Encore includes ent integration as an option. Learn more in the docs.

Using ORMs with Encore for simpler database management

No matter which ORM you choose, one of the biggest pain points of working with databases in Go isn’t writing queries. It’s everything around them: Provisioning databases, managing connection strings, running migrations, and keeping development, testing, and production environments in sync.

Encore is an open source Go framework that removes much of this operational overhead.

It comes with built-in PostgreSQL support, automatic local database provisioning, environment-aware configuration, migration workflows, and connection management out of the box. Instead of wiring up infrastructure yourself, you declare what your application needs and Encore takes care of the rest.

That means you can use modern Go ORMs and database tooling without turning database setup into a project of its own. Learn more in these guides:

• Setting up GORM
• Using ent with Encore

Beyond databases, Encore also provides declarative APIs for:

• Pub/Sub messaging
• Cron jobs
• Secrets and configuration
• Caching

If you enjoy Go but want the productivity and guardrails of a batteries-included backend framework, learn more about Encore here.

Wrapping up

Each ORM has its strengths and ideal use cases. GORM and ent are more code-first and user-friendly, suitable for a broad range of applications. sqlc is more specialized, excelling in scenarios where direct SQL interaction or database-first design is preferred. The choice largely depends on the specific needs and preferences of your project.

Related reading

We hope this brief article helps inform your choice about which Go ORM to use in your next project. Related to picking an ORM, it's common to want to use a framework to make development more efficient. There are many frameworks to choose from, all with different characteristics. To help inform your decision, we've recently published a guide to the best Go frameworks.