This is the second SQL Challenge from the phpBB Doctor. It is my hope that this series of posts will be interesting but educational as well. The concept is simple: I will post a challenge that must be solved with (unless stated otherwise) a single SQL statement. No php code, no “insert into…” temporary tables, just one simple (or more likely not-so-simple!) SQL statement. There is often more than one way to solve the same problem, so I personally will be interested to see some of the solutions that are presented. Eventually I will post my original answer and optionally the best answers (judged by me) submitted to the challenge as well. Some of the challenges will use phpBB tables and data, others may use special data that I will create and make available for you to download.

What do you win? You win the knowledge that you solved a challenge. Is that enough for you?

This one, in my opinion, is tough. In my solution I use several different SQL tricks that you may or may not have been exposed to. But give it a shot and see what you come up with.

The Setup

For this challenge you should be able to use your own board. You need at least three months of posting data in order to attempt this challenge. The more data you have, the more interesting this query becomes, at least in my opinion. This challenge is based on a real-world question that I wanted to answer the other day. In many cases the “top ten” posters are in that position because they have remained active for a long time. My biggest board is now over five years old, and over time some of the top-ten posters have gradually been falling down (or off of) the list. So I thought it would be interesting to write a query that would identify the current top-ten users and then show me their average monthly post count for the last three months. That way I would get an indication of how many of my top-ten posters were still showing any level of activity.

The Challenge

You want to know the average number of posts per month made by your top-ten posters over the past three months. You need to determine the top-ten posters from your board inception date and then show the average number of posts each of them has made in the last three months. The technique that I used requires version 4.1 of MySQL at minimum.

You can assume that the value in user_posts is accurate and use it to determine your top-ten posters. In many cases the user_posts value is not 100% accurate, either because of pruning (which does not reduce the post count) or MODs (some board admins have forums that do not increment your post count). I won’t worry about that for this challenge, treat user_posts as being the correct value.

Here are the results that I got, with the names obscured for privacy:

+--------------+-----------------+
| username     | avg(post_count) |
+--------------+-----------------+
| 1afa4b18ad00 |        202.0000 |
| 3ec682b8d52e |         25.0000 |
| 586c0d4f087d |        120.3333 |
| 87e25d48d6a8 |          0.0000 |
| 97ec7e2e5296 |         13.6667 |
| a719c7a5e035 |        115.3333 |
| c1909711326d |        119.6667 |
| cac58b5234e1 |        154.0000 |
| f6bc46b581ba |          0.0000 |
| f8b21c8ff704 |        179.0000 |
+--------------+-----------------+

As you can see, I got my answer. Two of my current top-ten users have not done a thing (average of 0.0 posts) in the last three months. If you are curious, the username is obscured by running it through the md5() function and then chopping off some of the characters. Ultimately this query did not tell me anything that I had not already been able to derive simply by looking at the data. But it does use some interesting SQL techniques.

The Data

Here’s what the data looked like:

+-------------+----------+----------+----------+----------+----------+----------+
| total_posts | w1_posts | w2_posts | w3_posts | w4_posts | w5_posts | w6_posts |
+-------------+----------+----------+----------+----------+----------+----------+
|          56 |        3 |        4 |        8 |        9 |       16 |       16 |
|         589 |       39 |       53 |       89 |      106 |      152 |      150 |
|           7 |        1 |        0 |        0 |        0 |        3 |        3 |
|           2 |        0 |        1 |        0 |        0 |        1 |        0 |
|          10 |        0 |        1 |        3 |        3 |        1 |        2 |
|         266 |       36 |       37 |       61 |       43 |       34 |       55 |
|          14 |        1 |        1 |        3 |        0 |        1 |        8 |
|           5 |        0 |        0 |        0 |        0 |        0 |        5 |
|          15 |        2 |        3 |        2 |        1 |        3 |        4 |
|         236 |       58 |       53 |       49 |       31 |       19 |       26 |
|           5 |        0 |        2 |        1 |        0 |        2 |        0 |
|          46 |       27 |        0 |        2 |        9 |        8 |        0 |
|           3 |        2 |        0 |        0 |        0 |        0 |        1 |
|           4 |        2 |        2 |        0 |        0 |        0 |        0 |
+-------------+----------+----------+----------+----------+----------+----------+

Here was the desired output:

+------+----------+
| wk   | count(*) |
+------+----------+
|    1 |     1139 |
|    2 |      407 |
|    3 |      198 |
|    4 |       85 |
|    5 |       64 |
|    6 |       46 |
+------+----------+

This challenge is really quite simple, as long as you know the proper function to use.

I Saw The Sign…

One of the fairly standard functions that I use is sign(). I say “fairly standard” because it is available on most of the databases I have worked with. It’s a very simple function but that doesn’t stop it from being quite versatile at the same time. The definition of sign() is as follows:

sign(X) = 1 if X > 0
sign(X) = 0 if X = 0
sign(X) = -1 if X < 0
sign(X) is null if X Is Null

So X can be any of an infinite number of values from minus infinity to plus infinity, and the sign() function will return a finite number of values. How does this help?

In this challenge all I want to know is if someone posted. It's impossible for someone to have a negative or null post count. So the results of a sign() function will be exactly zero or one. Hmmm, binary. I like binary.

The Solution

So here is my solution that generates the output as shown above from the data I provided:

select	sign(w1_posts)+sign(w2_posts)+sign(w3_posts)+sign(w4_posts)+sign(w5_posts)+sign(w6_posts) as wk
,	count(*)
from	sql_challenge_01
group by 1

What this sign() function does in this case is reduce any positive post count to one, and leave any zero post count at zero. If you then sum those values together you can count the number of weeks that included posts by a user. To do that, I include count(*) as the second column in my query.

Let me take the first three rows of the data and show how this works:

+-------------+----------+----------+----------+----------+----------+----------+
| total_posts | w1_posts | w2_posts | w3_posts | w4_posts | w5_posts | w6_posts |
+-------------+----------+----------+----------+----------+----------+----------+
|          56 |        3 |        4 |        8 |        9 |       16 |       16 |
|         589 |       39 |       53 |       89 |      106 |      152 |      150 |
|           7 |        1 |        0 |        0 |        0 |        3 |        3 |

Each of the first two rows have a positive value for each weekly value. So the sign() function will reduce them to 1. The net result is 1+1+1+1+1+1 or 6. That means that user posted in each of the last six weeks. The third row has 3 positive values and 3 zero values. The net is 1+0+0+0+1+1 or 3. That user has posted in three of the last six weeks. Simple, eh?

Note that I don't care which weeks the user has posted in, only that there was at least one post. By creating the column as shown in the solution SQL above I will generate a number from 1 to 6. The "group by" clause pulls those rows together and the count(*) counts the number of rows that match.

Another Sign

I mentioned that I use this function frequently, and so I thought I would share another use of the same function. I want to run one query that will show me how many users I have, how many activated users I have, and how many posting users I have. A user count is simple. The user_active field is already a binary, so I can simply sum() that field to count activated users. The user_posts field can have numbers from zero to infinity (it should not have negative numbers, but it can, and I ignore that in this solution). In order to count, I need to reduce that infinite number of values down to something binary. Like this:

select	count(user_id) as total_users
,	sum(user_active) as active_users
,	sum(sign(user_posts)) as posting_users
from 	phpbb_users;

There are other ways this could have been done. But I believe this is probably the easiest.

Did anyone else get something different? If so, please share. SQL Challenge #2 is much harder than this one, and will come out in the next few days. The rules are the same, solve the challenge using a single query, no php code is allowed.

The Setup

Here is the table:

mysql> desc sql_challenge_01;
+-------------+-----------------------+------+-----+---------+-------+
| Field       | Type                  | Null | Key | Default | Extra |
+-------------+-----------------------+------+-----+---------+-------+
| total_posts | int(11)               |      |     | 0       |       |
| w1_posts    | mediumint(8) unsigned | YES  |     | NULL    |       |
| w2_posts    | mediumint(8) unsigned | YES  |     | NULL    |       |
| w3_posts    | mediumint(8) unsigned | YES  |     | NULL    |       |
| w4_posts    | mediumint(8) unsigned | YES  |     | NULL    |       |
| w5_posts    | mediumint(8) unsigned | YES  |     | NULL    |       |
| w6_posts    | mediumint(8) unsigned | YES  |     | NULL    |       |
+-------------+-----------------------+------+-----+---------+-------+

My original work table included the user_id but I dropped that from the challenge version of the table since you won’t need to join to anything. Here are some sample rows from the table so you can get a feel for what it looks like:

+-------------+----------+----------+----------+----------+----------+----------+
| total_posts | w1_posts | w2_posts | w3_posts | w4_posts | w5_posts | w6_posts |
+-------------+----------+----------+----------+----------+----------+----------+
|          56 |        3 |        4 |        8 |        9 |       16 |       16 |
|         589 |       39 |       53 |       89 |      106 |      152 |      150 |
|           7 |        1 |        0 |        0 |        0 |        3 |        3 |
|           2 |        0 |        1 |        0 |        0 |        1 |        0 |
|          10 |        0 |        1 |        3 |        3 |        1 |        2 |
|         266 |       36 |       37 |       61 |       43 |       34 |       55 |
|          14 |        1 |        1 |        3 |        0 |        1 |        8 |
|           5 |        0 |        0 |        0 |        0 |        0 |        5 |
|          15 |        2 |        3 |        2 |        1 |        3 |        4 |
|         236 |       58 |       53 |       49 |       31 |       19 |       26 |
|           5 |        0 |        2 |        1 |        0 |        2 |        0 |
|          46 |       27 |        0 |        2 |        9 |        8 |        0 |
|           3 |        2 |        0 |        0 |        0 |        0 |        1 |
|           4 |        2 |        2 |        0 |        0 |        0 |        0 |
+-------------+----------+----------+----------+----------+----------+----------+

The various columns w1_posts, w2_posts, and so on contain the number of posts that a user made during that week. I built this table to help analyze how frequently users were visiting my board. In order to do that, I needed to know how many users had visited and posted in every one of the past six weeks, along with how many had posted in at least five (any of the last five) weeks, and so on.

The Challenge

Your challenge, should you decide to accept it, is to write one SQL script (not php!) that returns a count of how many rows in this table include users that posted in all six weeks, in any five weeks, in any in four weeks, and so on. If you look carefully at the data, any single column could be zero. Checking for rows that include posts in all six weeks is easy. Checking for rows that include posts in five out of the six gets a bit more challenging as any one of the six weeks could be zero. And so on from there.

When I say “in any five” I mean exactly five weeks. Anyone that posted in six weeks also posted in five, but that’s not where I went with this. “Any five” means just that.

Here is the expected output:

+------+----------+
| wk   | count(*) |
+------+----------+
|    1 |     1139 |
|    2 |      407 |
|    3 |      198 |
|    4 |       85 |
|    5 |       64 |
|    6 |       46 |
+------+----------+

So this tells me that 64 rows in the sample data had non-zero values in five out of the six weekly columns. 407 rows had non-zero values in 2 out of the six. And so on. The expected value for “wk” based on the sample rows shown above would be this:

+-------------+----------+----------+----------+----------+----------+----------+------+
| total_posts | w1_posts | w2_posts | w3_posts | w4_posts | w5_posts | w6_posts | wk   |
+-------------+----------+----------+----------+----------+----------+----------+------+
|          56 |        3 |        4 |        8 |        9 |       16 |       16 |    6 |
|         589 |       39 |       53 |       89 |      106 |      152 |      150 |    6 |
|           7 |        1 |        0 |        0 |        0 |        3 |        3 |    3 |
|           2 |        0 |        1 |        0 |        0 |        1 |        0 |    2 |
|          10 |        0 |        1 |        3 |        3 |        1 |        2 |    5 |
|         266 |       36 |       37 |       61 |       43 |       34 |       55 |    6 |
|          14 |        1 |        1 |        3 |        0 |        1 |        8 |    5 |
|           5 |        0 |        0 |        0 |        0 |        0 |        5 |    1 |
|          15 |        2 |        3 |        2 |        1 |        3 |        4 |    6 |
|         236 |       58 |       53 |       49 |       31 |       19 |       26 |    6 |
|           5 |        0 |        2 |        1 |        0 |        2 |        0 |    3 |
|          46 |       27 |        0 |        2 |        9 |        8 |        0 |    4 |
|           3 |        2 |        0 |        0 |        0 |        0 |        1 |    2 |
|           4 |        2 |        2 |        0 |        0 |        0 |        0 |    2 |
+-------------+----------+----------+----------+----------+----------+----------+------+

So, there you go. The first SQL Challenge from the phpBB Doctor. What do you win? You win the knowledge that you solved a puzzle. Is that enough for you? It is my hope that this series of posts will be interesting but educational as well. There is often more than one way to solve the same problem, so I personally will be interested to see some of the solutions that are presented. Eventually I will edit the post and include my original answer and optionally the best answers (judged by me) submitted to the challenge as well.

The Material

This is a zip file that contains a SQL script that will create and populate the table used in this challenge.

sql_challenge_01.zip

Some of the future challenges will use the standard phpBB tables instead of requiring you to download and install something. I used this for the first challenge because I thought it presented an interesting challenge.