Cost of creating a datastore.Key: Storing a key in struct versus an id and fetching from the datastore

Consider the following two alternatives.

A) Storing the key in the struct.

type Point struct {
    Place *datastore.Key
    Lat   float64
    Lon   float64
}

Then fetching using the key:

place := new(Place)
if err := datastore.Get(c, k, point.Place); err != nil {
    return err
} 

B) Storing the id

type Point struct {
    Place int64
    Lat   float64
    Lon   float64
}

Then fetching after creating the key.

k := datastore.NewKey(c, "Place", "", point.Place, nil)
place := new(Place)
if err := datastore.Get(c, k, place); err != nil {
    return err
} 

Storing the key instead of the id takes a bit more space. In order to see the tradeoff, it would be great to get a feeling for how much resources it takes to create a key. In other words, is it really cheap to create a key, or is it better to create it once and store it?

With a single key, it probably doesn't matter much, but let's say that I fetch a list of points, and for each point I want to retrieve the place (i.e. loop through the points to build an array of keys, and fetch them).

Edit: I am not thinking about allocating IDs or keys here, only using them (i.e. all points and places are already in the datastore, the question is just whether to store the id or the entire key).

Ex animo,
Alexander Yngling

Key is basically just a wrapper around a set of properties: kind, id/name, parent key(s), namespace.

So creating a Key from a kind and ID costs nothing, as this is a local operation (does not require Datastore).

OTOH, Key allocation does cost as this creates a Key with unique ID and this needs to Query a Datastore under the hood.

I think Peter gave a pretty good answer, but there's two things involved here:

1. You seem to be asking whether it's cheaper to generate a key from an ID and store the ID to save storage cost, or store the actual key. Generating a key from an ID is a pretty simple hash, close to neglible - you probably have many more important things to worry about. I can't say how much it costs, but you can do a pretty simple experiement and loop a few hundred thousand times and estimate the cost. It probably is cheaper than storage, but I doubt it'd be very significant.

2. The difficult part is generating the unique ID, which you didn't include in your question. For that, it's probably easier to just get a datastore key which is guaranteed to be unique.

As mentioned already creating a key costs nearly nothing; therefore, you would choose to store the ID which would save you some storage cost. The benefits to storing the Key is that it is typeded to what the id is actually pointing at and would prevent possible errors in your code. For example if you store the ID it is possible for you to retrieve that ID and then create a key fro the wrong entity in your code, if you store the key you don't need to worry about that mistake. And at the cost of the datastore the difference in storing a ID and a Key is probably negligible, the time you spent thinking about it is more valuable.