web-dev-qa-db-fra.com

Comment convertir int en caractère avec des zéros non significatifs?

J'ai besoin de convertir int datafield en nvarchar avec des zéros non significatifs

exemple:

1 convertir en '001'

867 convertir en '000867', etc.

tHX.

Voici ma réponse 4 heures plus tard ...

J'ai testé ce script T-SQL et fonctionne très bien pour moi!

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

SELECT RIGHT('000' + CAST(@number1 AS NCHAR(3)), 3 ) AS NUMBER_CONVERTED

SELECT RIGHT('000000' + CAST(@number2 AS NCHAR(6)), 6 ) AS NUMBER_CONVERTED

J'ai créé cette fonction utilisateur

Code T-SQL:

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

    -- BIGINT = 2^63-1 (9,223,372,036,854,775,807) Max size number

    -- @intlen contains the string size to return
    IF @intlen > 20
       SET @intlen = 20

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

END

Exemple :

SELECT dbo.CIntToChar (867, 6) AS COD_ID

SORTIE

000867

sql-serverstored-procedures
84
RicardoBalda

Essayez ceci: select right('00000' + cast(Your_Field as varchar(5)), 5)

Le résultat sera composé de 5 chiffres, ex: 00001, ...., 01234

82
Nguyen Tran

Vous pouvez également utiliser la fonction FORMAT () introduite dans SQL Server 2012 . http://technet.Microsoft.com/library/hh213505.aspx

DECLARE @number1 INT, @number2 INT

SET @number1 = 1
SET @number2 = 867

SELECT FORMAT(@number1, 'd10')
SELECT FORMAT(@number2, 'd10')
44
Darek.K

Utilisez REPLICATE afin de ne pas coder en dur tous les zéros non significatifs:

DECLARE @InputStr int
       ,@Size     int
SELECT @InputStr=123
      ,@Size=10

PRINT REPLICATE('0',@Size-LEN(RTRIM(CONVERT(varchar(8000),@InputStr)))) + CONVERT(varchar(8000),@InputStr)

SORTIE:

0000000123
21
KM.

Ne vous inquiétez pas pour cette question, mais il faut noter que vous devez utiliser (N) VARCHAR au lieu du type de données (N) CHAR.

RIGHT('000' + CAST(@number1 AS NCHAR(3)), 3 )

Le segment ci-dessus ne produira pas la réponse correcte de SQL 2005

RIGHT('000' + CAST(@number1 AS NVARCHAR(3)), 3 )

Au-dessus du segment, produira la réponse souhaitée de SQL 2005

Le varchar vous fournira la longueur de préfixe souhaitée à la volée . Where, car le type de données de longueur fixe nécessitera une désignation et des ajustements de longueur.

13
GoldBishop

Le type de données "int" ne peut pas comporter plus de 10 chiffres. De plus, la fonction "Len ()" fonctionne avec les ints. Il n'est donc pas nécessaire de convertir l'int en chaîne avant d'appeler la fonction len ().

Enfin, vous ne prenez pas en compte le cas où la taille de votre int> correspond au nombre total de chiffres pour lesquels vous souhaitez l'ajouter (@intLen).

Par conséquent, une solution plus concise/correcte est la suivante:

CREATE FUNCTION rf_f_CIntToChar(@intVal Int, @intLen Int) RETURNS nvarchar(10)
AS
BEGIN
    IF @intlen > 20 SET @intlen = 20
    IF @intlen < LEN(@intVal) RETURN RIGHT(CONVERT(nvarchar(10), @intVal), @intlen)
    RETURN REPLICATE('0', @intLen - LEN(@intVal)) + CONVERT(nvarchar(10), @intVal)
END
4
C.List

J'aime utiliser 

DECLARE @Length int
DECLARE @Number int
SET @Length = 9
SET @Number = 4

select right( POWER(10, @Length) + @Number, @Length)

cela me donne 

000000004
4
Sedecimdies

Pas très élégant, mais j'ajoute une valeur définie avec le même nombre de zéros que je souhaite au chiffre que je veux convertir et j'utilise la fonction DROITE.

Exemple:

SELECT RIGHT(CONVERT(CHAR(7),1000000 + @number2),6)

Résultat: '000867'

2
Brute Force SQL

Solution à une ligne ( en soi ) pour SQL Server 2008 ou version ultérieure:

DECLARE @DesiredLenght INT = 20;
SELECT 
    CONCAT(
        REPLICATE(
            '0',
            (@DesiredLenght-LEN([Column])) * (1+SIGN(@DesiredLenght-LEN([Column])) / 2) ),
        [Column])
FROM Table;

La multiplication par l'expression SIGN équivaut à MAX(0, @DesiredLenght-LEN([Column])). Le problème est que MAX() n'accepte qu'un seul argument ...

1
Piotr Nawrot
    select right('000' + convert(varchar(3),id),3) from table

    example
    declare @i int
    select @i =1

select right('000' + convert(varchar(3),@i),3)

BTW si c'est une colonne int alors il ne gardera toujours pas les zéros Faites-le simplement dans la couche de présentation ou si vous en avez vraiment besoin dans le SELECT

1
Tarun Gupta

Dans mon cas, je souhaitais que mon champ soit composé de zéros en tête dans un champ de 10 caractères (NVARCHAR (10)) . Le fichier source ne contenait pas les zéros en tête nécessaires pour ensuite rejoindre une autre table . être sur SQL Server 2008R2:

Set Field = right (('0000000000' + [Field]), 10) (Impossible d'utiliser Format () car il s'agit d'une version antérieure à SQL2012)

Effectué cela avec les données existantes. Ainsi, 1 ou 987654321 remplira toujours les 10 espaces avec les 0 premiers.

Au fur et à mesure que les nouvelles données sont importées puis transférées dans la table via une base de données Access, je peux utiliser Format ([Champ], "0000000000") lors de l'ajout à partir d'Accès à la table du serveur SQL pour tout nouvel enregistrement.

1
jhimes

J'ai trouvé un bon article ici :

Rembourrage d'une chaîne avec des zéros au début

J'ai besoin de le faire beaucoup de fois. lors de la sortie d'une donnée de longueur fixe exporter où par exemple un numérique la colonne est composée de 9 caractères et vous besoin de préfixer avec les 0 premiers.

1
Andrew Hare

Si j'avais le même problème, c'est comme ça que j'ai résolu ... Simple et élégant. Le "4" correspond à la longueur de la chaîne. Quelle que soit la longueur du nombre entier transmis, il complétera les zéros jusqu'à "4".

STUFF(SomeVariableOrField,1,0,REPLICATE('0',4 - LEN(SomeVariableOrField)))
1
user2096582
DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

- Sans 'RTRIM', la valeur renvoyée est 3__ !!!

SELECT RIGHT('000' + RTRIM(CAST(@number1 AS NCHAR(3)), 3 )) AS NUMBER_CONVERTED

- Sans 'RTRIM', la valeur renvoyée est 867___ !!! 

SELECT RIGHT('000000' + RTRIM(CAST(@number2 AS NCHAR(6)), 6 )) AS NUMBER_CONVERTED
0
John Lonberger

Cela fonctionne pour moi dans MYSQL:

FUNCTION leadingZero(format VARCHAR(255), num VARCHAR(255))
  RETURNS varchar(255) CHARSET utf8
BEGIN
  return CONCAT(SUBSTRING(format,1,LENGTH(format)-LENGTH(num)),num);
END

Par exemple:

leadingZero('000',999); returns '999'
leadingZero('0000',999); returns '0999'
leadingZero('xxxx',999); returns 'x999'

J'espère que cela vous aidera . Cordialement

0
Tricky Silence

Utiliser RIGHT est une bonne option, mais vous pouvez également effectuer les opérations suivantes:

SUBSTRING(CAST((POWER(10, N) + value) AS NVARCHAR(N + 1)), 2, N)

où N est le nombre total de chiffres que vous voulez afficher. Donc, pour une valeur à 3 chiffres avec des zéros non significatifs (N = 3):

SUBSTRING(CAST((POWER(10, 3) + value) AS NVARCHAR(4)), 2, 3)

ou alternativement

SUBSTRING(CAST(1000 + value) AS NVARCHAR(4)), 2, 3)

Cela permet d’ajouter la valeur souhaitée à une puissance de 10 suffisamment grande pour générer suffisamment de zéros non significatifs, puis de couper le premier.

L'avantage de cette technique est que le résultat sera toujours de la même longueur, permettant d'utiliser SUBSTRING au lieu de RIGHT, qui n'est pas disponible dans certains langages de requête (comme HQL).

0
Peter Gluck