blitzdb

I think Hasura takes care of building „good“ SQL queries that retrieve the data in a single request. I agree that it’s often not viable to resort to the standard GraphQL resolvers that will produce n database queries when asking for a list of items with a corresponding joined field. A while ago I built a MongoDB->SQL wrapper that would take a MongoDB query (with arbitrary many nested $include entries) and convert it to a single SQL query, which worked quite well. Of course this didn’t have any logic to check for permissions as we weren’t “crazy” enough to let arbitrary clients formulate the queries (we did it in the backend). The code is available at https://github.com/adewes/blitzdb, we used it with https://github.com/QuantifiedCode/QuantifiedCode.

I wrote a similar library -BlitzDB- a while ago: https://github.com/adewes/blitzdb It's a pure Python database engine with a MongoDB-like query engine and support for three different backends: File (native), SQL (via SQLAlchemy) and MongoDB. The library transparently translates a large number of MongoDB queries into SQL or its own native storage backend, and when using the SQL backend it can do things that MongoDB can't, like queries spanning multiple relationships. The latest version is not fully documented yet but I'm using it on several production projects myself. I'm looking for a maintainer and contributors btw, so if you're interested feel free to get in touch with me!

A while ago I wrote a similar system, called BlitzDB: https://github.com/adewes/blitzdb It provides a uniform, mongo-like interface over various storage backends, most notably SQL (Postgres, SQLite) via SQLAlchemy, MongoDB itself (well, naturally) and a flat-file based backend that doesn't have any external dependencies. Feel free to check it out, feedback is welcome.

I actually built a MongoDB query interface for SQL via Python+SQLAlchemy. It allows you to query your relational database just like you would with MongoDB, and in addition use some things (e.g. Joins in queries or "deep querying") that are not possible using MongoDB. Here's the repo: https://github.com/adewes/blitzdb The implementation is stable but I'm still working on finishing Python3 support and documentation.

It sounds like you're describing an embeddable document store. There are options for that as well: - UnQLite: http://charlesleifer.com/blog/python-bindings-for-unqlite-an... - tinydb: https://pypi.python.org/pypi/tinydb/ - Blitz: https://github.com/adewes/blitzdb

SQLAlchemy really is great. Alembic (the schema migration toolkit) still lacks some functionality compared to e.g. the Django "South" package, especially concerning the handling of cyclic dependencies (where it just "bails out") and some things that are still not correctly implemented for various database backends (such as Enum fields), but apart from that it's a really really great tool. Recently I have used it to implement MongoDB query sntax on SQL which was not only possible using SQLAlchemy but even enjoyable (for those who are interested in running Mongo queries on SQL: https://github.com/adewes/blitzdb -> see feature/sql_backend branch, which is still not 100 % stable though). What makes it especially amazing is that Mike Bayer has written 90 % of the code base by himself (https://github.com/zzzeek/sqlalchemy/graphs/contributors),

If you're looking for something similar for Python, check out BlitzDB: https://github.com/adewes/blitzdb It's a serverless, flat-file, document-oriented database which supports indexing and transactions and comes with a built-in ORM layer and a rich query language modeled after MongoDB.

I'm working on a document-oriented database engine written purely in Python: BlitzDB! https://github.com/adewes/blitzdb My motivation was that I needed (wanted?) a pure-Python document database that does not have any dependencies (like pymongo) and provides querying capabilities similar to MongoDB. Currently, Blitz is under active development and comes with a file-based backend as well as a MongoDB backend. Contributions to the codebase and feedback are highly welcome :) The issue tracker contains various suggestions for contributions, with various difficulty levels: https://github.com/adewes/blitzdb/issues

Putting side effects in the __init__ code seems to become quite fashionable these days but is a pretty bad idea since it removes the possibility to "just" import the functionality defined by the module without performing any initialization. Personally, I always try to avoid having a system that relies on some global configuration (like e.g. Django, Matplotlib or Flask do). In matplotlib for example this causes a lot of problems, since importing the pylab module will automatically (among other things) load and initialize a backend, which is then set in stone for the rest of the session. IMHO, the way to go here instead is dependency injection: Inject the configuration into the module through a function or class method (e.g. Flask.initialize({config state}). Wrapping all module functionality that depends on configuration in a class is a goo