EXERCISE TOPIC▼
SQL EXERCISES▼
SQL EXERCISES▼
- Simple Queries (4)
- Setting criteria using WHERE (5)
- Calculations (7)
- Calculations using dates (4)
- Basic joins (8)
- More exotic joins (2)
- Aggregation and grouping (8)
- Views (5)
- Subqueries (5)
- Stored procedures (5)
- Variables (8)
- Parameters and return values (11)
- Testing conditions (1)
- Looping (3)
- Scalar functions (6)
- Transactions (5)
- Creating tables (5)
- Temporary tables and table variables (9)
- Table-valued functions (6)
- Derived tables and CTEs (13)
- Dynamic SQL (4)
- Pivots (2)
- Triggers (2)
- Archived (70)
SQL | Aggregation and grouping exercise | Show the total number of events for each century
This exercise is provided to allow potential course delegates to choose the correct Wise Owl Microsoft training course, and may not be reproduced in whole or in part in any format without the prior written consent of Wise Owl.
You can learn how to do this exercise if you attend one of more of the courses listed below!
Software ==> | SQL (198 exercises) |
Version ==> | Any version of SQL Server |
Topic ==> | Aggregation and grouping (8 exercises) |
Level ==> | Harder than average |
Courses ==> | Introduction to SQL / Fast-track SQL |
- Go into SQL Server Management Studio;
- Open the SQL file you've just unzipped (you can press CTRL + O to do this); then
- Execute this script.
This will generate the database that you'll need to use in order to do this exercise (note that the database and script are only to be used for exercises published on this website, and may not be reused or distributed in any form without the prior written permission of Wise Owl).
You need a minimum screen resolution of about 700 pixels width to see our exercises. This is because they contain diagrams and tables which would not be viewable easily on a mobile phone or small laptop. Please use a larger tablet, notebook or desktop computer, or change your screen resolution settings.
Create a query to show the following information:

You'll need to calculate the century for each event date, and group by this.
To get the top row giving the grand total in the same query, encase your GROUP BY expression in the CUBE function.
Save this query as Passing of the centuries, then close it down.
I am getting different result..
NULL 459
18th Century 4
19th Century 14
20th Century 396
21st Century 45
for both rollup and cube.. is this right? Final total same as site.
This will give you exact same result as posted on site
USE WorldEvents
GO
SELECT
CASE
WHEN DATEPART(YY,tblEvent.EventDate) like '18%' THEN '19th Century'
WHEN DATEPART(YY,tblEvent.EventDate) like '17%' THEN '18th Century'
WHEN DATEPART(YY,tblEvent.EventDate) like '19%' THEN '20th Century'
WHEN DATEPART(YY,tblEvent.EventDate) like '20%' THEN '21st Century'
END AS Century,COUNT(tblEvent.EventName) AS NumberOfEvents
FROM tblEvent
GROUP BY CUBE(CASE
WHEN DATEPART(YY,tblEvent.EventDate) like '18%' THEN '19th Century'
WHEN DATEPART(YY,tblEvent.EventDate) like '17%' THEN '18th Century'
WHEN DATEPART(YY,tblEvent.EventDate) like '19%' THEN '20th Century'
WHEN DATEPART(YY,tblEvent.EventDate) like '20%' THEN '21st Century'
END)
ORDER BY NumberOfEvents DESC
This is way too specific. What will happen once more event are updated to the database? And there might be events from before the 18th century.
I believe we should write a code that can be used over more data.
How about this:
SELECT
(CAST(((YEAR(EventDate)/100)+1) AS varchar) + 'th century') AS 'Century',
COUNT(CAST(((YEAR(EventDate)/100)+1) AS varchar) + 'th century') AS 'Number of events'
FROM
[tblEvent]
GROUP BY
(CAST(((YEAR(EventDate)/100)+1) AS varchar) + 'th century')
WITH CUBE
Hi, I would like to offer these observations by using the code below:
use worldevents
go
SELECT CASE LEFT(CONVERT(VARCHAR(10), eventdate, 121), 2) WHEN '20' THEN '21st century'
WHEN '19' THEN '20th century'
WHEN '18' THEN '19th century'
WHEN '17' THEN '18th century' end as Century,
COUNT(eventid) AS [Number of Events]
FROM tblevent
GROUP BY CUBE (CASE LEFT(CONVERT(VARCHAR(10), eventdate, 121), 2) WHEN '20' THEN '21st century'
WHEN '19' THEN '20th century'
WHEN '18' THEN '19th century'
WHEN '17' THEN '18th century' end)
ORDER BY Century
Using a simple CASE construct, makes the code easier to read. Grouping on the eventid (primary key) ensures an accurate count. Grouping on the eventname (nullable) doesn't ensure you will get an accurate count. Also, using an explicit conversion avoids the sql engine from having to do an implicit conversion from date to string so that the LIKE statement can be used. Also, LIKE and wildcards are usually a drag on performance but in this case with only a few rows, the hit is not noticeable. In the actual performance plan, the buffer size using this code is 1/4 the size of the code using LIKE. Going up against a lot of data could produce a memory hit.
Impressive analysis - thanks!