A quick Google search turned up just the tutorial I needed from the design blog Hongkiat.com:

How to Separate Comments and Trackbacks [Wordpress Tips].

I found a ton of solutions (some from people with no clue about the difference between median and average), but the one below — adapted from a post by Adam Machanic at sqlblog.com — was the best. It produces accurate results and is fairly speedy to boot.

Here’s an example. Consider this table with student grades from two courses:
.

We’d like to find the median grade in each class. Here’s the script:


DECLARE @tmp TABLE (
   ID int identity(1,1),
   Class varchar(50),
   FirstName varchar(50),
   Grade decimal(5,1)
)

INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Math', 'Bob', 65)
INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Math', 'Joe', 72)
INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Math', 'Sally', 95)
INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Science', 'Bob', 65)
INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Science', 'Joe', 81)
INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Science', 'Sally', 81)
INSERT INTO @tmp (Class, FirstName, Grade)
   VALUES ('Science', 'Mike', 72)

SELECT
   x.Class,
   CAST(AVG(x.Grade) AS DECIMAL(6,1)) AS 'Median'
FROM
(
   SELECT
   Class,
   FirstName,
   Grade,
   ROW_NUMBER() OVER (
      PARTITION BY Class
      ORDER BY Grade ASC, ID ASC) AS RowAsc,
   ROW_NUMBER() OVER (
      PARTITION BY Class
      ORDER BY Grade DESC, ID DESC) AS RowDesc
   FROM @tmp
) AS x
WHERE
   RowAsc IN (RowDesc, RowDesc - 1, RowDesc + 1)
GROUP BY x.Class
ORDER BY x.Class

That’s a lot. Let’s break down what’s happening.

First, to set up the data, we’re creating a temporary table and inserting seven rows.

Then comes the main SELECT, which includes a subquery that’s the meat of the goodness behind this. The subquery uses the ROW_NUMBER function to create ascending and descending row identifiers based on the ordering of the grades. It’s easier to visualize if you see what the subquery’s creating:
.

The RowAsc and RowDesc fields reflect the ordered row numbers of the grades per each class (i.e., partition). Given those, it’s easy to find the median. For the math class, with an odd number of students, the median occurs where RowAsc equals RowDesc. For the science class, with an even number of students, the median is the average of the two grades where RowAsc and RowDesc are within one of each other.

(Whenever you’re looking for the median in an ordered list that has an even number of values, averaging the two middle numbers gives the answer.)

That’s what our main query does when it pulls from the subquery result set. It looks for:

RowAsc IN (RowDesc, RowDesc - 1, RowDesc + 1)

and then averages what it finds. The answer is 72 for the math class and 76.5 for science.

This solution works with T-SQL and Microsoft SQL Server. With minor tweaks, it also runs fine in PostgreSQL 8.4, which also implements the ROW_NUMBER function. MySQL does not support that function, so you’ll have to search for another option.

Good stuff and pretty handy for extracting large numbers of median values without having to resort to a stats program.

Portfolio AD is a one-column theme with a two-column sidebar. Both columns in the sidebar can display widgets. The header is a modification of the well-worn Hemingway theme, and the rest is my take-off of a site built via this tutorial from WPDesigner.com. It works fine with WordPress 3.0.

What you see here is the result of constant tinkering. I coded up a theme of my own to learn more about what WordPress can do, and in the process I have learned tons about CSS, HTML, web hosting and content management systems in general. If you have the time, it’s well worth the investment.

Use the theme as a starting point for your own tinkering and have fun!

“Never stop learning.”

Plenty of people, regardless of industry, argue otherwise. Play it safe, take few risks and stay with the tried and true — that keeps the bills paid and the lights on.

Decades ago, “No one ever got fired for buying IBM” was a phrase you could bank on. IBM had it all — the kings of the air-conditioned mainframe, making oodles of money, and very snug in their white-shirt-and-tie ways. But they were slow to learn. PCs came along, the mainframe business withered, OS/2 failed to unseat Windows, and tens of thousands of people in IBM-hometowns found themselves unemployed. IBM’s come back, but it’s nothing like the company it was in 1980.

Stop learning, rest on the existing models, and it’s easy to become a mainframe-hawker in a PC revolution. Or a railroad tycoon watching with disregard as Henry Ford mass produces Model T’s.

I’ve practiced Jerry McBride’s advice better at times than others. Lately, very much so. I’m on a learning jag. My latest quest is Ubuntu, Apache, PostgreSQL and Django. Last night, this little screen brought a smile or two:

P.S. My bookmarks and RSS feeds prove one thing: There’s no excuse for not learning; the Internet is the best free library you’ll ever find.

I realize that many journalists prefer the open source (free) MySQL to Microsoft’s product, so I’ve replicated the five queries below in MySQL syntax. You can download script files for either syntax here:

– Five essential queries (MS SQL Server)
– Five essential queries (MySQL)

Feedback and your ideas are welcome. Here they are:

1. Create a temporary table with identity column.
Temp tables are handy for storing and manipulating data when you need a table but don’t want to make it part of your actual schema. In SQL Server, the table variable is held in memory and disappears once the query finishes executing.

DECLARE @tmp TABLE (
   id int identity(1,1),
   FirstName varchar(50))

INSERT INTO @tmp (FirstName) VALUES ('Bob')
INSERT INTO @tmp (FirstName) VALUES ('Joe')
INSERT INTO @tmp (FirstName) VALUES ('Sally')

SELECT * FROM @tmp

2. Use a CASE expression to update a field based on values in another field.
Here, we create a temporary table that has FirstName and NickName fields. If we want to update the NickName field based on the values found in FirstName, we can use a standard UPDATE statement with CASE embedded.

DECLARE @tmp TABLE (
    id int identity(1,1),
    FirstName varchar(50),
    NickName varchar(50))

INSERT INTO @tmp (FirstName) VALUES ('Robert')
INSERT INTO @tmp (FirstName) VALUES ('Joseph')
INSERT INTO @tmp (FirstName) VALUES ('Elizabeth')

UPDATE @tmp
SET Nickname =
   CASE
      WHEN FirstName = 'Robert' THEN 'Bob'
      WHEN FirstName = 'Joseph' THEN 'Joe'
      WHEN FirstName = 'Elizabeth' THEN 'Liz'
   END

SELECT * FROM @tmp

3. Join a table to itself using aliasing.
Sometimes, it’s handy to be able to join a table to itself or to join the results of two or more queries. Using aliases is a helpful way to do this. In this example, we create a table to hold information on eating contests. Each row has the result for one contestant and includes name, contest date and their result.

Let’s say we want to know, for each contestant, their most recent contest and how well they did. First we need to find the maximum date for their name and then find the result on that date. We do both operations as separate queries and assign each an alias — in this case, A and B. We can then join those to query them as if they were two separate tables.

DECLARE @EatingContests TABLE (
   id int identity(1,1),
   FirstName varchar(50),
   cDate datetime,
   Result int)

INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Bill','3/2/2010','4')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Bill','5/18/2010','3')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Bill','12/19/2010','1')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Lisa','3/2/2010','6')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Lisa','12/7/2009','1')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Lisa','1/6/2010','2')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Lou','3/2/2010','3')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Lou','4/4/2010','5')
INSERT INTO @EatingContests (FirstName, cDate, Result) VALUES ('Lou','9/16/2009','1')

SELECT A.FirstName, A.MaxDate, B.Result
FROM
   (SELECT FirstName, Max(cDate) AS 'MaxDate'
   FROM @EatingContests
   GROUP BY FirstName)
   AS A
LEFT JOIN
   (SELECT FirstName, cDate, Result
   FROM @EatingContests)
   AS B
ON A.FirstName = B.FirstName AND A.MaxDate = B.cDate

4. Rank query results.
SQL Server has a very handy RANK function that will return the rank of a value we specify in the query.
Here we have a table of names and salaries. We use RANK to order the names by salary and provide the rank. Note that RANK shows that two people tied for 2nd and then ranks the next person 4th.

DECLARE @tmp TABLE (
   id int identity(1,1),
   FirstName varchar(50),
   Salary int)

INSERT INTO @tmp (FirstName, Salary) VALUES ('Robert','25000')
INSERT INTO @tmp (FirstName, Salary) VALUES ('Jan','36000')
INSERT INTO @tmp (FirstName, Salary) VALUES ('Mike','48000')
INSERT INTO @tmp (FirstName, Salary) VALUES ('Sarah','51000')
INSERT INTO @tmp (FirstName, Salary) VALUES ('Lisa','48000')
INSERT INTO @tmp (FirstName, Salary) VALUES ('Steve','22000')

SELECT FirstName, Salary, RANK() OVER (ORDER BY Salary DESC) AS 'Rank'
FROM @tmp

5. Concatenate row values into one field
The table created with the script below has names and test scores. For some applications, it’s handy to present these values in a list, such as “82, 93, 74″.

MySQL’s GROUP_CONCAT function does this easily, but there’s no similar option in SQL Server. It can be done, though, and this syntax (which I stumbled upon after an eternity of Googling), makes use of both the STUFF function and the FOR XML PATH output option. STUFF inserts text inside another piece of text.

CREATE TABLE #tmp (
   id int identity(1,1),
   FirstName varchar(50),
   Score varchar(10))

INSERT INTO #tmp (FirstName, Score) VALUES ('Dana','82');
INSERT INTO #tmp (FirstName, Score) VALUES ('Dana','93');
INSERT INTO #tmp (FirstName, Score) VALUES ('Dana','74');
INSERT INTO #tmp (FirstName, Score) VALUES ('Tammy','92');
INSERT INTO #tmp (FirstName, Score) VALUES ('Tammy','98');

SELECT
FirstName,
   STUFF((
      SELECT ', ' + t.Score
      FROM #tmp t
      WHERE t.FirstName = #tmp.FirstName
      ORDER BY t.Score DESC
      FOR XML PATH('')
   ),1,1,'') as Scores
FROM #tmp
GROUP BY FirstName

DROP TABLE #tmp

So, I’d like to return the favor. Anyone who’d like my WordPress theme can have it. I have no illusions about being a designer, but if you’re looking to craft your own theme it’s a good start.

Download Portfolio_AD here.

Everything worked, but it had no style.

Of course, the reason I set out to build a theme from scratch was to make something unique. I’ve been impressed, for example, at what the author of FlowingData has achieved using WordPress. And I like a good challenge.

So, I’ve spent the last few days digging into my CSS. I’ve used style sheets at work for internal projects I code in Visual Studio, so I have a head start. A reference CSS tutorial is handy for defining various elements, but I probably am learning the most by studying (and borrowing from) a couple of themes I’ve admired: Hemingway and Monochrome Lite.

If you know the Hemingway theme well, you’ll recognize shades of it in my  current header, which closely resembles the Hemingway header. I added a horizontal navigation bar that separates the top from the content to come. I’ve yet to style the content well, but I did decide to create left, middle and right divs for blocks of content. More to come — and I definitely will have to ask for help with colors. It’s what I know the least about.

What you see now (or, what you would have seen if you were here now), is the result of studiously following this detailed tutorial. I’m glad I slogged through it, because it largely demystified WordPress. The process gave me the same feeling I had when, as a geeky 12-year-old, I took apart my family’s lawnmower engine. Seeing the parts moving on the inside really helps.