De meeste grote RDBMS'en bieden ons manieren om getallen op te maken met SQL. Sommige bieden alleen basisformatteringsmogelijkheden, terwijl andere geavanceerder zijn.
Hieronder staan voorbeelden van het opmaken van een getal in enkele van de meer populaire RDBMS'en.
MySQL
In MySQL kunnen we de FORMAT() . gebruiken functie om een getal op te maken in een specifiek formaat. Deze functie accepteert drie parameters; het aantal, het aantal decimalen en een optionele landinstelling:
SELECT FORMAT(123456.789, 2);Resultaat:
123,456.79
Zoals vermeld, kunt u ook een derde argument doorgeven om de landinstelling op te geven die moet worden gebruikt voor het opmaakpatroon. Zie Getallen opmaken in MySQL voor een voorbeeld.
Om getallen op te maken als valuta, zie Getallen opmaken als valuta in MySQL.
Oracle
Oracle Database biedt ons een aantal opties als het gaat om het opmaken van getallen.
In het bijzonder de TO_CHAR(number) functie stelt ons in staat om een getal op te maken op basis van ons eigen aangepaste formaatmodel.
Voorbeeld:
SELECT
TO_CHAR(12345, 'fmL99G999D00')
FROM DUAL;Resultaat:
$12,345.00
Het eerste argument is het getal dat moet worden opgemaakt en het tweede argument is het formaatmodel. Het formaatmodel bestaat uit een of meer formaatelementen, die elk een ander element in de opgemaakte uitvoer vertegenwoordigen.
In het bovenstaande voorbeeld gebruiken we de 9 teken om elk cijfer weer te geven, en de 0 teken om het cijfer of de nul uit te voeren (afhankelijk van of er al dan niet een cijfer op die positie bestaat). We gebruiken ook G voor een lokaal bewust groepsscheidingsteken en D voor een locale bewust decimaal scheidingsteken. De fm element onderdrukt eventuele voorloop- of volgopvulling die op het resultaat kan worden toegepast.
Hier is een volledige lijst met opmaakelementen die u voor uw opmaakmodel kunt gebruiken bij het opmaken van getallen.
Er zijn andere manieren om getallen op te maken in Oracle. Bijvoorbeeld de LPAD() functie kan worden gebruikt om getallen naar een tekenreeks te converteren en ze direct op te maken zoals u wilt. Functies zoals CAST() kan ook van invloed zijn op de opmaak van een getal, afhankelijk van het gegevenstype waarin het wordt gecast.
Zie Getallen opmaken in Oracle voor meer details en voorbeelden.
PostgreSQL
Net als Oracle heeft PostgreSQL ook een TO_CHAR() functie, en het werkt op ongeveer dezelfde manier:
SELECT TO_CHAR(923, 'fm000G000th');Resultaat:
000,923rd
Hier gebruikte ik de 0 format-element om voorloopnullen uit te voeren, zelfs als het oorspronkelijke nummer op die plaats geen cijfers had. In dit geval gebruikte ik de th format-element om het getal naar het ordinale getal te converteren. Ik gebruikte ook G voor een lokaal bewust groepsscheidingsteken.
Hier is een lijst met sjabloonpatronen waaruit de opmaakreeks kan bestaan bij het opmaken van getallen, evenals de opmaakmodifiers.
Een andere manier om een getal op te maken in PostgreSQL is door het te converteren naar money data type. Nummers opgeslagen als het money type worden uitgevoerd in een indeling die bekend is met de landinstelling, met het juiste valutasymbool, groepsscheidingsteken, decimaalteken, enz.:
SELECT CAST(10000 as money);Resultaat:
$10,000.00
Zie Getallen opmaken in PostgreSQL voor meer voorbeelden van opmaak van getallen in PostgreSQL.
SQL-server
SQL Server heeft de FORMAT() functie, die ongeveer hetzelfde werkt als Oracle en PostgreSQL's TO_CHAR() functie, in die zin dat u getallen kunt opmaken op basis van een opmaakreeks:
SELECT
FORMAT(123456.789, 'N') AS "Number",
FORMAT(123456.789, 'P') AS "Percent",
FORMAT(123456.789, 'C') AS "Currency";Resultaat:
+------------+----------------+-------------+ | Number | Percent | Currency | |------------+----------------+-------------| | 123,456.79 | 12,345,678.90% | $123,456.79 | +------------+----------------+-------------+
Dit voorbeeld demonstreert drie standaardformaatspecificaties - die elk het getal in een specifiek formaat uitvoeren.
We kunnen ook onze eigen aangepaste formaatspecificaties gebruiken, waarmee we ons eigen formaat kunnen maken, voor het geval dat het standaardformaat niet is wat we willen.
Je kunt ook dingen doen zoals getallen opmaken in hun hexadecimale equivalent, of exponentiële notatie gebruiken, enz.
En je kunt een optioneel derde argument doorgeven om de landinstelling te specificeren waarvoor het getal moet worden opgemaakt (het formatteert het getal volgens de conventies van die landinstelling).
Zie Getallen opmaken in SQL Server voor meer voorbeelden.
MariaDB
Net als MySQL heeft MariaDB een FORMAT() functie, die de basisgetalnotatie biedt.
Hier is een voorbeeld van het gebruik van deze functie om een getal op te maken met verschillende landinstellingen:
SELECT
FORMAT(123456.789, 2, 'ta_IN') AS "Tamil, India",
FORMAT(123456.789, 2, 'de_DE') AS "German, Germany",
FORMAT(123456.789, 2, 'zh_HK') AS "Chinese, Hong Kong";Resultaat:
+--------------+-----------------+--------------------+ | Tamil, India | German, Germany | Chinese, Hong Kong | +--------------+-----------------+--------------------+ | 1,23,456.79 | 123.456,79 | 123,456.79 | +--------------+-----------------+--------------------+
Zie Getallen opmaken in MariaDB voor meer voorbeelden.
SQLite
SQLite is beperkter dan de andere DBMS'en als het gaat om het formatteren van getallen. Er zijn echter manieren om wat basisgetalnotatie te krijgen:
SELECT PRINTF("%,d", 123456789);Resultaat:
123,456,789
De PRINTF() functie kan groepsscheidingstekens uitvoeren voor gehele getallen, maar niet voor reële/zwevende kommagetallen. Om echte / drijvende-kommagetallen op te maken, moet u wat meer werk doen. Zie Getallen opmaken met een komma in SQLite voor een voorbeeld van wat ik bedoel.
Bijwerken :SQLite 3.38.0 (uitgebracht op 22 februari 2022) hernoemde de PRINTF() functie naar FORMAT() . De originele PRINTF() naam wordt behouden als een alias voor achterwaartse compatibiliteit.
Dus het bovenstaande voorbeeld kan hier in veranderd worden:
SELECT FORMAT("%,d", 123456789);Resultaat:
123,456,789