How to handle with GORM a JSON that corresponds to a database schema?


I am writing a backend API that sends to the frontend some JSON data from a database (handled by GORM). The frontend, after some modifications to the content of the fields, sends me back the data also as JSON.

Below is a mock-up of the code

package main

import (


type User struct {
    ID     uint
    Name   string
    Card   Card
    CardID uint

type Card struct {
    ID     uint
    Number string

func main() {
    // initialize the database
    db, _ := gorm.Open(sqlite.Open("mytest.sqlite"), &gorm.Config{})
    db.AutoMigrate(&User{}, &Card{})
    // create two cards
        Number: "42",
        Number: "100",
    // find one of them
    var myCard Card
    db.Where(map[string]interface{}{"number": "42"}).First(&myCard)
    // create a user with that card
        Name: "john",
        Card: myCard,
    // find that user
    var myUser User
    db.Preload("Card").Where(map[string]interface{}{"name": "john"}).Last(&myUser)
    // this is then marshalled to JSON, and sent to a frontend.
    // on that frontend there are some changes and I get back the JSON
    // this is simulated below:
    // the card itself changed
    myUser.Card.ID = "2"
    myUser.Card.ID = "100"
    // the name of the user changed
    myUser.Name = "mary"
    output, _ := json.Marshal(myUser)
    // Now output holds the JSON string

// output
// {"ID":12,"Name":"mary","Card":{"ID":2,"Number":"100"},"CardID":1}

My question is about how to handle output so that it can be written back into the database.

I do not really know GORM (or ORM for that matter) and I do not understand how to handle the fact that:

  • the ID of the card was changed
  • the Name of the user changed

In particular, I do not understand whether GORM will just "know" that the attached card is now different (and corresponds to a card in the database). I believe that the fact that Name changed is not a problem (because the ID is the same)


You can decode the JSON body into a user struct, and then do an update with it.

func patchUser(w http.ResponseWriter, r *http.Request) {
    // get the id from the url i.e. /users/1
    // you need to use a framework or implement this yourself
    id := getId(r.URL)

    // decode the body into a new user
    patch := User{}
    // patch the user at the given id
    db.Model(User{}).Where("id = ?", id).Updates(patch)

You can find docs about updates here:

Answered By – The Fool

Answer Checked By – Marie Seifert (GoLangFix Admin)

Leave a Reply

Your email address will not be published.