Robust metod för att skapa SQL-frågor programmatiskt

Bättre fråga

Till att börja med kan du fixa syntaxen, förenkla och förtydliga en hel del:

SELECT *
FROM  (
   SELECT p.person_id, p.name, p.team, sum(s.score)::int AS score
         ,rank() OVER (PARTITION BY p.team
                       ORDER BY sum(s.score) DESC)::int AS rnk
    FROM  person p
    JOIN  score  s USING (person_id)
    GROUP BY 1
   ) sub
WHERE  rnk < 3;

Bygger vidare på min uppdaterade bordslayout. Se fiol nedan.
Du behöver inte den extra underfrågan. Fönsterfunktioner exekveras efter samla funktioner, så att du kan kapsla den som visat.
Medan du pratar om "rank", vill du förmodligen använda rank() , inte row_number() .
Förutsatt people.people_id är PK, kan du förenkla GROUP BY .
Se till att tabellkvalificera alla kolumnnamn som kan vara tvetydiga

PL/pgSQL-funktion

Sedan skulle jag skriva en plpgsql-funktion som tar parametrar för dina variabla delar. Implementera a - c av dina poäng. d är oklart, så du kan lägga till det.

CREATE OR REPLACE FUNCTION f_demo(_agg text       DEFAULT 'sum'
                               , _left_join bool  DEFAULT FALSE
                               , _where_name text DEFAULT NULL)
  RETURNS TABLE(person_id int, name text, team text, score int, rnk int) AS
$func$
DECLARE
   _agg_op  CONSTANT text[] := '{count, sum, avg}';  -- allowed functions
   _sql     text;
BEGIN

-- assert --
IF _agg ILIKE ANY (_agg_op) THEN
   -- all good
ELSE
   RAISE EXCEPTION '_agg must be one of %', _agg_op;
END IF;

-- query --
_sql := format('
SELECT *
FROM  (
   SELECT p.person_id, p.name, p.team, %1$s(s.score)::int AS score
         ,rank() OVER (PARTITION BY p.team
                       ORDER BY %1$s(s.score) DESC)::int AS rnk
    FROM  person p
    %2$s  score  s USING (person_id)
    %3$s
    GROUP BY 1
   ) sub
WHERE  rnk < 3
ORDER  BY team, rnk'
   , _agg
   , CASE WHEN _left_join THEN 'LEFT JOIN' ELSE 'JOIN' END
   , CASE WHEN _where_name <> '' THEN 'WHERE p.name LIKE $1' ELSE '' END
);

-- debug   -- quote when tested ok
-- RAISE NOTICE '%', _sql;

-- execute -- unquote when tested ok
RETURN QUERY EXECUTE _sql
USING  _where_name;   -- $1

END
$func$  LANGUAGE plpgsql;

Ring:

SELECT * FROM f_demo();
SELECT * FROM f_demo('sum', TRUE, '%2');    
SELECT * FROM f_demo('avg', FALSE);
SELECT * FROM f_demo(_where_name := '%1_'); -- named param

SQL Fiddle

Du behöver en gedigen förståelse för PL/pgSQL. Annars finns det för mycket att förklara. Du hittar relaterade svar här på SO under plpgsql för praktiskt taget varje detalj i svaret.
Alla parametrar behandlas säkert, ingen SQL-injektion möjlig. Mer:
- Definiera tabell- och kolumnnamn som argument i en plpgsql-funktion?
- Tabellnamn som en PostgreSQL funktionsparameter
Notera särskilt hur en WHERE sats läggs till villkorligt (när _where_name skickas) med positionsparametern $1 i frågan sting. Värdet skickas till EXECUTE som värde med USING klausul . Ingen typkonvertering, ingen flykt, ingen chans till SQL-injektion. Exempel:
Använd DEFAULT värden för funktionsparametrar, så du är fri att ange några eller inga. Mer:
- Funktioner med variabelnummer av ingångsparametrar
- Handboken om anropsfunktioner
Funktionen format() är avgörande för att bygga komplexa dynamiska SQL-strängar på ett säkert och rent sätt.