Database
 sql >> Datenbank >  >> RDS >> Database

SQL SUM() für Anfänger

In SQL die SUM() Funktion ist eine Aggregatfunktion, die die Summe aller Werte in einem bestimmten Ausdruck zurückgibt.

Es kann auch verwendet werden, um die Summe aller unterschiedlichen (eindeutigen) Werte in einem Ausdruck zurückzugeben.

Der Ausdruck muss numerisch sein (er darf keine Zeichenkette, Bitkette oder Datumszeit sein).

Nachfolgend finden Sie einige grundlegende Beispiele, um zu demonstrieren, wie es funktioniert.

Beispieltabelle

Angenommen, wir haben die folgende Tabelle:

SELECT * FROM Products;

Ergebnis:

+-------------+------------+---------------------------------+----------------+-----------------------------------------+
| ProductId   | VendorId   | ProductName                     | ProductPrice   | ProductDescription                      |
|-------------+------------+---------------------------------+----------------+-----------------------------------------|
| 1           | 1001       | Left handed screwdriver         | 25.99          | Purple. Includes left handed carry box. |
| 2           | 1001       | Long Weight (blue)              | 14.75          | Includes a long wait.                   |
| 3           | 1001       | Long Weight (green)             | 11.99          | Approximate 30 minute waiting period.   |
| 4           | 1002       | Sledge Hammer                   | 33.49          | Wooden handle. Free wine glasses.       |
| 5           | 1003       | Chainsaw                        | 245.00         | Orange. Includes spare fingers.         |
| 6           | 1003       | Straw Dog Box                   | NULL           | Tied with vines. Very chewable.         |
| 7           | 1004       | Bottomless Coffee Mugs (4 Pack) | 9.99           | Brown ceramic with solid handle.        |
| 8           | 1001       | Right handed screwdriver        | 25.99          | Blue. Includes right handed carry box.  |
+-------------+------------+---------------------------------+----------------+-----------------------------------------+

Beispiel

Wir können die folgende Abfrage verwenden, um die Summe aller Preise zu erhalten.

SELECT SUM(ProductPrice)
FROM Products;

Ergebnis:

+--------------------+
| (No column name)   |
|--------------------|
| 367.20             |
+--------------------+

In diesem Fall werden Preisinformationen im ProductPrice gespeichert Spalte, und wir übergeben das als Argument an SUM() Funktion, die dann die Summe berechnet und das Ergebnis zurückgibt.

Spaltenaliase verwenden

Sie werden feststellen, dass die vorherigen Ergebnisse keinen Spaltennamen enthalten. Dies ist zu erwarten, da die SUM() Funktion gibt keine Spalten zurück. Sie können ganz einfach einen Spaltennamen angeben, indem Sie einen Alias ​​zuweisen.

SELECT SUM(ProductPrice) AS Sum
FROM Products;

Ergebnis:

+--------+
| Sum    |
|--------|
| 367.20 |
+--------+

Gefilterte Ergebnisse

Die SUM() Die Funktion arbeitet mit den von der Abfrage zurückgegebenen Zeilen. Wenn Sie also die Ergebnisse filtern, das Ergebnis von SUM() wird das widerspiegeln.

SELECT SUM(ProductPrice) AS Sum
FROM Products
WHERE VendorId = 1001;

Ergebnis:

+-------+
| Sum   |
|-------|
| 78.72 |
+-------+

In diesem Fall ist 78,72 die Summe aller vom angegebenen Anbieter angebotenen Produkte.

NULL Werte

Die SUM() Funktion ignoriert jeden NULL Werte. In unserer Beispieltabelle oben, Produktnummer 6 hat NULL in seinem ProductPrice Spalte, aber das wurde in unserem SUM() ignoriert Beispiel.

Abhängig von Ihrem DBMS und Ihren Einstellungen sehen Sie möglicherweise eine Warnung, dass NULL Werte wurden in der Ergebnismenge eliminiert.

Hier ist ein Beispiel dafür, was Sie sehen könnten:

SELECT SUM(ProductPrice) AS Sum
FROM Products;

Ergebnis:

+--------+
| Sum    |
|--------|
| 367.20 |
+--------+
Warning: Null value is eliminated by an aggregate or other SET operation.

All dies sagt uns, dass die Spalte mindestens einen NULL enthielt Wert, und dass er bei der Berechnung der Ergebnisse ignoriert wurde.

Datums-/Uhrzeitdaten

Die SUM() Funktion akzeptiert keine Datums-/Zeitausdrücke.

Angenommen, wir haben die folgende Tabelle:

SELECT PetName, DOB 
FROM Pets;

Ergebnis:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
| Bark      | NULL       |
| Meow      | NULL       |
+-----------+------------+

Wenn wir versuchen, SUM() zu verwenden auf dem DOB Spalte erhalten wir einen Fehler.

SELECT SUM(DOB) AS Sum
FROM Pets;

Ergebnis:

Msg 8117, Level 16, State 1, Line 1
Operand data type date is invalid for sum operator.

Charakterdaten

Die SUM() Die Funktion akzeptiert auch keine Zeichenkettenausdrücke.

Folgendes passiert, wenn wir versuchen, SUM() zu verwenden auf ProductName Spalte unserer Products Tabelle (die den Datentyp varchar verwendet):

SELECT SUM(ProductName) AS Sum
FROM Products;

Ergebnis:

Msg 8117, Level 16, State 1, Line 1
Operand data type varchar is invalid for sum operator.

Der DISTINCT Schlüsselwort

Sie können den DISTINCT verwenden Stichwort mit SUM() nur unterschiedliche Werte zu berechnen. Das heißt, wenn doppelte Werte vorhanden sind, werden sie als ein Wert behandelt.

Beispiel:

SELECT SUM(DISTINCT ProductPrice) AS DistinctSum
FROM Products;

Ergebnis:

+---------------+
| DistinctSum   |
|---------------|
| 341.21        |
+---------------+

Wir können sehen, dass dieses Ergebnis niedriger ist als das Ergebnis, das wir ohne DISTINCT erhalten haben Schlüsselwort.

Um es noch einmal zusammenzufassen:Wir haben 367,20 ohne den DISTINCT erhalten Schlüsselwort und 341.21 mit dem DISTINCT Schlüsselwort.

Dies liegt daran, dass es zwei Artikel gibt, die den gleichen Preis haben (der Schraubendreher für Linkshänder und der Schraubendreher für Rechtshänder kosten beide 25,99). Daher die SUM() Funktion, wenn sie mit DISTINCT verwendet wird Schlüsselwort, behandelt beide Werte als einen und berechnet das Ergebnis entsprechend.

Fensterfunktionen

Abhängig von Ihrem DBMS können Sie möglicherweise einen OVER verwenden -Klausel mit Ihrem SUM() Funktion zum Erstellen einer Fensterfunktion.

Eine Fensterfunktion führt eine aggregierte Operation für eine Reihe von Abfragezeilen aus. Es erzeugt ein Ergebnis für jede Abfragezeile. Dies steht im Gegensatz zu einer Aggregatoperation, die Abfragezeilen in einer einzigen Ergebniszeile gruppiert.

Hier ist ein Beispiel, um das Konzept zu demonstrieren.

Wir haben uns bereits die Products angesehen Tisch. Unsere Datenbank hat auch einen Customers Tabelle, und sie enthält die folgenden Daten:

+--------------+----------------------+-------------------+------------+-----------------+------------+-----------+----------------+
| CustomerId   | CustomerName         | PostalAddress     | City       | StateProvince   | ZipCode    | Country   | Phone          |
|--------------+----------------------+-------------------+------------+-----------------+------------+-----------+----------------+
| 1001         | Palm Pantry          | 20 Esplanade      | Townsville | QLD             | 2040       | AUS       | (308) 555-0100 |
| 1002         | Tall Poppy           | 12 Main Road      | Columbus   | OH              | 43333      | USA       | (310) 657-0134 |
| 1003         | Crazy Critters       | 10 Infinite Loops | Cairns     | QLD             | 4870       | AUS       | (418) 555-0143 |
| 1004         | Oops Media           | 4 Beachside Drive | Perth      | WA              | 1234       | AUS       | (405) 443-5987 |
| 1005         | Strange Names Inc.   | 789 George Street | Sydney     | NSW             | 2000       | AUD       | (318) 777-0177 |
| 1006         | Hi-Five Solutionists | 5 High Street     | Highlands  | HI              | 1254       | AUS       | (415) 413-5182 |
+--------------+----------------------+-------------------+------------+-----------------+------------+-----------+----------------+

Wir können Daten aus diesen Tabellen abrufen und sie mithilfe eines Joins als eine Ergebnismenge darstellen.

Wir können auch SUM() verwenden Funktion mit dem OVER -Klausel, um eine Fensterfunktion auf die Daten anzuwenden.

SELECT 
    v.VendorName,
    p.ProductName,
    p.ProductPrice,
    SUM(ProductPrice) OVER (PARTITION BY v.VendorName) AS "Sum For This Vendor"
FROM Products p 
INNER JOIN Vendors v 
ON v.VendorId = p.VendorId
ORDER BY VendorName, ProductPrice, "Sum For This Vendor";

Ergebnis:

+---------------+---------------------------------+----------------+-----------------------+
| VendorName    | ProductName                     | ProductPrice   | Sum For This Vendor   |
|---------------+---------------------------------+----------------+-----------------------|
| Katty Kittens | Bottomless Coffee Mugs (4 Pack) | 9.99           | 9.99                  |
| Mars Supplies | Long Weight (green)             | 11.99          | 78.72                 |
| Mars Supplies | Long Weight (blue)              | 14.75          | 78.72                 |
| Mars Supplies | Right handed screwdriver        | 25.99          | 78.72                 |
| Mars Supplies | Left handed screwdriver         | 25.99          | 78.72                 |
| Pedal Medals  | Straw Dog Box                   | NULL           | 245.00                |
| Pedal Medals  | Chainsaw                        | 245.00         | 245.00                |
| Randy Roofers | Sledge Hammer                   | 33.49          | 33.49                 |
+---------------+---------------------------------+----------------+-----------------------+

In diesem Fall haben wir den OVER verwendet -Klausel mit unserem SUM() Funktion, um das Ergebnis nach Herstellernamen zu partitionieren.

Auf diese Weise konnten wir Preisinformationen für jedes Produkt sowie die Summe aller Produkte von diesem bestimmten Anbieter zurückgeben. Die Summe ändert sich, wenn sich der Anbieter ändert (es sei denn, mehrere Anbieter haben zufällig dieselbe Summe), bleibt aber für alle Produkte desselben Anbieters gleich.

Dieses Konzept kann auch auf andere Aggregatfunktionen in SQL angewendet werden, wie z. B. AVG() , MIN() , MAX() , und COUNT() .