I’m using PHP and MySQL. I have records for:
- events with various “event types” that are hierarchical (events can have multiple categories and subcategories, but there are a fixed amount of such categories and subcategories) (timestamped)
What is the best way to set up the table? Should I have a bunch of columns (30 or so) with enums for yes or no indicating membership in that category? or should I use MySQL SET datatype?
http://dev.mysql.com/tech-resources/articles/mysql-set-datatype.html
Basically I have performance in mind and I want to be able to retrieve all of the ids of the events for a given category. Just looking for some insight on the most efficient way to do this.
It sounds like you’re chiefly concerned with performance.
A couple people have suggested splitting into 3 tables (category table plus either simple cross-reference table or a more sophisticated way of modeling the tree hierarchy, like nested set or materialized path), which is the first thing I thought when I read your question.
With indexes, a fully normalized approach like that (which adds two JOINs) will still have “pretty good” read performance. One issue is that an INSERT or UPDATE to an event now may also include one or more INSERT/UPDATE/DELETEs to the cross-reference table, which on MyISAM means the cross-reference table is locked and on InnoDB means the rows are locked, so if your database is busy with a significant number of writes you’re going to have a larger contention problems than if just the event rows were locked.
Personally, I would try out this fully normalized approach before optimizing. But, I’ll assume you know what you’re doing, that your assumptions are correct (categories never change) and you have a usage pattern (lots of writes) that calls for a less-normalized, flat structure. That’s totally fine and is part of what NoSQL is about.
SET vs. “lots of columns”
So, as to your actual question “SET vs. lots of columns”, I can say that I’ve worked with two companies with smart engineers (whose products were CRM web applications … one was actually events management), and they both used the “lots of columns” approach for this kind of static set data.
My advice would be to think about all of the queries you will be doing on this table (weighted by their frequency) and how the indexes would work.
First, with the “lots of columns” approach you are going to need indexes on each of these columns so that you can do
SELECT FROM events WHERE CategoryX = TRUE. With the indexes, that is a super-fast query.Versus with SET, you must use bitwise AND (&), LIKE, or FIND_IN_SET() to do this query. That means the query can’t use an index and must do a linear search of all rows (you can use EXPLAIN to verify this). Slow query!
That’s the main reason SET is a bad idea — its index is only useful if you’re selecting by exact groups of categories. SET works great if you’d be selecting categories by event, but not the other way around.
The primary problem with the less-normalized “lots of columns” approach (versus fully normalized) is that it doesn’t scale. If you have 5 categories and they never change, fine, but if you have 500 and are changing them, it’s a big problem. In your scenario, with around 30 that never change, the primary issue is that there’s an index on every column, so if you’re doing frequent writes, those queries become slower because of the number of indexes that have to updated. If you choose this approach, you might want to check the MySQL slow query log to make sure there aren’t outlier slow queries because of contention at busy times of day.
In your case, if yours is a typical read-heavy web app, I think going with the “lots of columns” approach (as the two CRM products did, for the same reason) is probably sane. It is definitely faster than SET for that SELECT query.
TL;DR Don’t use SET because the “select events by category” query will be slow.