Find sum of max values in a single SELECT query - sql

Question

I have prepared an SQL Fiddle for my question.
In a word game I run a custom function to find all words played by a user in her last turn:
Invalid words have a score of NULL (could be changed to -1 if needed).
Valid words have positive score and if there are several matching words, then I only need the highest score (and discard the other score).
For example, if a player plays horizontal word "ab" with score 8 and vertical word "ab" with score 2, then she only gets 8 points for that turn.
Here is my test table:
CREATE TABLE words(word varchar, score integer);
And here I fill it with test data:
INSERT INTO words (word, score) VALUES
('ab', 8), -- word with higher score should be taken
('ab', 2), -- same word with lower score should be discarded
('xy', 2),
('zz', NULL); -- invalid word marked by NULL (or -1)
I can see if an invalid word has been played by
IF EXISTS (SELECT 1 FROM words WHERE score IS NULL) THEN
RAISE EXCEPTION 'Invalid word played';
END IF;
And I can remove duplicate words with GROUP BY:
SELECT word, max(score) as score FROM words GROUP BY word;
My question is however:
How to combine both statements above to a single SELECT statement, so that I:
Know if an invalid word has been played
The sum of played scores (so that I can update the player's score)
I am looking for a single statement, so that the custom function is not run several times and preferably without a temporary table.
The result should look like (I am going to call it from another custom PL/pgSQL function):
DECLARE
total_user_score integer;
invalid_words_found boolean;
SELECT
....., -- how to calculate this value please?
..... -- how to calculate this value please?
INTO STRICT
total_user_score,
invalid_words_found
FROM words_check_words(....); -- avoid calling this function twice
IF invalid_words_found THEN
RAISE EXCEPTION "Invalid words found";
ELSE
UPDATE games SET user_score = user_score + total_user_score;
END IF;

Answer 1

(edited to return a boolean for invalid_words_found)
(edited to use bool_or aggregate function)
If I understood correctly:
with cte as (
select max(score) as score,
bool_or(score is null) as has_invalid
from words_check_words(....)
group by word
)
select coalesce(sum(score), 0) as total_user_score,
bool_or(has_invalid) as invalid_words_found
from cte
Your custom function would only get called once.
EDIT: Integrating into your procedure, it would look something like this:
DECLARE
total_user_score integer;
invalid_words_found boolean;
with cte as (
select max(score) as score,
bool_or(score is null) as has_invalid
from words_check_words(....)
group by word
)
select coalesce(sum(score), 0),
bool_or(has_invalid)
INTO STRICT
total_user_score,
invalid_words_found
FROM cte;
IF invalid_words_found THEN
RAISE EXCEPTION "Invalid words found";
ELSE
UPDATE games SET user_score = user_score + total_user_score;
END IF;

Answer 2

You could do it like this:
select coalesce(sum(max_score), 0) as total_user_score,
count(*) - count(max_score) as invalid_words_found
from (select max(score) as max_score
from words
group by word) x
See: Sql Fiddle
This assumes that if a word is invalid, it cannot also occur (in another record) with a non-null score.
The IF statement would need to look as follows:
IF invalid_words_found > 0 THEN
... and you could display the number of invalid words in the error message:
RAISE EXCEPTION '% Invalid words found!', invalid_words_found;

Answer 3

select
word,
max(
case
when score is null then raise_error('Invalid word: ' || word)::int
else score
end)
from words
group by word;
where the raise_error function declared like
create function raise_error(text) returns text language plpgsql volatile as
$body$
begin
raise exception '%', $1;
end $body$;
To make the query more elegant there is another common-purpose function could be created:
create function assert(
p_cond boolean,
p_message text,
p_result anyelement) returns anyelement language plpgsql volatile as
$body$
begin
if p_cond then
return p_result;
else
raise exception '%', p_message;
end if;
end $body$;
And the query becomes more compact:
select
word,
max(assert(score is not null, 'Invalid word: ' || word, score))
from words
group by word;