Função PadLeft em T-SQL

Eu tenho a seguinte tabela A:

id
----
1
2
12
123
1234

Preciso preencher com o botão esquerdo os idvalores com zero:

id
----
0001
0002
0012
0123
1234

Como posso conseguir isso?

Eu acredito que pode ser isso que você está procurando:

SELECT padded_id = REPLACE(STR(id, 4), SPACE(1), '0') 

FROM tableA

ou

SELECT REPLACE(STR(id, 4), SPACE(1), '0') AS [padded_id]

FROM tableA

Não testei a sintaxe do segundo exemplo. Não tenho certeza se isso funciona 100% - pode exigir alguns ajustes - mas transmite a ideia geral de como obter a saída desejada.

EDITAR

Para abordar as preocupações listadas nos comentários ...

@ pkr298 - Sim, STR só funciona com números ... O campo do OP é um ID ... portanto, apenas número.

@Desolator - Claro que não vai funcionar ... o primeiro parâmetro tem 6 caracteres. Você pode fazer algo como:

SELECT REPLACE(STR(id,
(SELECT LEN(MAX(id)) + 4 FROM tableA)), SPACE(1), '0') AS [padded_id] FROM tableA

isso deveria, teoricamente, mover os postes da baliza ... conforme o número aumenta, ele SEMPRE deve funcionar .... independentemente se for 1 ou 123456789 ...

Portanto, se seu valor máximo for 123456 ... você verá 0000123456 e se seu valor mínimo for 1, você verá 0000000001

O SQL Server agora oferece suporte à função FORMAT a partir da versão 2012, portanto:

SELECT FORMAT(id, '0000') FROM TableA

vai fazer o truque.

Se sua id ou coluna estiver em a varchare representar um número que você converte primeiro:

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

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

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

Resultado

----
0001
0002
0012
0123
1234

Postagem antiga, mas talvez isso ajude alguém:

Para concluir até que termine com 4 caracteres não em branco:

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

Para completar até 10:

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

Caso a coluna seja numérica , converta-a primeiro em varchar com o seguinte código:

Select RIGHT('0000'+Convert(nvarchar(20), COLUMNNAME), 4)
From TABLENAME

E para completar até 10 com um campo numérico:

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

Experimente isto:

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

- Por favor, olhe para estes.

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

- Espero que isso te ajude

Isso funciona para strings, inteiros e numéricos:

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

Onde 4está o comprimento desejado. Funciona para números com mais de 4 dígitos, retorna uma string vazia no NULLvalor.

Se alguém ainda estiver interessado, encontrei este artigo em DATABASE.GUIDE:
Preenchimento esquerdo no SQL Server - 3 LPAD () equivalentes

Resumindo, existem 3 métodos mencionados nesse artigo.
Digamos que seu id = 12 e você precise que ele seja exibido como 0012.

Método 1 - Use a função RIGHT ()
O primeiro método usa a função RIGHT () para retornar apenas a parte mais à direita da string, após adicionar alguns zeros à esquerda.

SELECT RIGHT('00' + '12', 4);

Resultado:
0012

Método 2 - Use uma combinação de RIGHT () e REPLICATE ()
Este método é quase o mesmo que o método anterior, com a única diferença que eu simplesmente substituo os três zeros pela função REPLICATE ():

SELECT RIGHT(REPLICATE('0', 2) + '12', 4);

Resultado:
0012

Método 3 - Use uma combinação de REPLACE () e STR ()
Este método vem de um ângulo completamente diferente dos métodos anteriores:

SELECT REPLACE(STR('12', 4),' ','0');

Resultado:
0012

Confira o artigo, há uma análise mais aprofundada com exemplos.

É o que normalmente uso quando preciso preencher um valor.

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

Eu precisava disso em uma função no servidor SQL e ajustei um pouco a resposta 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'

Criar Função:

    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

Exemplo:

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

Eu criei uma função:

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;

Use: selecione dbo.fnPadLeft (123, 10)

Retorna: 0000000123

Algo bastante compatível com ODBC, se necessário, pode ser o seguinte:

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

Isso se baseia no fato de que a quantidade de dígitos para um número de base 10 pode ser encontrada pelo componente integral de seu log. Disto podemos subtraí-lo da largura de preenchimento desejada. A repetição retornará nullpara valores abaixo de 1, então precisamos ifnull.

Minha solução não é eficiente, mas me ajudou em situações em que os valores (números de cheque bancário e número de referência de transferência eletrônica) foram armazenados como varchar onde algumas entradas tinham valores alfanuméricos com eles e eu tive que preencher se o comprimento for menor que 6 caracteres.

Pensei em compartilhar se alguém se deparasse com a mesma situação

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

Um exemplo simples seria

    DECLARE @number INTEGER
    DECLARE @length INTEGER
    DECLARE @char   NVARCHAR(10)
    SET @number = 1
    SET @length = 5
    SET @char = '0'

    SELECT FORMAT(@number, replicate(@char, @length))

Criei uma função para fazer isso, onde você pode especificar o comprimento de caractere de saída desejado:

CREATE FUNCTION [dbo].[udfLeadingZero]
(
        @String VARCHAR(MAX)
,       @Len INT
)
RETURNS VARCHAR(MAX)
BEGIN
    SET @String = RIGHT(REPLICATE('0',@Len)+@String,@Len)
RETURN @String
END
GO

Resultados de exemplo

A maneira mais eficiente é:

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

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