with - sql zero to left




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

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.

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?


Aqui está uma variante da resposta da Hogan que eu uso no SQL Server Express 2012:

SELECT RIGHT(CONCAT('000', field), 3)

Ao invés de se preocupar se o campo é uma string ou não, eu apenas CONCAT , já que ele irá gerar uma string de qualquer maneira. Além disso, se o campo puder ser NULL , o uso de ISNULL poderá ser necessário para evitar que a função obtenha resultados NULL .

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

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


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.


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.


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

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

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)

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


Use esta função que se adapta a todas as situações.

CREATE FUNCTION dbo.fnNumPadLeft (@input INT, @pad tinyint)
RETURNS VARCHAR(250)
AS BEGIN
    DECLARE @NumStr VARCHAR(250)

    SET @NumStr = LTRIM(@input)

    IF(@pad > LEN(@NumStr))
        SET @NumStr = REPLICATE('0', @Pad - LEN(@NumStr)) + @NumStr;

    RETURN @NumStr;
END

Amostra de saída

SELECT [dbo].[fnNumPadLeft] (2016,10) -- returns 0000002016
SELECT [dbo].[fnNumPadLeft] (2016,5) -- returns 02016
SELECT [dbo].[fnNumPadLeft] (2016,2) -- returns 2016
SELECT [dbo].[fnNumPadLeft] (2016,0) -- returns 2016 

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.





tsql