Hej!

Har 2 tabeller som enkelt uttryckt ser ut så här:

Tabell1
--------
Id *
Butik

Tabell2
---------
Id *
Value (Decimal, Innehåller både positvia & negativa tal)

Jag vill summera Value grupperat per butik, men jag vill ha en positv och en negativ summa.
Alltså Positiva summan=Summan av alla positiva Value
Negativa summan = Summan av alla negativa value

Så här ser min sql ut nu för att få ut negativa summan:
select Butik, Sum(Value) Summa from Tabell2
inner join Tabell1 on Tabell1.Id=Tabell2.Id
where Value < 0
group by Butik
order by Butik

... och så positva summan:
select Butik, Sum(Value) Summa from Tabell2
inner join Tabell1 on Tabell1.Id=Tabell2.Id
where Value > 0
group by Butik
order by Butik

Svaret blir ju typ för den sistnämda frågan:
Butik | Summa
1 | 92019
2 | 8989
3 | 9009909

Skulle vilja slå ihop dessa frågor o få svar typ så här:

Butik | Postiv | Summa
1 | 1 | 92019
1 | 0 | -834894
2 | 1 | 8989
2 | 0 | -79938


Är detta möjligt?

Vänliga Hälsningar
/ Stefan

ngt i stil med
(SELECT ..., 0 as Type WHERE value < 0) UNION (SELECT ..., 1 as Type WHERE value > 0)

SELECT TOP (100) PERCENT dbo.Table_1.Butik, SUM(dbo.Table_2.Value) AS Summa
FROM dbo.Table_1 INNER JOIN
dbo.Table_2 ON dbo.Table_1.Id = dbo.Table_2.Id
GROUP BY dbo.Table_1.Butik, SIGN(dbo.Table_2.Value)
HAVING (SIGN(dbo.Table_2.Value) <> 0)
ORDER BY dbo.Table_1.Butik


Raden "HAVING (SIGN(dbo.Table_2.Value) <> 0)" har jag med för att inte få med 0-värden som en grupp.


[Edit]

Här är ett annat sätt för att få ut samma uppgifter fast med PIVOT funktion

SELECT pvt.[Butik], pvt.[-1], pvt.[1]
FROM (SELECT t1.[Butik], t2.[Value], SIGN(t2.[Value]) AS [Tecken]
FROM [dbo].[Table_1] t1 INNER JOIN
[dbo].[Table_2] t2 ON t1.[Id] = t2.[Id]) AS t2 PIVOT (SUM([Value]) FOR [Tecken] IN ([-1], [1])) AS pvt;

Har inte testat, men det skulle kunna fungera såhär, men är långt ifrån säker :)

select Butik, Value < 0 AS Negativ, Sum(Value) Summa from Tabell2
inner join Tabell1 on Tabell1.Id=Tabell2.Id
where Value < 0
group by Butik, Value < 0
order by Butik

/Johan

Tack för svaren.
Har testat lite nu och fått det att fungera. Vilken av era frågor anser ni vara snabbast. Tabellerna innehåller väldigt många rader = > 1000000.

Det är väl bara att testa. Spontant tror jag faktiskt en del på min; borde gå på O(N) (N för att hitta första, N för att hitta andra, N för att slå ihop), ngt i stil med O(3N)?

Kör man en join borde det väl gå på O(N^2) (N per varje rad)?
Fast det är klart, databaser är ju rätt hårt optimerade...

Edit: O(NlogN) enligt http://www.partow.net/programming/databasealgos/index.html

I access kan man skriva:

SELECT Table1.Butik, -Sum(Table2.Value * (Table2.Value>0)) AS Posetive, -Sum(Table2.Value  * (Table2.Value<0)) AS Negative
FROM Table1 INNER JOIN Table2 ON Table1.Id = Table2.Id
GROUP BY Table1.Butik;

Tack för svaret Niklas.
Jag måste väl ändå köra en join eftersom jag ska ha Butik från tabell1, eller hur tänkte du?

Jo, jo, men det är ju något man lägger på i efterhand. Påverkar inte argumentet.

Hmm förstår inte riktigt hur du menar. Såhär skriver jag nu enligt ditt "union" förslag. Är det så du menar?

SELECT Table_1.Butik, 0 as Type, SUM(Table_2.Value) AS Summa,
FROM Table_1 INNER JOIN
Table_2 ON Table_1.Id = Table_2.Id
WHERE Table_2.Value < 0
GROUP BY dbo.Table_1.Butik, Type
UNION
SELECT Table_1.Butik, 1 as Type, SUM(Table_2.Value) AS Summa,
FROM Table_1 INNER JOIN
Table_2 ON Table_1.Id = Table_2.Id
WHERE Table_2.Value > 0
GROUP BY dbo.Table_1.Butik, Type
ORDER BY dbo.Table_1.Butik

Hej!

Om du inte måste ha två rader per butik är följande ett annat sätt att lösa det på.
(endast en rad per butik):

Butik | Positiv summa | Negativ summa
1 | 92019 | -834894
2 | 8989 | -79938

SELECT a.Butik,
"Positiv summa"  = SUM(CASE WHEN b.value > 0 THEN b.value ELSE 0 END),
"Negativ summa" = SUM(CASE WHEN b.value < 0 THEN b.value ELSE 0 END)
FROM Tabell1 a
INNER JOIN Tabell1 b ON a.Id = b.Id
GROUP BY b.Butik

Stefan: Jag antog att du menade prestandan. Jag menar att joinen inte påverkar prestandan.

I princip är det du ska göra något i stil med

(SELECT ... UNION SELECT ...) JOIN SELECT ...

Alltså, slå ihop deltabellerna först, sen kan du joina dem med vad du vill.
Försök att få bara den satsen att funka först.

Håkan: Är CASE del av SQL-standarden?
Det tycker jag alltid är en viktig del av frågeställningen. Är prestandavinsten så stor att den öveväger nyttan med att kunna använda koden med en annan databas?

EDIT: Det var inget, vid närmare eftertanke är det väl faktiskt så att den är del av standarden. I så fall en mycket trevlig variant.

Niklas: Eftersom du ändå frågade (och svarade själv), ja det är det.

//Håkan

Om du använder SQL server varför inte göra vyer? Det borde ge en effektiv fråga?

Vy för positiva tal:

CREATE VIEW viewPositivTabell AS
SELECT Table_2.Id, 1 as Type, SUM(Table_2.Value) AS PositivSumma
FROM Table_2
WHERE Table_2.Value > 0
GROUP BY Table_2.Id

CREATE VIEW viewNegativTabell AS
SELECT Table_2.Id, 0 as Type, SUM(Table_2.Value) AS NegativSumma
FROM Table_2
WHERE Table_2.Value < 0
GROUP BY Table_2.Id

SELECT     Table_1.Butik, PositivSumma, NegativSumma
FROM         Table_1 LEFT JOIN
    viewPositivTabell ON Table_1.Id = viewPositivTabell.Id  LEFT JOIN
    viewNegativTabell ON Table_1.Id = viewNegativTabell.Id

SELECT     Table_1.Butik, PositivSumma, NegativSumma
FROM         Table_1 LEFT JOIN
    (SELECT Table_2.Id, SUM(Table_2.Value) AS PositivSumma
        FROM Table_2
        WHERE Table_2.Value > 0
        GROUP BY Table_2.Id) AS PositivTabell ON Table_1.Id = PositivTabell.Id  LEFT JOIN
    (SELECT Table_2.Id, SUM(Table_2.Value) AS NegativSumma
        FROM Table_2
        WHERE Table_2.Value < 0
        GROUP BY Table_2.Id) AS NegativTabell ON Table_1.Id = PositivTabell.Id

Jävla märkligt att jag aldrig använder den... Finns ju massa puckade konstruktioner i applikationer jag har skrivit med massa efterbehandling av data, när man kan lösa det så pass enkelt...