changeset.go

package rel

import (
	"reflect"
	"time"
)

type pair = [2]interface{}

// Changeset mutator for structs.
// This allows REL to efficiently to perform update operation only on updated fields and association.
// The catch is, enabling changeset will duplicates the original struct values which consumes more memory.
type Changeset struct {
	doc       *Document
	snapshot  []interface{}
	assoc     map[string]Changeset
	assocMany map[string]map[interface{}]Changeset
}

func (c Changeset) valueChanged(typ reflect.Type, old interface{}, new interface{}) bool {
	if oeq, ok := old.(interface{ Equal(interface{}) bool }); ok {
		return !oeq.Equal(new)
	}

	if ot, ok := old.(time.Time); ok {
		return !ot.Equal(new.(time.Time))
	}

	return !(typ.Comparable() && old == new)
}

// FieldChanged returns true if field exists and it's already chagned.
// returns false otherwise.
func (c Changeset) FieldChanged(field string) bool {
	for i, f := range c.doc.Fields() {
		if f == field {
			var (
				typ, _ = c.doc.Type(field)
				old    = c.snapshot[i]
				new, _ = c.doc.Value(field)
			)

			return c.valueChanged(typ, old, new)
		}
	}

	return false
}

// Changes returns map of changes.
func (c Changeset) Changes() map[string]interface{} {
	return buildChanges(c.doc, c)
}

// Apply mutation.
func (c Changeset) Apply(doc *Document, mut *Mutation) {
	var (
		t = now().Truncate(time.Second)
	)

	for i, field := range c.doc.Fields() {
		var (
			typ, _ = c.doc.Type(field)
			old    = c.snapshot[i]
			new, _ = c.doc.Value(field)
		)

		if c.valueChanged(typ, old, new) {
			mut.Add(Set(field, new))
		}
	}

	if !mut.IsMutatesEmpty() && c.doc.Flag(HasUpdatedAt) && c.doc.SetValue("updated_at", t) {
		mut.Add(Set("updated_at", t))
	}

	if mut.Cascade {
		for _, field := range doc.BelongsTo() {
			c.applyAssoc(field, mut)
		}

		for _, field := range doc.HasOne() {
			c.applyAssoc(field, mut)
		}

		for _, field := range doc.HasMany() {
			c.applyAssocMany(field, mut)
		}
	}
}

func (c Changeset) applyAssoc(field string, mut *Mutation) {
	assoc := c.doc.Association(field)
	if assoc.IsZero() {
		return
	}

	doc, _ := assoc.Document()

	if ch, ok := c.assoc[field]; ok {
		if amod := Apply(doc, ch); !amod.IsEmpty() {
			mut.SetAssoc(field, amod)
		}
	} else {
		amod := Apply(doc, newStructset(doc, false))
		mut.SetAssoc(field, amod)
	}
}

func (c Changeset) applyAssocMany(field string, mut *Mutation) {
	if chs, ok := c.assocMany[field]; ok {
		var (
			assoc      = c.doc.Association(field)
			col, _     = assoc.Collection()
			muts       = make([]Mutation, 0, col.Len())
			updatedIDs = make(map[interface{}]struct{})
			deletedIDs []interface{}
		)

		for i := 0; i < col.Len(); i++ {
			var (
				doc    = col.Get(i)
				pValue = doc.PrimaryValue()
			)

			if ch, ok := chs[pValue]; ok {
				updatedIDs[pValue] = struct{}{}

				if amod := Apply(doc, ch); !amod.IsEmpty() {
					muts = append(muts, amod)
				}
			} else {
				muts = append(muts, Apply(doc, newStructset(doc, false)))
			}
		}

		// leftover snapshot.
		if len(updatedIDs) != len(chs) {
			for id := range chs {
				if _, ok := updatedIDs[id]; !ok {
					deletedIDs = append(deletedIDs, id)
				}
			}
		}

		if len(muts) > 0 || len(deletedIDs) > 0 {
			mut.SetAssoc(field, muts...)
			mut.SetDeletedIDs(field, deletedIDs)
		}
	} else {
		newStructset(c.doc, false).buildAssocMany(field, mut)
	}
}

// NewChangeset returns new changeset mutator for given record.
func NewChangeset(record interface{}) Changeset {
	return newChangeset(NewDocument(record))
}

func newChangeset(doc *Document) Changeset {
	c := Changeset{
		doc:       doc,
		snapshot:  make([]interface{}, len(doc.Fields())),
		assoc:     make(map[string]Changeset),
		assocMany: make(map[string]map[interface{}]Changeset),
	}

	for i, field := range doc.Fields() {
		c.snapshot[i], _ = doc.Value(field)
	}

	for _, field := range doc.BelongsTo() {
		initChangesetAssoc(doc, c.assoc, field)
	}

	for _, field := range doc.HasOne() {
		initChangesetAssoc(doc, c.assoc, field)
	}

	for _, field := range doc.HasMany() {
		initChangesetAssocMany(doc, c.assocMany, field)
	}

	return c
}

func initChangesetAssoc(doc *Document, assoc map[string]Changeset, field string) {
	doc, loaded := doc.Association(field).Document()
	if !loaded {
		return
	}

	assoc[field] = newChangeset(doc)
}

func initChangesetAssocMany(doc *Document, assoc map[string]map[interface{}]Changeset, field string) {
	col, loaded := doc.Association(field).Collection()
	if !loaded {
		return
	}

	assoc[field] = make(map[interface{}]Changeset)

	for i := 0; i < col.Len(); i++ {
		var (
			doc    = col.Get(i)
			pValue = doc.PrimaryValue()
		)

		if !isZero(pValue) {
			assoc[field][pValue] = newChangeset(doc)
		}
	}
}

func buildChanges(doc *Document, c Changeset) map[string]interface{} {
	var (
		changes = make(map[string]interface{})
		fields  []string
	)

	if doc != nil {
		fields = doc.Fields()
	} else {
		fields = c.doc.Fields()
	}

	for i, field := range fields {
		switch {
		case doc == nil:
			if old := c.snapshot[i]; old != nil {
				changes[field] = pair{old, nil}
			}
		case i >= len(c.snapshot):
			if new, _ := doc.Value(field); new != nil {
				changes[field] = pair{nil, new}
			}
		default:
			old := c.snapshot[i]
			new, _ := doc.Value(field)
			if typ, _ := doc.Type(field); c.valueChanged(typ, old, new) {
				changes[field] = pair{old, new}
			}
		}
	}

	if doc == nil || len(c.snapshot) == 0 {
		return changes
	}

	for _, field := range doc.BelongsTo() {
		buildChangesAssoc(changes, c, field)
	}

	for _, field := range doc.HasOne() {
		buildChangesAssoc(changes, c, field)
	}

	for _, field := range doc.HasMany() {
		buildChangesAssocMany(changes, c, field)
	}

	return changes
}

func buildChangesAssoc(out map[string]interface{}, c Changeset, field string) {
	assoc := c.doc.Association(field)
	if assoc.IsZero() {
		return
	}

	doc, _ := assoc.Document()
	if changes := buildChanges(doc, c.assoc[field]); len(changes) != 0 {
		out[field] = changes
	}
}

func buildChangesAssocMany(out map[string]interface{}, c Changeset, field string) {
	var (
		changes    []map[string]interface{}
		chs        = c.assocMany[field]
		assoc      = c.doc.Association(field)
		col, _     = assoc.Collection()
		updatedIDs = make(map[interface{}]struct{})
	)

	for i := 0; i < col.Len(); i++ {
		var (
			doc          = col.Get(i)
			pValue       = doc.PrimaryValue()
			ch, isUpdate = chs[pValue]
		)

		if isUpdate {
			updatedIDs[pValue] = struct{}{}
		}

		if dChanges := buildChanges(doc, ch); len(dChanges) != 0 {
			changes = append(changes, dChanges)
		}
	}

	// leftover snapshot.
	if len(updatedIDs) != len(chs) {
		for id, ch := range chs {
			if _, ok := updatedIDs[id]; !ok {
				changes = append(changes, buildChanges(nil, ch))
			}
		}
	}

	if len(changes) != 0 {
		out[field] = changes
	}
}