# Summarizing Data in SQL

#### by Matt DeLand |

**About Matt:** Matt DeLand is Co-Founder and Data Scientist at Wagon.
His team is building a collaborative SQL editor for analysts and engineers. He studied algebraic geometry at Columbia University,
taught at the University of Michigan, and now enjoys applied machine learning— his mom is very proud!

### Introduction

How quickly can you understand data from your database? Excel croaks at ten thousands rows, R is difficult to run on a cluster, and your eye certainly can’t summarize large tables. SQL to the rescue!

Summary statistics are the fastest way to learning about your dataset. Are there outliers? How does the distribution look?
What are the relationships hiding inside the rows and columns? You’ll always want to ask these questions when faced with a new dataset.
SQL (an uninspired acronym for *Structured Query Language*) is the native language for database computation. Many summary methods are
available as built in SQL functions in modern databases and more complex measures can be implemented directly in SQL as well.

In this post, we’ll walk through 4 ways to summarize your dataset in SQL so you can run it directly on your database.

### A summary of summaries

- The Basics
- Percentiles
- Histogram
- Joint Distributions

Here’s a relatable example: suppose we work in a banana stand’s back office and we analyze banana data.

### The Basics

With just a few SQL commands, we’ll be able to calculate the basics: `count`

, `distinct`

, `sum`

, `average`

, `variance`

, ... If we have a table of banana transactions, let’s calculate the total number of customers, unique customers, number of bananas sold, as well as total and average revenue per day:

This should be a familiar SQL pattern (and if not, come to the next free Wagon SQL class!). With just one query, we can calculate important aggregations over very large datasets. If we dress it up with a few `where`

statements or `join`

with customer lookup tables, we can quickly and effectively slice and dice our data. Unfortunately, there are some tricky questions that can’t be answered with the regular SQL functions alone.

### Computing Percentiles

How long do people wait for their tasty banana orders? Using basic SQL we can compute average wait time, but if the distribution is skewed away from normal (as many internet-driven (and banana?) distributions often are), this may not give us a complete picture of how long most people are waiting. In addition to computing the average, we might (and should) ask, what are the 25th, 50th, 75th percentiles of wait-time, and how does that number vary day to day?

Many databases (including Postgres 9.4, Redshift, SQL Server) have built in percentile functions. Here's an example using the function `percentile_cont`

which is a window function that computes the percentile of wait-time, split (pun intended!) by day:

The structure of the `percentile_cont`

is similar to other window functions: we specify how to order the data, how to group it - and the database does the rest. If we wanted to add more dimensions to our query (e.g. time of day), we’d add them to the `partition`

and `group by`

clause.
If our database doesn't support `percentile_cont`

(sorry MySQL, Postgres < 9.4), the query is more complicated, but fear not, still possible! The challenge is to order the rows by increasing wait-time (per date of course) and then pick out the middle value (for median). In MySQL, we can use local variables to keep track of the order, and in Postgres, we can use the row-number function. Here's the Postgres version:

### Histograms

It's often useful to have a rough idea of the distribution of the data in a table or query result. Generating a histogram is a great way to understand that distribution. What’s the distribution of revenue per purchase at the banana stand? I mean, how much could a banana cost? We might (naively) write a query like:

It's likely this query will return far too many rows to eyeball the revenue distribution (1 row per distinct price). Instead, we'd like to group revenue values together into buckets so that we can understand the shape of the data. We might be interested in the number of banana purchases which generated between \$0 to \$5, \$5 to \$10, etc. There's no "correct" number of buckets to use, it's a choice we can make and experiment with to get a better understanding of the distribution. Probably 1000 buckets is too many, but 2 is too few. A reasonable rule of thumb is to use somewhere around 20 buckets. Our query will specify the width of the bucket, rather than the total number. The larger the width, the fewer buckets we'll end up with.

This is a simple, but tricky query that will generate a histogram for us. It rounds each revenue data point down to the nearest multiple of 5 and then groups by that rounded value. It has one failing in that if we have no data in a bucket (e.g. no purchases of 55 to 60 dollars), then that row will not appear in the results. We can fix that with a more complex query, but let’s skip it for now. In order to choose our bucket size, it helps to first calculate the min/max values so we know how many buckets we would end up with. If we want the buckets to have slightly nicer labels, we can format the labels with a query like:

### Joint Distributions

Comparing two numerical measures is very important as we try to summarize our data. Though the math becomes more complicated, SQL can still handle it. For example, we might be nervous that if people have to wait too long, they end up spending less money when they get to the front of the line. To get a rough idea of the relationship between wait-time and revenue, we might write a query very similar to the histogram one:

These queries give us some insight into the join distribution (plug: Wagon makes charts like these super easy to generate). We might also be interested in more statistical measurements like covariance or correlation. Most of the popular SQL implementations have these statistics built in, so for example in Postgres/Redshift we can write:

Postgres has all kinds of cool aggregate functions, including linear regressions - right in our SQL query!

### Wagon

At Wagon, we're very interested in how people write queries, understand their results, and share them with their team. Our SQL tool computes statistics on all your query results (including histograms!) to help you understand your result-set without having to do additional work. If you're interested, we'd love to hear from you, give us a shout! And remember, there’s always `sum_money`

in the `banana_stand`

.