Question

I’m trying to design a basic ORM for a data app that I’m working on. My question about the model I came up with is 2-fold:

• Is this the ‘best’ most ‘efficient’ model for database tracking?
• Is this idiomatic Go?

The idea is to load a complete model of the db into memory at app start. Use this model to generate a map with a crc32 hash of each object (corresponding to a row in the database). This is what we use to compare with model to find specifically where changes have been made when .save() is called.

The first part of the following generates the crc32 map, the second part introduces a random change, and the last part would be part of .save() to write db changes to disk

The code:

func main() {
    // Read data off of disk into memory
    memDB := ddb

    // Create hash map of memDB
    peopleMap := make(map[int]uint32)
    for _, v := range memDB.people {
        // make row into byte array, looks kludgy
        hash := []byte(fmt.Sprintf("%#v", v))
        peopleMap[v.pID] = crc32.ChecksumIEEE(hash)
        fmt.Printf("%v: %v %v \t(%v %v) - crc sum: %v\n",
            v.pID, v.fName, v.lName, v.job, v.location,
            peopleMap[v.pID])
    }
    fmt.Println("\n# of people in memory:", len(memDB.people))

    // Sometime later, we need to delete Danielle, so
    // Delete in memory:
    var tmpSlice []ddPerson
    for _, v := range memDB.people {
        if v.fName == "Danielle" {
            continue
        }
        tmpSlice = append(tmpSlice, v)
    }
    memDB.people = tmpSlice
    fmt.Println("# of people in memory:", len(memDB.people))

    // Okay, we save in-memory representation mem.DB back
    // to disk with some kind of .save() assertion
    // a len(peopleMap) comparison to len(memDB.people) will
    // tell us there has been a change for INSERTS and
    // DELETES, but it won't tell us about updates or which
    // record was inserted or deleted

    // First, check for additions
    if len(peopleMap) < len(memDB.people) {
        // Code to find and add person to disk db ddb here
        fmt.Println("Adding someone to disk database...")
    } else if len(peopleMap) > len(memDB.people) {
        // Check for deletions
        fmt.Println("Purging someone from disk database...")
    }

    // in any case, recheck hashes
    tMap := make(map[int]uint32)
    for _, v := range memDB.people {
        hash := []byte(fmt.Sprintf("%#v", v))
        t := crc32.ChecksumIEEE(hash)
        // Add to temporary map
        tMap[v.pID] = t
        // And check for changes
        if t != peopleMap[v.pID] {
            fmt.Println("Change detected in in-memory model...")
            fmt.Println("Writing changes to disk db now")
            // Writing any changes to DB here
            ddb.people = memDB.people
        }
    }

    // 'Fix' our hashmap checker deal
    peopleMap = tMap

    // Carry on
}

There is a working version at: http://play.golang.org/p/XMTmynNy7t

Answer 1

You’ve implemented an in memory cache of your db which isn’t really the same thing as an ORM.

There are several problems with what you have:

• If some other process/application ever modifies the database your in memory model will be out of date. This could cause your writes to clobber writes to the db because you didn’t know your cache was stale.
• If the db gets large you’re application will get correspondingly large.

Most ORM’s provide a way to map a type (eg. structs) to a db read and write. This allows you to read a single object from the database modify it and then write that object back to the database. That is probably a better approach for this.

As for how idiomatic your go is I didn’t see obviously non idiomatic go but there also isn’t much going on in it. At the top memDb := ddb is a function call but you don’t have parens after it. This is a syntax error.