Função PadLeft no T-SQL

Eu tenho a seguinte tabela A:

id ---- 1 2 12 123 1234 

Preciso deixar os valores de id com o zero:

 id ---- 0001 0002 0012 0123 1234 

Como posso conseguir isso?

Eu acredito que isso pode ser o 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 

Eu não testei a syntax no segundo exemplo. Eu não tenho certeza se isso funciona 100% – pode exigir alguns ajustes – mas transmite a idéia geral de como obter a saída desejada.

EDITAR

Para resolver as questões listadas nos comentários …

@ pkr298 – Sim, o STR só funciona em números … O campo do OP é um ID … daí apenas o número.

@Desolator – Claro que isso não 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 deve, teoricamente, mover os postes da baliza … como o número fica maior, deve sempre trabalhar …. independentemente de seu 1 ou 123456789 …

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

 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 

O SQL Server agora suporta a function FORMAT a partir da versão 2012, portanto:

 SELECT FORMAT(id, '0000') FROM TableA 

vai fazer o truque.

Se o seu id ou coluna estiver em um varchar e representar um número que você converter primeiro:

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

Post antigo, mas talvez isso ajude alguém:

Para completar até acabar com 4 caracteres não-blancos:

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

Para completar até 10:

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

Tente isto:

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

– Por favor, olhe para eles.

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

– Espero que estes ajudem você

Isso funciona para strings, inteiros e numéricos:

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

Onde 4 é o comprimento desejado. Funciona para números com mais de 4 dígitos, retorna string vazia no valor NULL .

Isso é o que eu normalmente uso quando preciso preencher um valor.

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

Eu precisava disso em uma function no servidor SQL e ajustei a resposta de Patrick um pouco.

 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 function:

 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 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. A partir disso podemos subtraí-lo da largura de preenchimento desejada. A repetição retornará null para valores abaixo de 1, então precisamos de ifnull .

Minha solução não é eficiente, mas me ajudou na situação em que os valores (números de cheques bancários e número de ref. Transferência bancária) eram armazenados como varchar onde algumas inputs tinham valores alfanuméricos e eu precisava preencher se o tamanho fosse menor que 6 caracteres.

Pensei em compartilhar se alguém se deparar 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 

A maneira mais eficiente é:

 Select id, LEN(id) From TableA Order by 2,1 The result : id ---- 1 2 12 123 1234