GitLab

It's impossible to cancel this correctly. This patch also tries to avoid
goroutines whenever possible.

Fix – sorted limited offset mount queries

Fix function comments based on best practices from Effective Go

Signed-off-by: CodeLingoBot <bot@codelingo.io>

remove ThreadSafeDatastore

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.

Splinter TTLDatastore interface into TTL + Datastore

gx publish 3.6.0

interfaces: make GetBacked* take a Read instead of a Datastore

fixes https://github.com/ipfs/go-ds-leveldb/issues/24

remove closer type assertions

remove io.Closer from the transaction interface

Transactions shouldn't have to implement Close.

We no longer need them.

feat(datastore): expose datastore Close()

query: make datastore ordering act like a user would expect

This applies orders hierarchically. Unfortunately, the interfaces had to be
changed significantly to get this to work.

For example `[OrderByValue{}, SortByKey{}]` *used* to re-sort by key, throwing
away the value sort. Now, this acts like a normal database and `SortByKey` will
only sort within equivalent values.