Question

I have the following generic schema to represent different types of information.

var Record = new Schema (
{
   type: {type: String}, // any string (foo, bar, foobar)
   value: {type: String}, // any string value
   o_id: {type:String}
}
);

Some of the records based on this schema have:

• type=”car”
• value=”ferrari” or
• value=”ford”

Some records have type “topspeed” with value “210” but they always share o_id (e.g. related “ferrari has this topspeed”). So if “ferrari has top speed 300”, then both records have same o_id.

How can I make query to find “ferrari with topspeed 300” when I don’t know o_id?

The only solution I found out is to select cars “ferrari” first and then with knowledge of all o_id for all “ferrari” use it to find topspeed.

In pseudocode:

Record.find({type:"car", value:"ferrari"}, function(err, docs)
{
   var condition = [];// create array of all found o_id;
   Record.find({type:"topspeed", value:"300"}...
}

I know that some merging or joining might not be possible, but what about some chaining these conditions to avoid recursion?

EDIT:
Better example:

• Lets imagine I have a HTML document that contains DIV elements with certain id (o_id).

• Now each div element can contain different type of microdata items (Car, Animal…).

• Each microdata item has different properties (“topspeed”, “numberOfLegs”…) based on the type (Car has a topspeed, animal numberOfLegs)

• Each property has some value (310 kph, 4 legs)

Now I’m saving these microdata items to the database but in a general way, agnostic of the type and values they contain since the user can define custom schemas from Car, to Animal, to pretty much anything). For that I defined the Record schema: type consists of “itemtype_propertyname” and value is value of the property.

I would eventually like to query “Give me o_id(s) of all DIV elements that contain item Ferrari and item Dog” at the same time.

The reason for this general approach is to allow anyone the ability to define custom schema and corresponding parser that stores the values.

But I will have only one search engine to find all different schemas and value combinations that will treat all possible schemas as a single definition.

Answer 1

I think it’d be far better to combine all records that share an o_id into a single record. E.g.:

{
  _id: ObjectId(...),
  car: "ferarri",
  topspeed: 300
}

Then you won’t have this problem, and your schema will be more efficient both in speed and storage size. This is how MongoDB is intended to be used — heterogenous data can be stored in a single collection, because MongoDB is schemaless. If you continue with your current design, then no, there’s no way to avoid multiple round-trips to the database.