dqlite VS rqlite

I'd be curious for a similar tuning with Dqlite: https://github.com/canonical/dqlite

Anyone knows how the DB this is about, https://rqlite.io/, compares with https://dqlite.io/ by Canonical (both seem to be distributed versions of sqlite)?

For folks' context, the new tool that's being discussed in the thread mentioned by the parent here is litefs [0], as well as which you can also look at rqlite [1] and dqlite [2], which all provide different trade-offs (e.g. rqlite is 'more strongly consistent' than litefs).

[0]: https://github.com/superfly/litefs

[1]: https://github.com/rqlite/rqlite

[2]: https://github.com/canonical/dqlite

I presume you're familiar with https://github.com/canonical/dqlite (made by my employer) and https://github.com/rqlite/rqlite (unrelated)? How will mvsqlite compare to those?

Check out dqlite, it's sqlite but with a raft consensus to distribute changes through a log: https://dqlite.io/ You can link it in as a library too, it sounds like exactly what you want.

https://dqlite.io/

I’m sure there’s more, those are just the ones I remember.

rqlite[1] creator here, happy to answer any questions. rqlite also supports read-only nodes, which can also help with reads at the "edge". It probably wouldn't scale to 100s of nodes, it is an option.

"rqlite supports adding read-only nodes. You can use this feature to add read scalability to the cluster if you need a high volume of reads, or want to distribute copies of the data nearer to clients – but don’t want those nodes counted towards the quorum. These types of nodes are also known as non-voting nodes."

[1] https://rqlite.io/

[2] https://rqlite.io/docs/clustering/read-only-nodes/

result, opErr := db.executeStmtWithConn for the "executeStmt that you , you can manipulate the picture ', you ... i = t given, and it' . If, -212<|endoftext|>

[1] https://rqlite.io/

Yes, it's saved me hours of time -- with certain narrow tasks. For example, it generated these files for me:

https://github.com/rqlite/rqlite/blob/master/auto/backup/sum*

It took a few minutes, might have taken me 1+ hour of some research, and mechanically typing it all in.

Just to point out, there are now SQLite replication and various "distributed database" projects which seem to work fairly well.

They're probably not as battle tested as the PostgreSQL ones, but they are around, have users, and are actively developed.

The ones I remember off the top of my head:

* https://litestream.io

* https://github.com/rqlite/rqlite <-- more of a "distributed database using RAFT" type of thing

* https://github.com/canonical/dqlite

Instead of running it as a separate rqlited, integrate it into an existing binary. I answered my own question by looking in https://github.com/rqlite/rqlite/blob/master/cmd/rqlited/main.go

Is this somehow related to rqlite? https://rqlite.io/

The architecture is very similar.

rqlite[1] creator here. This offering is completely new to me. Welcome to the party, that's what I say. I started doing what they are doing about 10 years ago. :-)

https://www.philipotoole.com/9-years-of-open-source-database...

The post makes a fairly big point of the shortcomings of statement-based replication (like rqlite does).

What they state is correct -- non-deterministic SQL will be a problem, but it's not a difficult problem to solve. Just parse and rewrite the statement before sending it to Raft. It's exactly what rqlite does[2] (though there is more to do). However they claim that there are two concerns with this approach.

>This solution introduces a runtime delay because each SQL statement must be parsed and analyzed.

The delay is insignificant compared with the delay introduced by Raft consensus. This is not a valid concern. I'm surprised they even mentioned it.

>More importantly, it increases the difficulty of staying up-to-date with the new versions of the underline SQL engine (SQLite in this specific case) because the custom parser must be updated each time a new SQL function/feature is introduced.

Theoretically true, not true in practice. Any competent programmer can update any parsing code in a matter of hours.

[1] https://rqlite.io

[2] https://rqlite.io/docs/api/non-deterministic/