汇总SQL

Question

I have a pretty simple SQL requirement but wanting to know what is 'best practice' for the below scenario as I am running into a performance issue.

I have a list of teams, each week/round these teams pay a game fee. If a team doesn't pay then then they will have an outstanding balance. All team payments go into a payments table which is getting bigger and bigger. What is the best practice to return a list of teams with their current balance?

What I have at the moment:

Select teams.*, (Select SUM(amount) from payments p where p.TeamID=teams.TeamID) as teambalance 
from (select TeamID, TeamName from Teams) teams

Answer 1

I have thought about this a lot and think that the classical advice of "don't store the same information twice" is mistaken here, or at least misinterpreted.

Think about how banks must do it. Obviously, when you want to know your current balance and you've been a customer for 20 years, they don't add up 20 years of account activity to find your current balance. In light of that, I see two ways to handle it:

1. Choose periods to "close" and always calculate from the last closed period. This keeps the summing relatively short. The monthly statement is probably a good such anchor. Do you have a similar natural time period or business life cycle to track with?
2. Work backwards, by anchoring your account history in the present . Instead of starting at 0 and adding, start at current balance and go back. This is just as valid, in my opinion, and has the added benefit that you don't have to do a thing when you want to trim old history. Store the current balance, and forget the supposed denormalization. The current balance is as true an empirical fact as the starting balance, and there is no harm in anchoring your accounts this way.

You can continue to add if you like, so long as performance is okay. But it may not be optimal.

Your current query is fine, but there is no need for the teams derived table. Unless you're using MySQL, the DBMS doesn't need this kind of "help"--though MySQL could actually be harmed by it.

Answer 2

select teamId,teamName,sum(amount)
from teams t join payments p on t.teamId = p.teamId
group by t.teamId, t.teamName

Answer 3

I have used two methods to accomplish this task - one being the method that you are currently using. The other is using cross apply.

I prefer your current method -

Answer 4

This may be faster than using a subquery in the SELECT clause (or a join):

select teams.TeamID, teams.teamName, team_balances.teambalance
  from teams
  join ( select TeamID, sum(amount) teambalance
           from payments
         group by TeamID
  ) team_balances
  on team_balances.TeamID = teams.TeamID;

This will sequentially scan the payments table once, rather than doing N index scans (one per team).

denormalizing

Another option is to create add a "outstanding_balance" column to the teams table.

Create a trigger on the payments table. In the trigger, increment or decrement the outstanding_balance column in teams based on the TeamID and the invoice/payment amount, respectively.

Depending on your RDBMS you could also use a materialized view. This is similar to the trigger method, except the balance for each team would be stored in a different table.