web-dev-qa-db-fra.com

Comment convertir un int en une chaîne à remplissage zéro en T-SQL?

Disons que j'ai un int avec la valeur 1. Comment puis-je convertir cet int en une chaîne zéro complétée, telle que 00000001?

sqltsql
39
flipdoubt
Declare @MyInt integer Set @MyInt = 123
Declare @StrLen TinyInt Set @StrLen = 8

Select Replace(Str(@MyInt, @StrLen), ' ' , '0')
39
Charles Bretana

Une autre façon est:

DECLARE @iVal int = 1
select REPLACE(STR(@iVal, 8, 0), ' ', '0')
35
Mitch Wheat

à partir de SQL Server 2012, vous pouvez maintenant faire ceci:

format(@int, '0000#')
31
gordy

Ce travail pour moi:

SELECT RIGHT('000' + CAST(Table.Field AS VARCHAR(3)),3) FROM Table

...

J'ai créé cette fonction utilisateur

Code T-SQL:

CREATE FUNCTION CIntToChar(@intVal Int, @intLen Int) RETURNS nvarchar(24) AS BEGIN

IF @intlen > 24
   SET @intlen = 24

RETURN REPLICATE('0',@intLen-LEN(RTRIM(CONVERT(nvarchar(24),@intVal)))) 
    + CONVERT(nvarchar(24),@intVal) END

Exemple :

SELECT dbo.CIntToChar (867, 6) AS COD_ID

SORTIE

000867

9
RicardoBalda

Si j'essaie d'ajouter une longueur totale spécifique, j'utilise les fonctions REPLICATE et DATALENGTH, comme suit:

DECLARE @INT INT
DECLARE @UNPADDED VARCHAR(3)
DECLARE @PADDED VARCHAR(3)

SET @INT = 2
SET @UNPADDED = CONVERT(VARCHAR(3),@INT)
SET @PADDED = REPLICATE('0', 3 - DATALENGTH(@UNPADDED)) + @UNPADDED
SELECT @INT, @UNPADDED, @PADDED

J'ai utilisé des variables ici pour simplifier les choses, mais vous voyez, vous pouvez spécifier la longueur finale de la chaîne totale sans vous soucier de la taille de l'INT par laquelle vous commencez tant que <= la longueur finale de la chaîne.

1
Steve Brouillard

Si l'int peut devenir négatif, vous avez un problème, alors pour éviter cela, je fais parfois ceci:

DECLARE @iVal int 
set @iVal = -1
    select 
        case 
            when @ival >= 0 then right(replicate('0',8) + cast(@ival as nvarchar(8)),8)
            else '-' + right(replicate('0',8) + cast(@ival*-1 as nvarchar(8)),8)
        end
1
Jim Birchall

J'utilise toujours:

SET @padded = RIGHT('z0000000000000'
  + convert(varchar(30), @myInt), 8)

Le z empêche le code SQL de convertir implicitement la chaîne en un entier pour l'ajout/la concaténation.

1
Amy B

Utilisez FORMAT(<your number>,'00000000'), utilisez autant de zéros que nécessaire pour avoir des chiffres dans votre résultat final.

Voici la documentation officielle de la fonction FORMAT

1
Ilia Gilmijarow

Une façon très simple de penser au padding avec '0's est que si vous corrigez que votre @ _int ait 4 décimales, vous injectez 4' 0:

    select RIGHT( '0000'+ Convert(varchar, @_int), 4) as txtnum

; si votre espace fixe est 3, vous injectez 3'0

    select RIGHT( '000'+ Convert(varchar, @_int), 3) as txtnum

; ci-dessous, j'injecte '00' pour générer 99 étiquettes pour chaque bâtiment

declare @_int int
set @_int = 1
while @_int < 100 Begin
    select BldgName + '.Floor_' + RIGHT( '00'+ Convert(varchar, @_int), 2) 
    + '.balcony' from dbo.tbl_FloorInfo group by BldgName
    set @_int = @_int +1
End

Le résultat est:

    'BldgA.Floor_01.balcony'
    'BldgB.Floor_01.balcony'
    'BldgC.Floor_01.balcony'
     ..
     ..
    'BldgA.Floor_10.balcony'
    'BldgB.Floor_10.balcony'
    'BldgC.Floor_10.balcony'
     ..
     ..
     ..
    'BldgA.Floor_99.balcony'
    'BldgB.Floor_99.balcony'
    'BldgC.Floor_99.balcony'
1
Jenna Leaf

Ou si vous voulez vraiment aller au plus dur ... ;-)

declare @int int
set @int = 1

declare @string varchar(max)
set @string = cast(@int as varchar(max))

declare @length int
set @length = len(@string)

declare @MAX int
set @MAX = 8

if @length < @MAX
begin
    declare @zeros varchar(8)
    set @zeros = ''

    declare @counter int
    set @counter = 0

    while (@counter < (@MAX - @length))
    begin
        set @zeros = @zeros + '0'
        set @counter = @counter + 1
    end
    set @string = @zeros + @string
end
print @string
0
user39603

Je pense que la réponse de Charles Bretana est la plus simple et la plus rapide. Une solution similaire sans utiliser STR est la suivante:

SELECT REPLACE(REVERSE(
        CONVERT(CHAR(5 /*<= Target length*/)
                , REVERSE(CONVERT(VARCHAR(100), @MyInt)))
     ), ' ', '0')
0
Diego

Et puis il y a celui-ci, en utilisant REPLICATE:

SELECT REPLICATE('0', 7) + '1'

Bien sûr, vous pouvez remplacer les littéraux 7 et '1' par les fonctions appropriées selon vos besoins; ce qui précède vous donne votre exemple. Par exemple:

SELECT REPLICATE('0', 8 - LEN(CONVERT(nvarchar, @myInt))) + CONVERT(nvarchar, @myInt)

remplira un entier de moins de 8 places avec des zéros jusqu'à 8 caractères. 

Maintenant, un nombre négatif dans le deuxième argument de REPLICATE renverra NULL. Ainsi, si cela est possible (par exemple, @myInt pourrait dépasser 100 millions dans l'exemple ci-dessus), vous pouvez utiliser COALESCE pour renvoyer le nombre sans zéros à gauche s'il y a plus de 8 caractères: 

SELECT COALESCE(REPLICATE('0', 8 - LEN(CONVERT(nvarchar, @myInt))) + CONVERT(nvarchar, @myInt), CONVERT(nvarchar, @myInt))
0
BobRodes