Fonction PadLeft dans T-SQL

declare @T table(id int)
insert into @T values
(1),
(2),
(12),
(123),
(1234)

select right('0000'+convert(varchar(4), id), 4)
from @T

Résultat

----
0001
0002
0012
0123
1234

SQL Server prend désormais en charge la fonction FORMAT à partir de la version 2012, donc:

SELECT FORMAT(id, '0000') FROM TableA

Fera l'affaire.

Si votre id ou colonne est dans un varchar et représente un nombre que vous convertissez en premier:

SELECT FORMAT(CONVERT(INT,id), '0000') FROM TableA

Ancien post, mais peut-être que cela aide quelqu'un:

Pour terminer jusqu'à ce qu'il se termine avec 4 caractères non-blancs:

SELECT RIGHT ('0000'+COLUMNNAME, 4) FROM TABLENAME;

Pour terminer jusqu'à 10:

SELECT RIGHT ('0000000000'+COLUMNNAME, 10) FROM TABLENAME;

Essayez ceci:

SELECT RIGHT(REPLICATE('0',4)+CAST(Id AS VARCHAR(4)),4) FROM [Table A]

-- S'il vous plaît regarder dans ces.

select FORMAT(1, 'd4');
select FORMAT(2, 'd4');
select FORMAT(12, 'd4');
select FORMAT(123, 'd4');
select FORMAT(1234, 'd4');

-- j'espère que ceux-ci vous aideront

Cela fonctionne pour les chaînes, entiers et numériques:

SELECT CONCAT(REPLICATE('0', 4 - LEN(id)), id)

Où 4 est la longueur désirée. Fonctionne pour les nombres avec plus de 4 chiffres, renvoie une chaîne vide sur la valeur NULL.

C'est ce que j'utilise normalement quand j'ai besoin de pad une valeur.

SET @PaddedValue = REPLICATE('0', @Length - LEN(@OrigValue)) + CAST(@OrigValue as VARCHAR)

J'en avais besoin dans une fonction sur SQL server et j'ai ajusté un peu la réponse de Patrick.

declare @dossierId int = 123
declare @padded_id varchar(7)


set @padded_id = REPLACE(
              SPACE(7 - LEN(@dossierId)) + convert(varchar(7), @dossierId), 
              SPACE(1),  
              '0') 

SELECT @dossierId as '@dossierId'
      ,SPACE(LEN(@dossierId)) + convert(varchar(7)
      ,@dossierId) as withSpaces
      ,@padded_id as '@padded_id'

Créer Une Fonction:

    Create FUNCTION [dbo].[PadLeft]
      (
        @Text NVARCHAR(MAX) ,
        @Replace NVARCHAR(MAX) ,
        @Len INT
      )
RETURNS NVARCHAR(MAX)
AS
    BEGIN 


        DECLARE @var NVARCHAR(MAX) 

        SELECT @var = ISNULL(LTRIM(RTRIM(@Text)) , '')


        RETURN   RIGHT(REPLICATE(@Replace,@Len)+ @var, @Len)


    END

Exemple:

Select dbo.PadLeft('123456','0',8)

J'ai créé une fonction:

CREATE FUNCTION [dbo].[fnPadLeft](@int int, @Length tinyint)
RETURNS varchar(255) 
AS 
BEGIN
    DECLARE @strInt varchar(255)

    SET @strInt = CAST(@int as varchar(255))
    RETURN (REPLICATE('0', (@Length - LEN(@strInt))) + @strInt);
END;

Utilisation: sélectionnez dbo.fnPadLeft (123, 10)

Renvoie: 0000000123

Quelque chose d'assez conforme à ODBC si nécessaire pourrait être le suivant:

select ifnull(repeat('0', 5 - (floor(log10(FIELD_NAME)) + 1)), '')
        + cast (FIELD as varchar(10))
  from TABLE_NAME

Cela repose sur le fait que la quantité de chiffres pour un nombre de base-10 peut être trouvée par la composante intégrale de son journal. De cela, nous pouvons le soustraire de la largeur de remplissage désirée. Repeat retournera null pour les valeurs inférieures à 1, nous avons donc besoin de ifnull.

Ma solution n'est pas efficace mais m'a aidé dans la situation où les valeurs (numéros de chèque bancaire et virement bancaire réf.) ont été stockés comme varchar où certaines entrées avaient des valeurs alphanumériques avec eux et j'ai dû pad si la longueur est inférieure à 6 caractères.

Pensé à partager si quelqu'un tombe sur la même situation

declare @minlen int = 6
declare @str varchar(20)

set @str = '123'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 000123

set @str = '1234'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 001234

set @str = '123456'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 123456

set @str = '123456789'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 123456789

set @str = '123456789'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 123456789


set @str = 'NEFT 123456789'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: NEFT 123456789

Un moyen plus efficace est:

Select id, LEN(id)
From TableA
Order by 2,1 

The result :
id
----
1
2
12
123
1234