GitLab

Motivation: I want to be able to use the concrete type from a different package
but I can't.

This:

1. Exports the concrete datastore type and avoids returning private types from
   public functions.
2. Removes the mostly useless ktds interface. Unfortunately, it collides with
   the idiomatic name for the datastore itself.

This could break something referencing the `ktds.Datastore` type but nothing is
doing that.

sync: apply entire query while locked

filter: values are now always bytes

autobatch: batch deletes

part of fixing: https://github.com/libp2p/go-libp2p-kad-dht/issues/316#issuecomment-482753415

cleanup and optimize naive query filters

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