Leaked write transactions are hard to avoid

[casey]

Idiomatic code tends to leak write transactions. We have a few places in ord where we're doing something like this:

let tx = database.begin_write()?;
let value = might_fail(tx)?;
// do more stuff with `value`
tx.commit()?;

If might_fail returns Result::Err, then we'll leak the write transaction, and get the message about leaking write transactions.

To work around this and avoid getting the error message, we have to introduce wrappers like this:

let tx = database.begin_write()?;
let value match might_fail(tx) {
  Ok(value) => value,
  Err(err) => {
    tx.abort()?;
    return Err(err);
  }
}
// do more stuff with value
tx.commit()?;

Also, sometimes there isn't just one function might_fail, there are a few in sequence, and either each one needs a wrapper, or the sequence needs to be extracted into a sub-function, so that you can match sub_function(tx). Both options are pretty verbose.

Given that, perhaps write transactions should just abort on drop?

[casey]

Aborting on drop would swallow errors, since Drop::drop returns (). However, there's some precedence for this in the standard library. std::fs::File::drop flushes the file, and ignores any errors that occur there.

[cberner]

Ah yes, I like that better. I avoided automatically aborting since it would ignore the errors, but if std does it 🤷

[casey]

Sweet, this is great! I can remove my weird AbortOnDrop wrapper now.

[cberner]

Just released this in 0.5.0

[casey]

Sweet, we'll update soon.

The ordinal explorer is getting more featureful by the way:

https://signet.ordinals.com/

The front page returns a list containing every signet block, which requires iterating over a 100k entry table, and redb is super fast.

The only reason we're doing something so stupid is because we haven't implemented pagination, but it's nice that we don't need to implement pagination just because our database is slow. (The reason we have to implement pagination is because it's not polite to return 16 MiB of HTML unless you're the whatwg.)

[casey]

You can also look up ordinals now by name, number, degree, or decimal: https://signet.ordinals.com/ordinal/cberner

[cberner]

Nice! How is the name calculated?

[casey]

It's close to being a straight conversion from base 10 / 0-9 to base 26 / a-z. However it goes from z to aa and not from z to ba, which is what you would get if a was 0 and b was one.