PostgreSQL and Golang Tutorial

January 24, 2023

SUMMARY: This article covers how to use PostgreSQL together with the programming language Golang (Go). After showing how to get started with Go’s Object Relational Mapper, it offers an example of setting up a PostgreSQL database using Go.

1. The connector

2. Getting started

3. A simple example

4. Launch!



Golang (or simply “Go”) is a powerful C/C++-like programming language that has garnered a lot of interest since its inception in 2009. It’s widely used at Google, where it was created, and I’ve personally seen several software engineers electing to use Go over more traditional languages like C/C++ and Java because of its more intuitive syntax and features. For the most part, these developers have said that choosing Go was an excellent choice, and they probably won’t go back. And to continue their streak of good choices, they often back their application with PostgreSQL, the world’s most powerful open-source database. This article will discuss how to get Go-ing with PostgreSQL.


The connector

For this article, we will be using GORM, a very powerful Object Relational Mapper (ORM) written for Go, which ultimately connects to PostgreSQL with Go’s “lib/pq” module.  Using “lib/pq” is pretty straightforward (and probably too simple for us to write a full article about). For more information, visit


Getting started

We’re going to assume that you’ve got Go installed on your machine, since there are several ways to do it, and to cover every OS and method would be outside the scope of this article.  Once Go is installed, you’ll need to install GORM and some of its dependencies:

go get

go get

go get

go get


A simple example

While there are many frameworks out there for working with Go, most of them don’t get into the nitty-gritty details about separating models from routes and such. All that is up to the developer, and while you can certainly split them up into different files and directories, we’ll give a simple one-file example here.


First, you’ll need to import the GORM package:

package main

import (







  _ ""



Next, you’ll need to define the Driver and Car tables as structs:

type Driver struct {


  Name     string

  License  string

  Cars     []Car


type Car struct {


  Year       int

  Make       string

  ModelName  string

  DriverID   int



Note that we have created a reference for a Car to have a driver/owner. GORM does not create foreign keys on the database side, though you can define a has-many relationship in the software (notice that a Driver can have multiple Cars in its model definition).

Next, we’ll tell Go to insert some data for us:

var db *gorm.DB

var err error

var (

    drivers = []Driver{

        {Name: "Jimmy Johnson", License: "ABC123"},

        {Name: "Howard Hills",  License: "XYZ789"},

        {Name: "Craig Colbin",  License: "DEF333"},


    cars = []Car{

        {Year: 2000, Make: "Toyota", ModelName: "Tundra", DriverID: 1},

        {Year: 2001, Make: "Honda",  ModelName: "Accord", DriverID: 1},

        {Year: 2002, Make: "Nissan", ModelName: "Sentra", DriverID: 2},

        {Year: 2003, Make: "Ford",   ModelName: "F-150",  DriverID: 3},




Then, you’ll need to tell Go how to handle incoming HTTP requests:

func main() {

  router := mux.NewRouter()

  db, err = gorm.Open( "postgres", "host=db port=5432 user=postgres dbname=postgres sslmode=disable password=postgres")

  if err != nil {

    panic("failed to connect database")


  defer db.Close()



  for index := range cars {



  for index := range drivers {



  router.HandleFunc("/cars", GetCars).Methods("GET")

  router.HandleFunc("/cars/{id}", GetCar).Methods("GET")

  router.HandleFunc("/drivers/{id}", GetDriver).Methods("GET")

  router.HandleFunc("/cars/{id}", DeleteCar).Methods("DELETE")

  handler := cors.Default().Handler(router)


  log.Fatal(http.ListenAndServe(":8080", handler))



Finally, you’ll need to define how the app will handle the HTTP requests:

func GetCars(w http.ResponseWriter, r *http.Request) {

  var cars []Car




func GetCar(w http.ResponseWriter, r *http.Request) {

  params := mux.Vars(r)

  var car Car

  db.First(&car, params["id"])



func GetDriver(w http.ResponseWriter, r *http.Request) {

  params := mux.Vars(r)

  var driver Driver

  var cars   []Car

  db.First(&driver, params["id"])


  driver.Cars = cars



func DeleteCar(w http.ResponseWriter, r *http.Request) {

  params := mux.Vars(r)

  var car Car

  db.First(&car, params["id"])


  var cars []Car






You should now have in one file all the code necessary to run—you’ve basically got a Model-View-Controller to manage your Cars and Drivers. Let’s give it a try! In your terminal, call “go run gorm_demo.go”. This will launch a webserver that listens on the port specified (“:8080” in our example). You’ll need to now open either a browser and navigate to “localhost:8080”, or just use “curl” to load the pages (since we never really defined any HTML templates):

$ curl localhost:8080/cars



Note that the JSON comes out unformatted. If you want to pretty-print it (without having to refactor the Go code), the easiest way to do so is by piping it to “python -m json.tool”. In the interest of length, I’ve only used that method in the final example.

Since we basically created a REST API, we can retrieve Cars by ID:

$ curl localhost:8080/cars/2



We can also delete Cars:

$ curl -X DELETE localhost:8080/cars/2



Finally, if you recall, we defined a one-to-many relationship between Drivers and Cars, so if we fetch a Driver, we can see its related Cars (and pretty-printed with python’s “json.tool” module):

$ curl localhost:8080/drivers/1 | python -m json.tool


    "ID": 1,

    "CreatedAt": "2019-12-20T23:38:26.181909Z",

    "UpdatedAt": "2019-12-20T23:38:26.181909Z",

    "DeletedAt": null,

    "Name": "Jimmy Johnson",

    "License": "ABC123",

    "Cars": [


            "ID": 1,

            "CreatedAt": "2019-12-20T23:38:26.176961Z",

            "UpdatedAt": "2019-12-20T23:38:26.176961Z",

            "DeletedAt": null,

            "Year": 2000,

            "Make": "Toyota",

            "ModelName": "Tundra",

            "DriverID": 1





There you have it! A simple and working example of how to use PostgreSQL with Go’s ORM.  For more information about the features of GORM, you may want to check out their documentation.

Happy coding!


Share this

Relevant Blogs

More Blogs