I'm currently building a forum component for a larger application and I'm considering different approaches to certain parts of the database schema. In particular, I am considering representing topics and posts in a single table. While I view topics and posts as practically the same, I feel a bit apprehensive as this may make things less flexible in the future.
When topics of a particular forum are queried, the title and first post will be shown as well as some of the user information (basically the name and avatar). In this application, there are various attributes that are used by both topics and posts except for views and replies; and perhaps title, and forum_id(forum_id because that would mean potentially hundreds of records need to be affected if a topic is changed to another forum as opposed to changing the forum_id attribute in the topic relation).
The tables look something like what I have below here:
TOPIC POST
topic_id poster_id
forum_id topic_id
poster_id content
title upvote
views dnvote
replies closed
post_id deleted
last_edited
last_editor
parent_id
content
post_id
Doing it this way, using table inheritance, generating the posts in the topic would require a 4-table join via TOPIC, POST, USER, and TOPIC_TYPE.
On the other hand, if I decide to take the single table approach, should I simply leave the views, replies, title, and forum_id attributes as null if the topic_type is a regular post? (topic_type references an appropriate icon for the type of topic displayed, and will be used for statistics and etc.)
If you are definitely committed to using relational technology (I would consider NoSQL db for this like Mongo, etc. as well) I would separate into two tables as you proposed.
Your case here is a fundamental of relational master-detail design or whole-parts and I think that two tables are appropriate.
I think in this scenario simple normalization is preferred. It will also be useful to generate different types of reports as well. Although single table may be used but as you have designed the table in this case if you use two tables that would be more manageable to avoid entry of same value multiple times.
It might be worthwhile to distinguish between a "topic" and a "topic starter" as such. A "topic starter" is a comment that is not a reply. Every topic has exactly one topic starter, which could be referenced by a foreign key in the topic table.
Other than that, I agree with both your analysis and your design.
Related
I'm currently in the process of building another generic Blog style website, and I got to thinking. Where I usually use a separate table for Posts and another for Comments and then join them using FK's. I began to wonder, are they really worthy of separate tables?
For example properties they both share include:
ID (int)
Title (string)
Body (text)
Poster (FK)
Created At (Datetime)
Updated At (DateTime)
Likes/Dislikes(ints)
Etc..
One Post Has(optional) Many Comments,Many Comments have one Post, but also One Comment, may also have many Comments.
Now would it make more sense. For a table to contain both, Comments and Posts, and self reference them from within? Having a separate lookup table for containing what each type of entity is.
Then however, if a Post is a Comment, and a comment is no different to a post. Except for in a view context, should posted Images also be contained within the same table? As these to, can have likes/comments/name etc.
Question in short: Do blog Posts and Comments belong in the same table?
I'm going to offer you a practical answer.
As a rule of thumb, when you have two apparent sub-types with only one or two different predicates then it isn't necessarily helpful to store them in separate physical tables.
Your logical model should make a distinction between posts and comments, because they have different relationships.
For your physical model, you really only have that one different predicate, according to your description. The basic difference between a post and a comment seems to be the foreign key which references a parent post/comment. I'm assuming you would say a post cannot have a child post, whereas you have said that a comment can have a child comment.
With this being the only difference, I would say that for practical purposes your physical tables should combine posts and comments.
How can you decide in general?
In general it's not cut and dry when to physically sub-type your tables. All design is trade-offs. What I look for are the number of different columns between two sub-types, but also I look at what those columns are and how much they might impact my application logic.
Having more than a few different predicates is usually a pretty good sign that you should be sub-typing physically. However, if these columns are just coming along for the ride, as it were, and don't impact your application logic too much, then maybe they should just be nullable columns on a combined table.
On the other hand, maybe there is only one different column between two sub-types, but that column completely changes the way your application behaves. In that case, maybe for the sake of keeping your code cleaner you should physically sub-type for that column alone.
I'm in the process of structuring a databasemodel for my new project. For all the entities in my model (which is a cms, and the entities as such f.ex: page, content, menu, template and a bunch of others) they all have in common the same attributes on dates and names.
More specifically each entity contains the following for the dates: IsCreated, IsValidFrom, IsPublished, IsDeleted, IsEdited and IsExpired, and for names: CreatedByNameId, ValidFromByNameId, PublishedByNameId and so on...
I'm going to use EF5 for mapping to objects.
The question is as simple: What is the best way to structure this: Having all the fields in every table (which I am not obliged to...) or to have two separate tables which the other can relate to...?
Thanks in advance /Finn.
First of all - give this a read - http://www.agiledata.org/essays/mappingObjects.html
You really need to think about your queries/access paths. There are many tradeoffs between different implementations.
In reply to your example though,
Given the following setup:
COMMON
ValidFromByNameId
SPECIFIC1
FieldA
SPECIFIC2
FieldB
Querying by the COMMON attributes is easy but you'll have to work some magic when pulling up the subclasses (unless EF5 does it for you)
If the primary questions you're asking are about specific1 and specific2 then perhaps this isn't the right model. having the COMMON table doesn't really buy you much necessary as it will introduce a join to load any Specific1 object. In this case, i'd probably just have duplicate columns.
This answer is intentionally partial as a full answer is better handled by the numerous articles and blogs already out there. Search for "mapping object hierarchies to databases"
I'm working on a proprietary feedback application. I have a table named topics that I will to use to store suggestions, questions, and problems.
topics [ id, user_id, title, content, type[suggestion, question, problem] ]
I can easily store this data in one table using a type column to distinguish between the three different topic types.
However, there's another wrinkle: Each topic has its own responses too, and responses are very similar to the topics themselves. I'm tempted to store them in the same table as well. So now I have type (suggestion, question, problem) and subtype (topic, response).
Am I asking too much of my topics table? Should I split my data into separate tables? I'm using Postgres and Rails for this particular project.
Best way to visualise is to compare it to StackoverFlow. SO stores questions and answers in the same posts table. Now suppose instead of only questions SO decided to allow suggestions and problems. Would they still use the same table?
How often you'll want to query both topics and responses in one action? Maybe when searching, but sometimes you also want to search only topics or only responses. And how often you will need to query only one of them? Most of the time.
Go for two separate tables, you can use views with UNION clause if you want to use them together. Also at the application level you can build inheritance model on top of relational database. Say Post object with Topic and Response subclasses. Some libraries like hibernate will transparently translate query for *all posts that...` into two separate queries and union results together.
Another approach (also being one of the ways to deal with inheritance in relational store) would be to have... three tables! Posts, Topics and Response, the last two having foreign key to Posts. This way common columns are in one table and type-specific columns are separately.
Keeping topics and responses in one table is better for forums. (A lot depends on the functionality you plan to have. Is it a forum or a news/articles/reviews site?)
Most forum frameworks use this design. Including SO as you mentioned. One distinction to make clear - note that what you are defining as "topic" is generally "post". So "responses" are also posts. What other frameworks call "topic" is the thread info.
Here's an image of phpBB's schema (warning, 1MB). Notice the phpbb_posts table with post_text and topic_id (where topic_ is the title, forum id, view count, etc. but not the post_text).
StackOverflow: The PostTypeId in the Posts table - "1 is a question, 2 is an answer. Answers will have a ParentId field populated to link back to the question post."
See this related question and google for others: How would you structure a forum's DB schema?
You could query a post + responses using something like:
select t.id, t.user_id, t.title, t.content, t.type, t.parent_id,
r.id, r.user_id, r.title, r.content, r.type, r.parent_id
from topics t
left join topics r on r.parent_id = t.id
where t.parent_id = 0 and t.id = <specific id>
The part you should separate is: If you want to show thread summaries like the stackoverflow Questions/Active/Newest pages; or forum index with latest topics, response, poster, etc. then maintaining a thread_info table would help for database performance, especially if you expect high vistor volume and/or many threads and posts.
Now suppose instead of only questions SO decided to allow suggestions and problems. Would they still use the same table?
For Suggestions that depends. Look at comments for example. Different table. The nature(model) + functionality of comments is different enough to be stored separately.
Taking another example: on news / reviews sites or like in wordpress, articles and their responses would be stored separately because of the same reasons. Articles would have relations to site authors, related articles, formatting, categories, etc. Responses would be threaded, possibly unformatted, etc.
Use multiple tables here, you said it yourself: there's another wrinkle: Each topic has its own respons*es* too
Multiple of anything usually requires another table.
I'd see it like this:
[TOPICS] [ topicID, user_id, title, content, type[suggestion, question, problem] ]
[SUGGESTION] [ suggID <fields here> *topicID ]
Note topicID as a foreign key in [SUGGESTION]
suppose I needed to design a database for a bulltin-board website.
something like stackoverflow which means there is a topic and a series of posts
but, no threaded posts (not a tree-based design)
I thought about two main options:
Topic table and Post table. Post has "topic_id" field
no Topic table. only one big Post table.
what do you think is the more preferable option?
Well, stackoverflow is a tagged based design, where a post may have multiple topics/tags.
So to capture this in a relational-style design, you would have three tables:
POST (post_id, author, etc.)
TOPIC (topic_id, name, etc.)
POSTTOPIC (post_id, topic_id)
The reason for POSTTOPIC is because a post may have multiple tags. Using #3, it becomes easy to assign/unassign tags to a post or to find posts with certain topics. None of which a column in POST would be able to accommodate.
For example, I have "news" and "articles" tables and I want comment these entries using "comments" table.
What the best way to make relationship and comment different entries?
I assume both news and articles to comments are one-to-many . And I also assume the same comment cannot associate to a new and an article at the same time.
One of the way is that:
Advantages is that the Schema is normalized ,data integrity is properly maintained and it allows for schema evolution. For example , there may be possibility to add the comment for another similar kind of entity in the future (eg Allow adding comments for the blog table).
Disadvantages is that it requires join extra table when query the comments for a news or articles