GitLab

Also make sure to clean and normalize keys before using them as prefixes.

BREAKING CHANGES:

* `myds.Query(Query{Prefix:"/foo"})` will no longer match "/foobar" (or even
  "/foo"). This is usually what the user expects, we had a tendency to normalize
  "/foo/" to "/foo" (when we clean keys), and many datastores can't efficiently
  search for prefixes that aren't on path-boundaries anyways.
* Given a mount datastore with mounts `["/foo", "/"]`, `myds.Put("/foo", "bar")`
  will put the value to the datastore mounted at "/", not "/foo", as the key "/"
  and "" usually doesn't make sense.

While technically breaking, these changes are much more likely to fix bugs than
they are to break things.

interface(Datastore): added Sync function to the Datastore, along with implementations in helper Datastores

Now we just need a common place to put:

func IsNotFound(e error) bool {
  for e != nil {
    if ne, ok := e.(interface { NotFound() bool }); ok {
      return ne.NotFound()
    }
    if ue, ok := e.(interface { Unwrap() error }); ok {
      e = ue.Unwrap()
    } else {
      return false
    }
  }
  return false
}

fixes #104

It's a lie! We:

1. Assume that our datastores are thread-safe all over the place, not bothering
   to check for this interface.
2. Implement this interface for, e.g., the mount datastore that _may not_ be
   thread-safe (depending on the sub-datastores).

Basically, there's no sane way to to do something like this in go. What we
_want_ is:

```rust
pub trait ThreadSafe {}

struct MyWrapper<D: Datastore> { ... }

impl<D: Datastore> ThreadSafe for MyWrapper<D> where D: ThreadSafe {}
```

Actually, we don't even need this because rust has already done all the hard
work with the `Sync` trait.

....

But we're using go which barely has types.

---

For completeness, it's actually possible to do this in go:

```go
type threadSafeMixin struct{}
func (threadSafeMixin) ThreadSafe() {}

func NewWrapper(d Datastore) Datastore {
  if _, ok := d.(ThreadSafe) {
    return &struct{myWrapper, threadSafeMixin}{myWrapper{d}, threadSafeMixin{}}
  }
  return &myWrapper{d}
}
```

Let's not.

We no longer need them.

We can also add this as an extension but it's simple enough I'd like to add it
directly to the Datastore.

Use-case: The blockstore now has a GetSize and bitswap uses it for packing
multiple blocks into a single message. Unfortunately, this means that bitswap is
now calling blockstore.GetSize which calls datastore.Get which tends to be more
expensive than datastore.Has.

None of our actual datastores support any other types and the cast noise gets
really annoying after a while.

This adds a PersistentDatastore interface which allows datastores
to report DiskUsage().

It implementes the interface on all wrapper types, which return
0 if the wrapped datastore does not provide this method.

Related: https://github.com/ipfs/go-ipfs/pull/4550

implement batch ops for different datastore types

rename Transaction to Batch

Revert "add in support for batched writes"

add in benchmarks for put and batchput

move batching into separate interface

address concerns from PR

regrab old code