Maybe have:

trait TransactionConnection: Connection {
	type Transaction: Connection;
	async fn start_transaction(&self, timeout: Duration) -> Transaction;
}

It'd be nice to allow the transaction to have its lifetime bounded by the connection, but this requires GATs...

A kinda gross solution might be:

trait TransactionConnectionInner {
	type Connection: Connection;

	async fn create_atom(&self, conn: &Self::Connection) -> Result<Atom, Self::Error>;
	// etc
}

struct Transaction<'a, T: TransactionConnectionInner> {
	connection: &'a T::Connection,
	inner: T,
}

impl<'a, T: TransactionConnectionInner> Connection for Transaction<'a, T> {
	// ...
}

trait TransactionConnection: Connection {
	type TransactionConnectionInner: TransactionConnectionInner<Connection = Self>;
	async fn start_transaction<'a>(&'a self, timeout: Duration) -> Transaction<'a, TransactionConnectionInner>;
}

• Only query from DB if needed
• Batch DB queries together? Could do a similar transformation to Haxl, potentially.
• Magic Sets (slides)

It'd be nice for both NIH, and for being able to more confidently assert the formal properties the database should have, to have a native backend rather than just the current SQLite-backed one.

Problems to solve:

• ACID
  • Shadow paging
  • https://research.cs.wisc.edu/adsl/Publications/alice-osdi14.pdf
• Performance
  • To some degree, too early to worry about it, lol
  • Get hawktracer in early
  • Index-free adjacency? Almost feels like you'd wanna ditch ACID if you did that, though...
    • OTOH, maybe just be in-memory? DL160 RAM is cheap, and the (non-blob) data is small...

eg query! { ?- edge($(from), To, "contains"). }

nb this necessitates a less efficient implementation than the current one; maybe make the string pool global, and make the query macro generate lazy_statics to hold references to the strings within?