with Pad uma string com zeros à esquerda por isso é 3 caracteres no SQL Server 2008




sql zero to left (12)

O método seguro:

SELECT REPLACE(STR(n,3),' ','0')

Isso tem a vantagem de retornar a string '***' para n <0 ou n> 999, que é um bom e óbvio indicador de entrada fora dos limites. Os outros métodos listados aqui falharão silenciosamente, truncando a entrada para uma substring de 3 caracteres.

Eu tenho uma seqüência que é de até 3 caracteres quando é criada pela primeira vez no SQL Server 2008 R2.

Eu gostaria de preenchê-lo com zeros à esquerda, portanto, se seu valor original fosse '1', o novo valor seria '001'. Ou, se o valor original for '23', o novo valor é '023'. Ou se o seu valor original for '124', então o novo valor é o mesmo que o valor original.

Estou usando o SQL Server 2008 R2. Como eu faria isso usando o T-SQL?


Eu tive problema semelhante com a coluna de inteiro como entrada quando eu precisava de saída varchar (ou string) de tamanho fixo. Por exemplo, 1 a '01', 12 a '12'. Este código funciona:

SELECT RIGHT(CONCAT('00',field::text),2)

Se a entrada também for uma coluna de varchar, você poderá evitar a peça de conversão.


Embora a questão fosse para o SQL Server 2008 R2, no caso de alguém estar lendo isso com a versão 2012 e acima, desde então, ficou muito mais fácil com o uso do FORMAT .

Você pode passar uma string de formato numérico padrão ou uma string de formato numérico personalizado como o argumento de formato (agradeça a Vadim Ovchinnikov por essa dica).

Para esta pergunta, por exemplo, um código como

DECLARE @myInt INT = 1;
-- One way using a standard numeric format string
PRINT FORMAT(@myInt,'D3');
-- Other way using a custom numeric format string
PRINT FORMAT(@myInt,'00#');

saídas

001
001

Para inteiros, você pode usar a conversão implícita de int para varchar:

SELECT RIGHT(1000 + field, 3)

Eu sei que seu bilhete antigo eu apenas pensei em compartilhá-lo.

Eu encontrei este código procurando uma solução. Não tenho certeza se funciona em todas as versões do MSSQL Eu tenho MSSQL 2016.

declare @value as nvarchar(50) = 23
select REPLACE(STR(CAST(@value AS INT) + 1,4), SPACE(1), '0') as Leadingzero

retorna "0023" O 4 na função STR é o comprimento total incluindo o valor. Os exemplos 4, 23 e 123 terão 4 em STR e a quantidade correta de zeros será adicionada. Você pode aumentar ou diminuir isso. Não há necessidade de obter o comprimento no 23.

Edit: Eu vejo o seu mesmo como post @Anon.


Simples é isso

Gostar:

DECLARE @DUENO BIGINT
SET @DUENO=5

SELECT 'ND'+STUFF('000000',6-LEN(RTRIM(@DueNo))+1,LEN(RTRIM(@DueNo)),RTRIM(@DueNo)) DUENO

Escrevi isso porque eu tinha requisitos para um tamanho específico (9). Almofada à esquerda com o @pattern APENAS quando a entrada precisa de preenchimento. Deve sempre retornar o comprimento definido em @pattern.

declare @charInput as char(50) = 'input'

--always handle NULL :)
set @charInput = isnull(@charInput,'')

declare @actualLength as int = len(@charInput)

declare @pattern as char(50) = '123456789'
declare @prefLength as int = len(@pattern)

if @prefLength > @actualLength
    select Left(Left(@pattern, @prefLength-@actualLength) + @charInput, @prefLength)
else
    select @charInput

Retorna 1234input


Aqui está uma técnica mais geral para preenchimento à esquerda para qualquer largura desejada:

declare @x     int     = 123 -- value to be padded
declare @width int     = 25  -- desired width
declare @pad   char(1) = '0' -- pad character

select right_justified = replicate(
                           @pad ,
                           @width-len(convert(varchar(100),@x))
                           )
                       + convert(varchar(100),@x)

No entanto, se você está lidando com valores negativos e preenchendo com zeros à esquerda, nem esta nem outra técnica sugerida funcionará. Você terá algo parecido com isto:

00-123

[Provavelmente não é o que você queria]

Então ... você terá que pular alguns aros adicionais. Aqui está uma abordagem que irá formatar corretamente os números negativos:

declare @x     float   = -1.234
declare @width int     = 20
declare @pad   char(1) = '0'

select right_justified = stuff(
         convert(varchar(99),@x) ,                            -- source string (converted from numeric value)
         case when @x < 0 then 2 else 1 end ,                 -- insert position
         0 ,                                                  -- count of characters to remove from source string
         replicate(@pad,@width-len(convert(varchar(99),@x)) ) -- text to be inserted
         )

Deve-se notar que as chamadas convert() devem especificar um [n]varchar de comprimento suficiente para manter o resultado convertido com truncamento.


Se o campo já é uma string, isso funcionará

 SELECT RIGHT('000'+ISNULL(field,''),3)

Se você quiser nulos para mostrar como '000'

Pode ser um inteiro - então você iria querer

 SELECT RIGHT('000'+CAST(field AS VARCHAR(3)),3)

Como requerido pela pergunta, esta resposta só funciona se o comprimento for <= 3, se você quiser algo maior, você precisa mudar a constante da string e as duas constantes inteiras para a largura necessária. por exemplo, '0000' and VARCHAR(4)),4


Para aqueles que querem atualizar seus dados existentes, aqui está a consulta:

update SomeEventTable set eventTime=RIGHT('00000'+ISNULL(eventTime, ''),5)

Eu sempre achei o método a seguir muito útil.

REPLICATE('0', 5 - LEN(Job.Number)) + CAST(Job.Number AS varchar) as 'NumberFull'

Para uma abordagem mais dinâmica, tente isso.

declare @val varchar(5)
declare @maxSpaces int
set @maxSpaces = 3
set @val = '3'
select concat(REPLICATE('0',@maxSpaces-len(@val)),@val)




tsql