GitLab

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.

delayed: implement io.Closer and export datastore type.

That way, we can return it directly.

split the datastore into a read and a write interface

This way, we can abstract over transactions, datastores, and batches when we
just need to write to the datastore.

gx publish 3.4.1

Describe behavior of Batching datastores

handle concurrent puts/deletes in BasicBatch

(also, clear datastore between tests)

add a GetSize method

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.

Allow ds.NewTransaction() to return an error