Storing an object with unknown structure

Question

Assuming

• A User can have many Characters
• A Character belongs to a User
• A Character has the basic attributes name, player, experience_points, status
• A Character can be one of many different ?Types? (working name)
  • I say "be" because I'm not sure if this is a has_a relationship where Type is an attribute
  • Example Types are
    • D&D5e with the attributes class, abilities, spells
    • WoDVampire with the attributes nature, demeanor, willpower, generation, blood, etc.
    • WoDWerewolf with the attributes nature, demeanor, gnosis, rage, etc.

(Note: some of the above attributes are better reflected as E/Rs, but that's beside the point right now.)

I'm not sure how to model this E/R between Character and Type (which I should change the name of because there's already an attribute :type.)

I considered Single Table Inheritance but found it lacking, because it looks like all of the attributes between all of the potential Types would be stored in the same table, which seems very... clunky.

Answer 1

One thing to note is that it is not a requirement to store all of the data in the database.

In case characters of the same type share the same set of abilities, those abilities and the amount of types are pretty static (do not change frequently), you could build your logics around a set of plain ruby classes containing all the required data and methods to access it.

On the other hand, you may want to let somebody without a proper knowledge of programming to add new classes. In this case you could save all the info as a local file on your filesystem, e.g. "wod_vampire.chr". Its contents could be a hash with key-value pairs of attributes and their values, or may be an array with elements in some particular order.

Okay so we considered all the non-database ways and they do not suite us. Assuming you're using a relational database, there is still a couple of options.

The first one is a Single Table Inheritance (you know about this way already). All the possible attributes gonna be stored in a single table, but each of the types would know and interact with only a particular set of those ones.

The second one is to use json datatype implemented in some of the modern databases (e.g. Postgresql and Mysql). This allows you to store a hash without a restriction to its structure (in other words, you can have as many different attributes as you need). Note that you may need to implement your own set of getters/setters methods to access values stored in this way.