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

J'ai besoin de convertir le champ de données int en nvarchar avec des zéros non significatifs

exemple:

1 conversion en '001'

867 convertir en '000867', etc.

THX.

Ceci est 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 :

SÉLECTIONNEZ dbo.CIntToChar (867, 6) COMME COD_ID

PRODUCTION

000867

Essaye ça: select right('00000' + cast(Your_Field as varchar(5)), 5)

Il obtiendra le résultat en 5 chiffres, ex: 00001, ...., 01234

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')

À utiliser REPLICATEpour ne pas avoir à 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)

PRODUCTION:

0000000123

Pas à High-Jack cette question mais il faut noter que vous devez utiliser (N) VARCHAR au lieu de (N) CHAR type de données.

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

Au-dessus du segment, 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 à partir de SQL 2005

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

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

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

Enfin, vous ne prenez pas en compte le cas où la taille de votre int> le nombre total de chiffres que vous souhaitez compléter (@intLen).

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

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

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

Exemple:

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

Résultat: '000867'

Solution en une seule ligne (en soi ) pour SQL Server 2008 ou supérieur:

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

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

J'ai trouvé un bon article ici :

Remplir une chaîne avec des zéros non significatifs

J'ai besoin de le faire beaucoup de fois lors de la sortie d'une exportation de données de longueur fixe où, par exemple, une colonne numérique fait 9 caractères et vous devez préfixer avec des 0 en tête.

    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 conservera toujours pas les zéros Faites-le simplement dans la couche de présentation ou si vous en avez vraiment besoin dans le SELECT

J'ai eu le même problème, c'est ainsi que j'ai résolu ... Simple et élégant. Le "4" est la longueur de la chaîne, quelle que soit la longueur de l'entier passé, elle sera complétée par des zéros jusqu'à "4".

STUFF(SomeVariableOrField,1,0,REPLICATE('0',4 - LEN(SomeVariableOrField)))

Dans mon cas, je voulais que mon champ ait des 0 en tête dans le champ de 10 caractères (NVARCHAR (10)). Le fichier source n'a pas les 0 principaux nécessaires pour ensuite se joindre à une autre table. Est-ce simplement dû au fait d'être sur SQL Server 2008R2:

Set Field = right (('0000000000' + [Field]), 10) (Impossible d'utiliser Format () car il s'agit d'avant SQL2012)

Effectué cela par rapport aux données existantes. Ainsi, de cette façon, 1 ou 987654321 remplira toujours les 10 espaces avec des 0 en tête.

Comme les nouvelles données sont importées et ensuite vidées dans la table via une base de données Access, je peux utiliser Format ([Field], "0000000000") lors de l'ajout d'Access à la table du serveur SQL pour tous les nouveaux enregistrements.

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

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

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

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

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

L'utilisation RIGHTest 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ù Nest le nombre total de chiffres que vous souhaitez 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)

Ce que cela fait, c'est ajouter la valeur souhaitée à une puissance de 10 suffisamment grande pour générer suffisamment de zéros non significatifs, puis couper le premier 1.

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

Ce travail 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 aidera. Meilleures salutations

Fonctionne dans SQLServer

declare @myNumber int = 123
declare @leadingChar varchar(1) = '0'
declare @numberOfLeadingChars int = 5

select right(REPLICATE ( @leadingChar , @numberOfLeadingChars ) + cast(@myNumber as varchar(max)), @numberOfLeadingChars)

Prendre plaisir

Je me demandais si cela vous serait utile?

declare @val int,@len=800
select replace(str(@val,@len),' ','0')