UpdateColumns triggers Gorm hook with incorrect values

I have this code which updates the upvote and downvote columns in my table:

// tx is my transaction

// `content.model` is a model interface

// `content.id` is the ID of what I'm going for

// `columnUpdates` is a `columnUpdates := make(map[string]interface{})` with 
// a bunch of different updates to the upvote & downvote columns

...

query := tx.Model(content.model).
	Where("id = ?", content.id).
	UpdateColumns(columnUpdates)
if err := query.Error; err != nil {
	tx.Rollback()
	return err
}

...which in turn triggers this Gorm hook (checked, it does trigger it):

func (p *Post) AfterUpdate(tx *gorm.DB) error {
	fmt.Println("upvotes: ", p.Upvote)
	fmt.Println("downvotes: ", p.Downvote)
	p.VoteScore = int(p.Upvote) - int(p.Downvote)
	return nil
}

but the hook always prints both votes as 0 even though they are not 0.

My goal is to have upvote and downvote fields inside my postgres table and a vote_score field that is auto-updated upon a row's upvote/downvote being updated. However, vote_score won't be calculated properly if upvote and downvote are always 0 in the hook.

How can I get the correct vote values in the Gorm Hook?

Here is my Post struct model, with just the relevant fields shown:

type Post struct {
	Downvote      uint         `gorm:"column:downvote"`
	Upvote        uint         `gorm:"column:upvote"`
	VoteScore     int          `gorm:"column:vote_score"`
}

Thanks.

I've just looked at your code and I found out a couple of issues. First, let me present my working code, then, I'm gonna walk you through the changes.

package main

import (
	"fmt"

	"gorm.io/driver/postgres"
	"gorm.io/gorm"
)

type Post struct {
	ID        int
	Downvote  uint `gorm:"column:downvote"`
	Upvote    uint `gorm:"column:upvote"`
	VoteScore int  `gorm:"column:vote_score"`
}

func (p *Post) AfterUpdate(tx *gorm.DB) error {
	fmt.Println("upvotes: ", p.Upvote)
	fmt.Println("downvotes: ", p.Downvote)
	p.VoteScore = int(p.Upvote) - int(p.Downvote)
	if err := tx.Model(&Post{}).Where("id = ?", p.ID).UpdateColumn("vote_score", p.VoteScore).Error; err != nil {
		return err
	}
	return nil
}

func main() {
	dsn := "host=localhost port=54322 user=postgres password=postgres dbname=postgres sslmode=disable"
	db, err := gorm.Open(postgres.Open(dsn))
	if err != nil {
		panic(err)
	}
	db.AutoMigrate(&Post{})

	// db.Create(&Post{ID: 1})

	if err := db.Model(&Post{ID: 1}).Where("id = ?", 1).Updates(map[string]interface{}{"upvote": 4, "downvote": 3}).Error; err != nil {
		db.Rollback()
		fmt.Println(err.Error())
		return
	}
}

The first issue is the usage of the method UpdateColumns. The latter must be used when you want neither the time tracking nor the hooks to be triggered. You can find more in this section of the GORM documentation: link.
After adding the ID to the struct, I make sure that the correct ID was set in the AfterUpdate hook. Thanks to this you can re-run an update to edit the just updated record.

If you don't want to run two updates you might use another hook that runs before the update.

Let me know if this solves your issue, thanks!