In SQL Server is de T-SQL ROUND() functie stelt u in staat een getal af te ronden tot een gespecificeerde lengte of precisie.
U geeft het getal op als argument, evenals de lengte waarop het getal moet worden afgerond. De functie accepteert ook een optioneel derde argument waarmee u kunt specificeren of het getal is afgerond of afgekapt.
Syntaxis
De syntaxis gaat als volgt:
ROUND ( numeric_expression , length [ ,function ] )
Waarbij de argumenten de volgende definities hebben:
- numeric_expression
- Is een uitdrukking van de exacte numerieke of geschatte numerieke gegevenstypecategorie, behalve de bit gegevenstype.
- lengte
- Is de precisie waarmee numeric_expression moet worden afgerond. Dit argument moet een uitdrukking zijn van het type tinyint , kleine , of int . Als het een positief getal is, numeric_expression wordt afgerond op het aantal decimalen dat door dit argument wordt gespecificeerd. Als het een negatief getal is, numeric_expression wordt afgerond aan de linkerkant van de komma, zoals gespecificeerd door dit argument.
- functie
- Is het type bewerking dat moet worden uitgevoerd. Dit moet tinyint . zijn , kleine , of int . Wanneer dit argument wordt weggelaten of de waarde 0 heeft (standaard), numeric_expression wordt afgerond. Wanneer een andere waarde dan 0 is opgegeven, numeric_expression wordt afgekapt.
Voorbeeld 1 – Basisgebruik
Hier is een eenvoudig voorbeeld om te demonstreren hoe deze functie werkt.
SELECT ROUND(1.49, 1) Result;
Resultaat:
+----------+ | Result | |----------| | 1.50 | +----------+
In dit geval wordt het getal naar boven afgerond.
Voorbeeld 2 – nul decimalen
Als we het tweede argument op nul zetten, gebeurt het volgende:
SELECT ROUND(1.49, 0) Result;
Resultaat:
+----------+ | Result | |----------| | 1.00 | +----------+
Dit komt omdat we nul fractionele delen hebben opgegeven waarmee het getal moet worden afgerond.
En dit is wat er gebeurt als ik het beginnummer verander in 1.50:
SELECT ROUND(1.50, 0) Result;
Resultaat:
+----------+ | Result | |----------| | 2.00 | +----------+
Voorbeeld 3 – Meer decimalen
Hier is een voorbeeld waarbij het getal dat moet worden afgerond meer decimalen bevat.
SELECT ROUND(1.234, 2) Result;
Resultaat:
+----------+ | Result | |----------| | 1.230 | +----------+
En dit gebeurt er als ik het laatste cijfer verhoog naar 5:
SELECT ROUND(1.235, 2) Result;
Resultaat:
+----------+ | Result | |----------| | 1.240 | +----------+
Natuurlijk kunnen we veel meer decimalen gebruiken. We zouden bijvoorbeeld veel decimalen kunnen inkorten.
SELECT ROUND(1.23456789123456789, 8) Result;
Resultaat:
+---------------------+ | Result | |---------------------| | 1.23456789000000000 | +---------------------+
Voorbeeld 4 – Truncatie (d.w.z. een derde argument gebruiken)
Zoals gezegd, kunnen we een derde argument geven om aan te geven of het resultaat wordt afgekapt of alleen afgerond. De vorige voorbeelden zijn allemaal afgerond omdat we geen derde argument hebben gespecificeerd. Als we het derde argument weglaten, wordt de waarde 0 gebruikt (wat betekent dat het resultaat wordt afgerond). Als we een andere waarde dan 0 opgeven, wordt het resultaat afgekapt.
SELECT ROUND(1.236, 2) 'Rounded (by default)', ROUND(1.236, 2, 0) 'Rounded (explicitly)', ROUND(1.236, 2, 1) 'Truncated';
Resultaat:
+------------------------+------------------------+-------------+ | Rounded (by default) | Rounded (explicitly) | Truncated | |------------------------+------------------------+-------------| | 1.240 | 1.240 | 1.230 | +------------------------+------------------------+-------------+
Voorbeeld 5 – Een negatieve waarde gebruiken voor het tweede argument
Hier leest u hoe we een negatieve waarde voor het tweede argument kunnen gebruiken om ervoor te zorgen dat delen van het niet-fractionele deel naar nul worden afgerond.
SELECT ROUND(123.456, -1) Result;
Resultaat:
+----------+ | Result | |----------| | 120.000 | +----------+
En zo wordt het afgerond als we de 3 . verhogen tot 5 of meer.
SELECT ROUND(125.456, -1) Result;
Resultaat:
+----------+ | Result | |----------| | 130.000 | +----------+
U kunt dit zelfs doen als het getal geen breuk bevat.
SELECT ROUND(125, -1) Result;
Resultaat:
+----------+ | Result | |----------| | 130 | +----------+
Voorbeeld 6 – Negatieve getallen afronden versus positieve getallen
Zoals te zien is in de vorige voorbeelden, wordt bij het gebruik van positieve getallen een waarde met een breuk van 0,5 of hoger naar boven afgerond op het volgende gehele getal.
Als u echter negatieve getallen gebruikt, worden dergelijke waarden naar beneden afgerond .
SELECT ROUND(1.50, 0) Positive, ROUND(-1.50, 0) Negative;
Resultaat:
+------------+------------+ | Positive | Negative | |------------+------------| | 2.00 | -2.00 | +------------+------------+