Dit artikel bevat voorbeelden van het converteren van een smalldatetime waarde tot een tijd waarde in SQL Server.
Wanneer u een smalldatetime . converteert waarde tot tijd , verlies je de datum. De uren, minuten en seconden worden gekopieerd. De fractionele seconden zijn ingesteld op 0.
De smalldatetime gegevenstype omvat zowel de datum als de tijd. De tijd heeft echter geen fractionele seconden en de secondencomponent is altijd ingesteld op nul (:00). De nauwkeurigheid is tot op de minuut nauwkeurig. De opslaggrootte is 4 bytes.
De tijd gegevenstype daarentegen bevat alleen de tijd. U kunt echter een precisie van een fractie van een seconde specificeren van 0 tot 7. Dit wordt bereikt door de time(n) ) syntaxis, waarbij n is de schaal van 0 tot 7. Als u dit niet opgeeft, gebruikt het 7 (de standaard), wat zorgt voor een nauwkeurigheid van 100 nanoseconden. Als u nul opgeeft (0 ), is de nauwkeurigheid tot op de seconde nauwkeurig. De opslaggrootte is 3, 4 of 5 bytes (plus 1 byte om de precisie op te slaan), afhankelijk van de precisie van de fractionele seconden.
Voorbeeld 1 – Impliciete conversie
Hier is een voorbeeld van een impliciete conversie tussen datetime en tijd .
DECLARE @thesmalldatetime smalldatetime, @thetime time; SET @thesmalldatetime = '2025-05-21 10:15:30'; SET @thetime = @thesmalldatetime; SELECT @thesmalldatetime AS 'smalldatetime', @thetime AS 'time';
Resultaat:
+---------------------+----------+ | smalldatetime | time | |---------------------+----------| | 2025-05-21 10:16:00 | 10:16:00 | +---------------------+----------+
Dit is een impliciete conversie omdat we geen conversiefunctie (zoals hieronder) gebruiken om deze expliciet te converteren. In dit geval voert SQL Server achter de schermen een impliciete conversie uit wanneer we proberen de smalldatetime toe te wijzen waarde tot een tijd variabel.
Het meest voor de hand liggende aan dit resultaat is dat de tijd waarde is exclusief de datum. Dit is te verwachten, omdat de tijd gegevenstype is uitsluitend bedoeld voor het opslaan van tijdwaarden, niet voor datumwaarden.
Wat is niet duidelijk (althans met mijn voorbeeld) is dat de tijdwaarde een fractie van een seconde aankan. Mijn systeem geeft de fractionele seconden hier niet weer, maar het volgende voorbeeld laat zien dat het inderdaad een fractionele seconden precisie van 7 heeft.
Als je goed kijkt, zie je ook dat de smalldatetime waarde afgerond op de minuten van de werkelijke waarde die ik probeerde toe te wijzen. Dit weerspiegelt de relatief lage precisie van de smalldatetime data type. De precisie is tot op de minuut nauwkeurig. Het voor de hand liggende gevolg hiervan is dat wanneer we de waarde uiteindelijk opnieuw toewijzen aan de tijd gegevenstype, het is de afgeronde waarde die is toegewezen - niet de initiële waarde die ik heb geprobeerd toe te wijzen. Als we de beginwaarde direct hadden toegewezen aan de tijd variabele, zouden we een preciezere waarde hebben gekregen (zelfs als we een schaal van 0 hadden gespecificeerd).
Dit is wat ik bedoel:
DECLARE @thesmalldatetime smalldatetime, @thetime time(0); SET @thesmalldatetime = '2025-05-21 10:15:30'; SET @thetime = '2025-05-21 10:15:30'; SELECT @thesmalldatetime AS 'smalldatetime', @thetime AS 'time';
Resultaat:
+---------------------+----------+ | smalldatetime | time | |---------------------+----------| | 2025-05-21 10:16:00 | 10:15:30 | +---------------------+----------+
Voorbeeld 2 – Fractionele seconden toevoegen
De smalldatetime gegevenstype heeft geen fractie van seconden, maar in ons eerste voorbeeld is de tijd waarde heeft een precisie van een fractie van een seconde van 7 (ook al worden er geen decimalen weergegeven). Ik ken de precisie omdat ik geen schaal heb opgegeven bij het declareren, daarom gebruikt het de standaardschaal van 7.
Hier is een voorbeeld om te bevestigen dat de tijd waarde kan in feite een fractioneel deel ondersteunen:
DECLARE @thesmalldatetime smalldatetime, @thetime time; SET @thesmalldatetime = '2025-05-21 10:15:30'; SET @thetime = @thesmalldatetime; SELECT @thesmalldatetime AS 'smalldatetime', @thetime AS 'Original time', DATEADD(nanosecond, 123456700, @thetime) AS 'Modified time';
Resultaat:
+---------------------+-----------------+------------------+ | smalldatetime | Original time | Modified time | |---------------------+-----------------+------------------| | 2025-05-21 10:16:00 | 10:16:00 | 10:16:00.1234567 | +---------------------+-----------------+------------------+
Merk op dat wanneer de tijd waarde heeft een schaal van 7, het heeft een opslaggrootte van 5 bytes. Daarom heeft het hogere opslagvereisten dan de smalldatetime type (dat slechts 4 bytes gebruikt).
Voorbeeld 3 – Expliciete conversie met CAST()
Hier is een voorbeeld van een expliciete conversie. In dit geval gebruik ik de CAST() functie direct binnen de SELECT statement om expliciet te converteren tussen smalldatetime en tijd .
DECLARE @thesmalldatetime smalldatetime; SET @thesmalldatetime = '2025-05-21 10:15:30.125'; SELECT @thesmalldatetime AS 'smalldatetime', CAST(@thesmalldatetime AS time(0)) AS 'time(0)';
Resultaat:
+---------------------+-----------+ | smalldatetime | time(0) | |---------------------+-----------| | 2025-05-21 10:16:00 | 10:16:00 | +---------------------+-----------+
In dit voorbeeld zet ik de schaal op 0.
Voorbeeld 4 – Expliciete conversie met CONVERT()
Hier is een voorbeeld van een expliciete conversie met de CONVERT() functie in plaats van CAST() .
DECLARE @thesmalldatetime smalldatetime; SET @thesmalldatetime = '2025-05-21 10:15:30.125'; SELECT @thesmalldatetime AS 'smalldatetime', CONVERT(time(0), @thesmalldatetime) AS 'time(0)';
Resultaat:
+---------------------+-----------+ | smalldatetime | time(0) | |---------------------+-----------| | 2025-05-21 10:16:00 | 10:16:00 | +---------------------+-----------+