goatfish

I wrote something that works more or less the same way, but exclusively over SQLite: https://github.com/skorokithakis/goatfish/ It's actually quite good as a quick-and-dirty datastore. I do need to move everything to SQLite's JSON field, though.

This is only tangentially related, but I rediscovered an old project of mine from years ago today and am rather excited about it: https://github.com/skorokithakis/goatfish It's basically a 200 line document database in Python that's backed by SQLite. I need to store a bunch of scraping data from a script but don't want a huge database or the hassle of making SQLite tables. Goatfish is perfect because it stores free-form objects (JSON, basically), only it lets you index by arbitrary keys in them and get fast queries that way. It's pretty simple, but a very nice compromise between the simplicity of in-memory dicts and the reliability of SQLite.

You might like this: https://github.com/stochastic-technologies/goatfish/

I wrote something like this: https://github.com/stochastic-technologies/goatfish I very much support NoSQL (schemaless, really) databases on SQLite, as it's a great RDBMS and schemaless databases are very handy for various things. I'd love an embedded Redis, but this is pretty much the second best thing.

That's exactly what I did! https://github.com/stochastic-technologies/goatfish

I wrote a very simple thing to sort-of emulate this on SQLite. It works rather well for prototyping! https://github.com/stochastic-technologies/goatfish It also supports indexing on arbitrary fields and is only a few lines of code. It did come in very handy.

Yeah, I have experimented with schemaless stores a bit (mostly with JSON fields in postgres, for now), to avoid adding columns for various things to the database, and I am not impressed. Not only is initialization and migration hard, but I've come to realize that there's no downside in adding these to the schema itself. Sure, the schema gets a bit bloated and dirty, but having undocumented fields in a dict whose existence is signified only by a line of code assigning something is not better. Where schemaless stores are great is prototyping. Especially for more algorithmic code, where I don't really know what storage I'll be needing and the algorithm will only live there for a few days, schemas are just a burden. That's why I wrote Goatfish: https://github.com/stochastic-technologies/goatfish

I did need a schemaless store for a project I was prototyping, but then I didn't see why I had to install MongoDB just to get a simple schemaless store. So, I wrote Goatfish: https://github.com/stochastic-technologies/goatfish/

If you use SQLite, you can use Goatfish[1]. It's not production-ready or as robust as Postgres's hstore, but it's embedded (since it works with SQLite) and also allows you to index various properties. [1] https://github.com/stochastic-technologies/goatfish

This is (almost) exactly what Goatfish[1] does, except it uses SQLite, and can create SQL indexes on any arbitrary field. I needed a schemaless, embeddable store, so I decided to go with that, since Postgres already has the hstore. It's still very simple and preliminary, but it works, and it's very useful for prototyping. I'd like to develop it some more, if people found it useful and started using it. [1] https://github.com/stochastic-technologies/goatfish

If you want to run a NoSQL layer over a relational DB, check out something like Goatfish: https://github.com/stochastic-technologies/goatfish Not production code by any stretch, but an interesting concept, and I'd be more inclined to work on it if more people were using it.

Which features, are making you consider MongoDB? I'm asking because I wrote a (really short and small) MongoDB-ish abstraction layer over SQLite the other day (https://github.com/stochastic-technologies/goatfish), and it seems to me that it's trivial to emulate the MongoDB queries and various other features over SQL without all the hassle of it eating your data or requiring 100 GB of RAM for a few indices.

This[1] was the most fun I've had in ages. MongoDB already exists, but this was just a blast to write and is great to use. I agree with both you and peterforde, you guys are really arguing about orthogonal issues. [1] https://github.com/stochastic-technologies/goatfish

This, along with the dependencies (I don't like having to install MongoDB just for this), is the reason I don't want to try this. I could probably deal with the installation, although I hate installing all those daemons and init scripts myself, but installing Mongo just for one thing, gah. Too bad there isn't an embedded version of Mongo, and my own goatfish[1] is still far from mature. [1] https://github.com/stochastic-technologies/goatfish