Como converter int em char com zeros à esquerda?

Preciso converter o campo de dados int em nvarchar com zeros à esquerda

exemplo:

1 convertido para '001'

867 converter para '000867', etc.

THX.

Esta é a minha resposta 4 horas depois ...

Eu testei este T-SQL Script e funcionou bem para mim!

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

SELECT RIGHT('000' + CAST(@number1 AS NCHAR(3)), 3 ) AS NUMBER_CONVERTED

SELECT RIGHT('000000' + CAST(@number2 AS NCHAR(6)), 6 ) AS NUMBER_CONVERTED

Eu criei esta função de usuário

Código T-SQL:

CREATE FUNCTION CIntToChar(@intVal BIGINT, @intLen Int) RETURNS nvarchar(20)
AS
BEGIN

    -- BIGINT = 2^63-1 (9,223,372,036,854,775,807) Max size number

    -- @intlen contains the string size to return
    IF @intlen > 20
       SET @intlen = 20

    RETURN REPLICATE('0',@intLen-LEN(RTRIM(CONVERT(nvarchar(20),@intVal)))) 
        + CONVERT(nvarchar(20),@intVal)

END

Exemplo:

SELECT dbo.CIntToChar (867, 6) AS COD_ID

RESULTADO

000867

Experimente isto: select right('00000' + cast(Your_Field as varchar(5)), 5)

Ele obterá o resultado em 5 dígitos, ex: 00001, ...., 01234

Você também pode usar a função FORMAT () introduzida no SQL Server 2012 . http://technet.microsoft.com/library/hh213505.aspx

DECLARE @number1 INT, @number2 INT

SET @number1 = 1
SET @number2 = 867

SELECT FORMAT(@number1, 'd10')
SELECT FORMAT(@number2, 'd10')

Use REPLICATEpara que você não precise codificar todos os zeros à esquerda:

DECLARE @InputStr int
       ,@Size     int
SELECT @InputStr=123
      ,@Size=10

PRINT REPLICATE('0',@Size-LEN(RTRIM(CONVERT(varchar(8000),@InputStr)))) + CONVERT(varchar(8000),@InputStr)

RESULTADO:

0000000123

Não para High-Jack esta pergunta, mas a nota precisa ser feita que você precisa usar (N) VARCHAR em vez de (N) CHAR tipo de dados.

RIGHT('000' + CAST(@number1 AS NCHAR(3)), 3 )

O segmento acima não produzirá a resposta correta do SQL 2005

RIGHT('000' + CAST(@number1 AS NVARCHAR(3)), 3 )

Acima do segmento, produzirá a resposta desejada do SQL 2005

O varchar fornecerá o comprimento de prefixo desejado imediatamente. Onde o tipo de dados de comprimento fixo exigirá designação e ajustes de comprimento.

Eu gosto de usar

DECLARE @Length int
DECLARE @Number int
SET @Length = 9
SET @Number = 4

select right( POWER(10, @Length) + @Number, @Length)

isso me dá

000000004

O tipo de dados "int" não pode ter mais de 10 dígitos, além disso, a função "Len ()" funciona em ints, portanto, não há necessidade de converter o int em uma string antes de chamar a função len ().

Por último, você não está levando em consideração o caso em que o tamanho do seu int> o número total de dígitos que você deseja preencher (@intLen).

Portanto, uma solução mais concisa / correta é:

CREATE FUNCTION rf_f_CIntToChar(@intVal Int, @intLen Int) RETURNS nvarchar(10)
AS
BEGIN
    IF @intlen > 20 SET @intlen = 20
    IF @intlen < LEN(@intVal) RETURN RIGHT(CONVERT(nvarchar(10), @intVal), @intlen)
    RETURN REPLICATE('0', @intLen - LEN(@intVal)) + CONVERT(nvarchar(10), @intVal)
END

Não é muito elegante, mas adiciono um valor definido com o mesmo número de zeros à esquerda que desejo ao numérico que desejo converter e uso a função DIREITA.

Exemplo:

SELECT RIGHT(CONVERT(CHAR(7),1000000 + @number2),6)

Resultado: '000867'

Solução de uma linha ( per se ) para SQL Server 2008 ou superior:

DECLARE @DesiredLenght INT = 20;
SELECT 
    CONCAT(
        REPLICATE(
            '0',
            (@DesiredLenght-LEN([Column])) * (1+SIGN(@DesiredLenght-LEN([Column])) / 2) ),
        [Column])
FROM Table;

A multiplicação por SIGNexpressão é equivalente a MAX(0, @DesiredLenght-LEN([Column])). O problema é que MAX()aceita apenas um argumento ...

Encontrei um bom artigo aqui :

Preenchendo uma string com zeros à esquerda

Eu preciso fazer isso muitas vezes ao gerar uma exportação de dados de comprimento fixo, onde, por exemplo, uma coluna numérica tem 9 caracteres e você precisa prefixar com zeros à esquerda.

    select right('000' + convert(varchar(3),id),3) from table

    example
    declare @i int
    select @i =1

select right('000' + convert(varchar(3),@i),3)

BTW se for uma coluna int então ainda não vai manter os zeros Basta fazê-lo na camada de apresentação ou se realmente precisar no SELECT

Teve mesmo problema, foi assim que resolvi ... Simples e elegante. O "4" é o comprimento que a string deve ter, não importa o comprimento do inteiro passado, ele será preenchido com zeros até "4".

STUFF(SomeVariableOrField,1,0,REPLICATE('0',4 - LEN(SomeVariableOrField)))

No meu caso, eu queria que meu campo tivesse zeros à esquerda em um campo de 10 caracteres (NVARCHAR (10)). O arquivo de origem não tem os zeros iniciais necessários para se juntar a outra tabela. Fiz isso simplesmente por estar no SQL Server 2008R2:

Defina Field = right (('0000000000' + [Field]), 10) (Não é possível usar Format (), pois isso é anterior ao SQL2012)

Executado isso contra os dados existentes. Portanto, desta forma, 1 ou 987654321 ainda preencherá todos os 10 espaços com zeros à esquerda.

Como os novos dados estão sendo importados e despejados na tabela por meio de um banco de dados do Access, posso usar o Formato ([Campo], "0000000000") ao anexar do Access à tabela do servidor SQL para quaisquer novos registros.

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

- Sem o 'RTRIM', o valor retornado é 3__!!!

SELECT RIGHT('000' + RTRIM(CAST(@number1 AS NCHAR(3)), 3 )) AS NUMBER_CONVERTED

- Sem o 'RTRIM', o valor retornado é 867___!!!

SELECT RIGHT('000000' + RTRIM(CAST(@number2 AS NCHAR(6)), 6 )) AS NUMBER_CONVERTED

Usar RIGHTé uma boa opção, mas você também pode fazer o seguinte:

SUBSTRING(CAST((POWER(10, N) + value) AS NVARCHAR(N + 1)), 2, N)

onde Né o número total de dígitos que você deseja exibir. Portanto, para um valor de 3 dígitos com zeros à esquerda ( N = 3):

SUBSTRING(CAST((POWER(10, 3) + value) AS NVARCHAR(4)), 2, 3)

ou alternadamente

SUBSTRING(CAST(1000 + value) AS NVARCHAR(4)), 2, 3)

O que isso está fazendo é adicionar o valor desejado a uma potência de 10 grande o suficiente para gerar zeros à esquerda suficientes e, em seguida, cortar o 1 à esquerda.

A vantagem desta técnica é que o resultado terá sempre o mesmo comprimento, permitindo o uso de em SUBSTRINGvez de RIGHT, o que não está disponível em algumas linguagens de consulta (como HQL).

Isso funciona para mim em MYSQL:

FUNCTION leadingZero(format VARCHAR(255), num VARCHAR(255))
  RETURNS varchar(255) CHARSET utf8
BEGIN
  return CONCAT(SUBSTRING(format,1,LENGTH(format)-LENGTH(num)),num);
END

Por exemplo:

leadingZero('000',999); returns '999'
leadingZero('0000',999); returns '0999'
leadingZero('xxxx',999); returns 'x999'

Espero que isso ajude. Cumprimentos

Funciona em SQLServer

declare @myNumber int = 123
declare @leadingChar varchar(1) = '0'
declare @numberOfLeadingChars int = 5

select right(REPLICATE ( @leadingChar , @numberOfLeadingChars ) + cast(@myNumber as varchar(max)), @numberOfLeadingChars)

Aproveitar

Eu estava me perguntando, isso seria útil para você?

declare @val int,@len=800
select replace(str(@val,@len),' ','0')