[SQLite] Valore colonne non-aggregate in query con group-by

[MItaly]

Ciao a tutti,

ho una query di questo genere:

SELECT IdGiocatore, COUNT(IdGiocatore) AS "Presenze", Nome, Ruolo, Squadra, SUM(GoalFatti) As "TotGoalFatti", SUM(Autogoal) As "TotAutogoal", SUM(Ammonizioni) As "TotAmmonizioni", SUM(Espulsioni) As "TotEspulsioni", SUM(GoalSubiti) AS "TotGoalSubiti", SUM(RigoriParati) AS "TotRigoriParati",
(SUM(GoalSubiti) + SUM(Ammonizioni)  + 3*SUM(Espulsioni) - 2*SUM(GoalFatti) + 3*SUM(Autogoal) - 2*SUM(RigoriParati)) AS Punteggio
FROM raw_ordered
GROUP BY IdGiocatore
ORDER BY Punteggio DESC

dove in raw_ordered ogni riga corrisponde alla prestazione di un certo giocatore in una certa giornata di campionato.

Ora, le colonne relative alle funzioni-aggregate sono a posto; il problema sta nelle altre, in particolare nella colonna Squadra. Quello che vorrei ottenere per ogni giocatore (=ogni riga, dato che la group-by è su IdGiocatore) è il nome dell'ultima squadra in cui questo ha giocato (che coincide con il valore di Squadra nella prima riga relativa al giocatore in raw_ordered, che è appunto ordinato per giornata in ordine discendente).
Guardando nella documentazione di SQLite non ho trovato nulla di particolare aiuto: non mi pare ci siano funzioni aggregate che forniscano il primo valore incontrato per una certa colonna, e l'ordinamento dei dati originali non influisce, dato che, in una query con group-by,

If the expression is an aggregate expression, it is evaluated across all rows in the group. Otherwise, it is evaluated against a single arbitrarily chosen row from within the group.

(link)

Qualche idea?

[Holidaysoft.it]

Ciao,
non ho avuto modo di testarlo, ma dovrebbe funzionare. L'idea è di estrarre l'ultima squadra con una query a parte e poi unire il risultato con la tua query:

SELECT X.IdGiocatore, COUNT(X.IdGiocatore) AS "Presenze", X.Nome, X.Ruolo, Z.Squadra,
SUM(X.GoalFatti) As "TotGoalFatti", SUM(X.Autogoal) As "TotAutogoal", SUM(X.Ammonizioni) As "TotAmmonizioni",
SUM(X.Espulsioni) As "TotEspulsioni", SUM(X.GoalSubiti) AS "TotGoalSubiti", SUM(X.RigoriParati) AS "TotRigoriParati",
(SUM(X.GoalSubiti) + SUM(X.Ammonizioni) + 3*SUM(X.Espulsioni) - 2*SUM(X.GoalFatti) + 3*SUM(X.Autogoal) - 2*SUM(X.RigoriParati)) AS Punteggio
FROM raw_ordered X,
(
SELECT A.IdGiocatore, B.SQUADRA FROM
(SELECT IdGiocatore, MAX(Punteggio) MAX_PUNTEGGIO FROM raw_ordered) A,
(SELECT IdGiocatore, Punteggio, SQUADRA FROM raw_ordered) B
WHERE A.IDGIOCATORE=B.ID_GIOCATORE AND A.MAX_PUNTEGGIO=B.PUNTEGGIO
) Z
WHERE X.IDGIOCATORE=Z.IdGiocatore
GROUP BY X.IdGiocatore
ORDER BY X.Punteggio DESC


Prova e fammi sapere
Ciao
Mik

[MItaly]

Grazie mille per la risposta; credo che funzioni, ma sia piuttosto lento come un'altra soluzione che avevo provato basata su subquery.

Alla fine ho risolto in un'altra maniera: anche se la documentazione non sembra aggiornata, da SQLite 3.7.1 avere una colonna con un MAX o MIN fa sì che i dati delle colonne "non-funzioni-aggregate" vengano dalla riga a cui corrisponde il MAX (all'interno del gruppo).

La query finale quindi è:

SELECT IdGiocatore, COUNT(IdGiocatore) AS "Presenze", Nome, Ruolo, 
Squadra,
SUM(GoalFatti) As "TotGoalFatti", SUM(Autogoal) As "TotAutogoal", SUM(Ammonizioni) As "TotAmmonizioni", SUM(Espulsioni) As "TotEspulsioni", SUM(GoalSubiti) AS "TotGoalSubiti", SUM(RigoriParati) AS "TotRigoriParati",
(SUM(GoalSubiti) + SUM(Ammonizioni)  + 3*SUM(Espulsioni) - 2*SUM(GoalFatti) + 3*SUM(Autogoal) - 2*SUM(RigoriParati)) AS Punteggio,
MAX(giornata) AS "UltimaGiornata"
FROM raw_ordered
GROUP BY IdGiocatore
ORDER BY Punteggio DESC