Convertir le nombre de mots - première, deuxième, troisième et ainsi de suite

Personne ne sait comment si c'est possible de prendre une variable de type entier en SQL et de le convertir à l'équivalent certain nombre de la forme: Premier, Deuxième, Troisième, Quatrième, etc?

Grâce

J'aurais dit, c'est MS SQL.
Quelle version? Il pourrait être pertinent
C'est MSSQL 2000
De quelle taille sont vos chiffres de chances d'être?
Jusqu'à un couple de centaines de.

OriginalL'auteur Danny | 2011-12-08

Cela semble être une approche plus simple, une belle algorithme récursif

CREATE FUNCTION fnIntegerToWords(@Number as BIGINT) 
RETURNS VARCHAR(1024)
AS
BEGIN
DECLARE @Below20 TABLE (ID int identity(0,1), Word varchar(32))
DECLARE @Below100 TABLE (ID int identity(2,1), Word varchar(32))
INSERT @Below20 (Word) VALUES 
( 'Zero'), ('One'),( 'Two' ), ( 'Three'),
( 'Four' ), ( 'Five' ), ( 'Six' ), ( 'Seven' ),
( 'Eight'), ( 'Nine'), ( 'Ten'), ( 'Eleven' ),
( 'Twelve' ), ( 'Thirteen' ), ( 'Fourteen'),
( 'Fifteen' ), ('Sixteen' ), ( 'Seventeen'),
('Eighteen' ), ( 'Nineteen' ) 
INSERT @Below100 VALUES ('Twenty'), ('Thirty'),('Forty'), ('Fifty'),
('Sixty'), ('Seventy'), ('Eighty'), ('Ninety')
declare @belowHundred as varchar(126) 
if @Number > 99 begin
select @belowHundred = dbo.fnIntegerToWords( @Number % 100)
end
DECLARE @English varchar(1024) = 
(
SELECT Case 
WHEN @Number = 0 THEN  ''
WHEN @Number BETWEEN 1 AND 19 
THEN (SELECT Word FROM @Below20 WHERE ID[email protected]Number)
WHEN @Number BETWEEN 20 AND 99   
THEN  (SELECT Word FROM @Below100 WHERE ID[email protected]Number/10)+ '-' +
dbo.fnIntegerToWords( @Number % 10) 
WHEN @Number BETWEEN 100 AND 999   
THEN  (dbo.fnIntegerToWords( @Number / 100)) +' Hundred '+
Case WHEN @belowHundred <> '' THEN 'and ' + @belowHundred else @belowHundred end 
WHEN @Number BETWEEN 1000 AND 999999   
THEN  (dbo.fnIntegerToWords( @Number / 1000))+' Thousand '+
dbo.fnIntegerToWords( @Number % 1000)  
WHEN @Number BETWEEN 1000000 AND 999999999   
THEN  (dbo.fnIntegerToWords( @Number / 1000000))+' Million '+
dbo.fnIntegerToWords( @Number % 1000000) 
WHEN @Number BETWEEN 1000000000 AND 999999999999   
THEN  (dbo.fnIntegerToWords( @Number / 1000000000))+' Billion '+
dbo.fnIntegerToWords( @Number % 1000000000) 
ELSE ' INVALID INPUT' END
)
SELECT @English = RTRIM(@English)
SELECT @English = RTRIM(LEFT(@English,len(@English)-1))
WHERE RIGHT(@English,1)='-'
RETURN (@English)
END

Cela a bien fonctionné pour ce dont j'avais besoin. Je l'ai utilisé pour charger une table de recherche. C'est une belle fonction récursive qui maintient la logique simple.

OriginalL'auteur Matthew Hintzen

Vous devez utiliser un CASE déclaration:

SELECT intfield CASE WHEN 1 THEN 'First'
WHEN 2 THEN 'Second'
WHEN 3 THEN 'Third'
...other conversions...
ELSE '' END
FROM Mytable

MODIFIER:

De travail code de 3 caractères ci-dessous. Vous pouvez ajouter le besoin de code ci-dessous pour 2 et 1 caractères (fondamentalement, il suffit de modifier ce que j'ai écrit et modifier le SUBSTRINGs en conséquence).

Essentiellement, il convertit un nombre en une chaîne, vérifie combien de numéros, puis il la décompose en conséquence.

DECLARE @n int = 515
DECLARE @v varchar(100) = CAST(@N as varchar)
SELECT CASE WHEN LEN(@v) = 3 THEN 
(CASE   WHEN LEFT(@v, 1) = 1 THEN 'One Hundred'
WHEN LEFT(@v, 1) = 2 THEN 'Two Hundred'
WHEN LEFT(@v, 1) = 3 THEN 'Three Hundred'
WHEN LEFT(@v, 1) = 4 THEN 'Four Hundred'
WHEN LEFT(@v, 1) = 5 THEN 'Five Hundred'
WHEN LEFT(@v, 1) = 6 THEN 'Six Hundred'
WHEN LEFT(@v, 1) = 7 THEN 'Seven Hundred'
WHEN LEFT(@v, 1) = 8 THEN 'Eight Hundred'
WHEN LEFT(@v, 1) = 9 THEN 'Nine Hundred'
ELSE '' END)
+ ' ' +
(CASE   WHEN SUBSTRING(@v, 2, 1) = 2 THEN 'Twenty'
WHEN SUBSTRING(@v, 2, 1) = 3 THEN 'Thirty'
WHEN SUBSTRING(@v, 2, 1) = 4 THEN 'Forty'
WHEN SUBSTRING(@v, 2, 1) = 5 THEN 'Fifty'
WHEN SUBSTRING(@v, 2, 1) = 6 THEN 'Sixty'
WHEN SUBSTRING(@v, 2, 1) = 7 THEN 'Seventy'
WHEN SUBSTRING(@v, 2, 1) = 8 THEN 'Eighty'
WHEN SUBSTRING(@v, 2, 1) = 9 THEN 'Ninety'
WHEN SUBSTRING(@v, 2, 1) = 1 THEN 
CASE    WHEN SUBSTRING(@v, 2, 2) = 10 THEN 'Ten'
WHEN SUBSTRING(@v, 2, 2) = 11 THEN 'Eleven'
WHEN SUBSTRING(@v, 2, 2) = 12 THEN 'Twelve'
WHEN SUBSTRING(@v, 2, 2) = 13 THEN 'Thirteen'
WHEN SUBSTRING(@v, 2, 2) = 14 THEN 'Fourteen'
WHEN SUBSTRING(@v, 2, 2) = 15 THEN 'Fifteen'
WHEN SUBSTRING(@v, 2, 2) = 16 THEN 'Sixteen'
WHEN SUBSTRING(@v, 2, 2) = 17 THEN 'Seventeen'
WHEN SUBSTRING(@v, 2, 2) = 18 THEN 'Eighteen'
WHEN SUBSTRING(@v, 2, 2) = 19 THEN 'Nineteen'
ELSE '' END
ELSE '' END)
+ ' ' +
(CASE   WHEN SUBSTRING(@v, 2, 1) = 1 THEN ''
WHEN SUBSTRING(@v, 3, 1) = 2 THEN 'Two'
WHEN SUBSTRING(@v, 3, 1) = 3 THEN 'Three'
WHEN SUBSTRING(@v, 3, 1) = 4 THEN 'Four'
WHEN SUBSTRING(@v, 3, 1) = 5 THEN 'Five'
WHEN SUBSTRING(@v, 3, 1) = 6 THEN 'Six'
WHEN SUBSTRING(@v, 3, 1) = 7 THEN 'Seven'
WHEN SUBSTRING(@v, 3, 1) = 8 THEN 'Eight'
WHEN SUBSTRING(@v, 3, 1) = 9 THEN 'Nine'
WHEN SUBSTRING(@v, 3, 1) = 1 THEN 'One'
ELSE '' END)
END

Ce ne serait pas le travail que le nombre d'entrée pourrait être GRANDE.
Ensuite, vous ne devriez pas essayer de le faire en SQL
J'apprécie le fait que ce genre de chose ne devrait pas être fait dans le SQL environnement, mais malheureusement nous n'avons pas une alternative à l'instant.
bien en SQL, c'est le chemin à parcourir. Il peut y avoir une API que vous pouvez utiliser pour cela dans votre couche application. Si vous êtes limité à l'aide de TSQL puis un CASE est à peu près aussi bon qu'il obtient. Vous pourriez éventuellement faire un TABLEAU pour le présent et JOIN sur que trop
+1 C'est vraiment votre seul choix. Vous pouvez remarquer quelques modèles dans la langue anglaise une fois que vous obtenez jusqu'à des choses comme twenty-first, thirty-second et ainsi de suite.

OriginalL'auteur JNK

Aussi, vous pouvez CREATE TABLE avec des nombres et de leurs noms.

CREATE TABLE tblNumbers (Nmb int, NmbWord varchar(100))
INSERT INTO tblNumbers 
VALUES (1,'first'), (2,'second'),(3,'third'), (4,'forth')
CREATE TABLE SomeTable (nmb int)
INSERT INTO SomeTable 
VALUES (1), (1),(2),(3)
SELECT  N.*
FROM tblNumbers N
JOIN SomeTable ST ON ST.nmb=N.Nmb
DROP TABLE tblNumbers
DROP TABLE SomeTable

C'est certainement une possibilité, si la nécessité de cette increasese. Merci.

OriginalL'auteur Igor Borisenko

0

Il n'est pas inhérente à la fonctionnalité qui reconnaît les nombres et les convertit en mots. Vous devez monter un dossier de déclaration ou d'une fonction/procédure stockée qui va le faire pour vous en fonction de vos règles de gestion.

http://www.novicksoftware.com/udfofweek/Vol2/T-SQL-UDF-Vol-2-Num-9-udf_Num_ToWords.htm

+1 pour le lien
Le lien est mort

OriginalL'auteur Vinnie

Cela devrait fonctionner jusqu'à 999...

IF OBJECT_ID('tempdb..#numbers_list') IS NOT NULL DROP TABLE #numbers_list
CREATE TABLE #numbers_list (int_value INT, text_value VARCHAR(100))
INSERT INTO #numbers_list
SELECT 1 as int_value, 'One' as text_value UNION ALL
SELECT 2 as int_value, 'Two' as text_value UNION ALL
SELECT 3 as int_value, 'Three' as text_value UNION ALL
SELECT 4 as int_value, 'Four' as text_value UNION ALL
SELECT 5 as int_value, 'Five' as text_value UNION ALL
SELECT 6 as int_value, 'Six' as text_value UNION ALL
SELECT 7 as int_value, 'Seven' as text_value UNION ALL
SELECT 8 as int_value, 'Eight' as text_value UNION ALL
SELECT 9 as int_value, 'Nine' as text_value UNION ALL
SELECT 10 as int_value, 'Ten' as text_value UNION ALL
SELECT 11 as int_value, 'Eleven' as text_value UNION ALL
SELECT 12 as int_value, 'Twelve' as text_value UNION ALL
SELECT 13 as int_value, 'Thirteen' as text_value UNION ALL
SELECT 14 as int_value, 'Fourteen' as text_value UNION ALL
SELECT 15 as int_value, 'Fifteen' as text_value UNION ALL
SELECT 16 as int_value, 'Sixteen' as text_value UNION ALL
SELECT 17 as int_value, 'Seventeen' as text_value UNION ALL
SELECT 18 as int_value, 'Eighteen' as text_value UNION ALL
SELECT 19 as int_value, 'Nineteen' as text_value UNION ALL
SELECT 20 as int_value, 'Twenty' as text_value UNION ALL
SELECT 30 as int_value, 'Thirty' as text_value UNION ALL
SELECT 40 as int_value, 'Fourty' as text_value UNION ALL
SELECT 50 as int_value, 'Fifty' as text_value UNION ALL
SELECT 60 as int_value, 'Sixty' as text_value UNION ALL
SELECT 70 as int_value, 'Seventy' as text_value UNION ALL
SELECT 80 as int_value, 'Eighty' as text_value UNION ALL
SELECT 90 as int_value, 'Ninety' as text_value UNION ALL
SELECT 100 AS int_value, 'One Hundred' AS text_value
SELECT 
tst2.number
,CASE WHEN exact.text_value IS NOT NULL THEN exact.text_value 
WHEN tst2.number > 100 AND COALESCE(tens.text_value,ones.text_value) IS NULL THEN hunds.text_value + ' Hundred'
WHEN tst2.number > 100 AND tst2.number_of_ones = 0 THEN hunds.text_value + ' Hundred And ' + tens.text_value
WHEN tst2.number > 100 AND tst2.number_of_tens = 0 THEN hunds.text_value + ' Hundred And ' + ones.text_value
WHEN tst2.number > 100 THEN hunds.text_value + ' Hundred And ' + tens.text_value + ' ' + ones.text_value
WHEN tst2.number > 10 THEN tens.text_value + ' ' + ones.text_value
END AS string
FROM
(
SELECT tst.number
,tst.number % 10 as number_of_ones
,CASE WHEN tst.number < 101 THEN tst.number - (tst.number % 10) 
WHEN tst.number > 100 THEN tst.number - 100 * (FLOOR(tst.number / 100)) - (tst.number % 10)
END as number_of_tens
,tst.number / 100 as number_of_hundreds
FROM 
(
SELECT 22 as number UNION ALL
SELECT 27 UNION ALL
SELECT 10 UNION ALL
SELECT 101 UNION ALL
SELECT 200 UNION ALL
SELECT 227
) tst
) tst2
LEFT OUTER JOIN #numbers_list exact on exact.int_value = tst2.number --if an exact match
LEFT OUTER JOIN #numbers_list ones on ones.int_value = tst2.number_of_ones 
LEFT OUTER JOIN #numbers_list tens on tens.int_value = tst2.number_of_tens
LEFT OUTER JOIN #numbers_list hunds on hunds.int_value = tst2.number_of_hundreds

OriginalL'auteur Dibstar

Vous devez vous connecter pour publier un commentaire.