Hierarchial, tree-like data model, which DB type? I have the need for a database, I know what to store, however the question is what database to use and why. I have used relation SQL databases a lot in the past (up to a few years ago) and I know I could do this in SQL. My question is mostly if there is a better alternative. I will sketch the scenario.

I have objects, and those objects can also contain other objects. There is a hierarchial relationship between those objects, bigger objects can contain smaller objects, not the other way around, but outside of this fact, the smaller and bigger objects are to be treated the same, have similar features and can and will be queried just the same. Important to note is that smaller objects can be part of multiple bigger objects (shared by the bigger objects)

Most of the queries will be on an identifier, to just retrieve the main object information plus the objects that it contain (and the objects those objects contain). Most of the information on these objects will remain the same, with a few exceptions, information that will be updated frequently. The important update is adding new objects (and their children which are also objects)

The two options that I see are:


SQL relational database, with a table that has two keys (parent and child)
MongoDB style document database, faster query times (I think, since we can use object ID as index) but slower and more chances at messing up


Is there something I'm missing? What is likely the best approach?
A graph database would be a good candidate. They specialise at retrieving interconnected data and navigating the relationships between objects. The ones I'm familiar with allow dynamic schema so different objects can have different values. Some allow classes of objects to be constructed so some consistency can be enforced. The links between objects are integral to query processing. 

A document database has no explicit concept of a connection between one record / row / object / node and another. Your queries would reduce to step-by-step retrieval of an object, then following the "foreign key" pointers to other objects in the application. At least in an RDBMS the referential integrity could be enforced.