Come convertire int in char con zeri iniziali?

Devo convertire int datafield in nvarchar con zeri iniziali

esempio:

1 converti in '001'

867 convertito in "000867", ecc.

grazie.

Questa è la mia risposta 4 ore dopo ...

Ho provato questo script T-SQL e funziona bene per me!

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

Ho creato questa funzione utente

Codice 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

Esempio :

SELEZIONA dbo.CIntToChar (867, 6) COME COD_ID

PRODUZIONE

000867

Prova questo: select right('00000' + cast(Your_Field as varchar(5)), 5)

Otterrà il risultato in 5 cifre, es: 00001, ...., 01234

È inoltre possibile utilizzare la funzione FORMAT () introdotta in 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')

Usa in REPLICATEmodo da non dover codificare tutti gli zeri iniziali:

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

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

PRODUZIONE:

0000000123

Non per High-Jack questa domanda, ma è necessario prendere nota che è necessario utilizzare (N) VARCHAR invece di (N) CHAR tipo di dati.

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

Il segmento sopra, non produrrà la risposta corretta da SQL 2005

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

Il segmento sopra, produrrà la risposta desiderata da SQL 2005

Il varchar ti fornirà la lunghezza del prefisso desiderata al volo. Dove il tipo di dati a lunghezza fissa richiederà la designazione e le regolazioni della lunghezza.

Mi piace usare

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

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

questo mi dà

000000004

Il tipo di dati "int" non può essere più di 10 cifre, inoltre la funzione "Len ()" funziona sugli int, quindi non è necessario convertire l'int in una stringa prima di chiamare la funzione len ().

Infine, non stai prendendo in considerazione il caso in cui la dimensione del tuo int> il numero totale di cifre a cui vuoi che venga riempito (@intLen).

Pertanto, una soluzione più concisa / corretta è:

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

Non molto elegante, ma aggiungo un valore impostato con lo stesso numero di zeri iniziali che desidero al numerico che voglio convertire e utilizzo la funzione DESTRA.

Esempio:

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

Risultato: "000867"

Soluzione a una riga (di per sé ) per SQL Server 2008 o versioni successive:

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

La moltiplicazione per SIGNespressione è equivalente a MAX(0, @DesiredLenght-LEN([Column])). Il problema è che MAX()accetta solo un argomento ...

Ho trovato un buon articolo qui :

Riempire una stringa con zeri iniziali

Ho bisogno di farlo molte volte durante l'output di un'esportazione di dati a lunghezza fissa in cui, ad esempio, una colonna numerica è lunga 9 caratteri ed è necessario anteporre il prefisso con gli 0 iniziali.

    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èuna colonna int allora non manterrà ancora gli zeri Fallo semplicemente nel livello di presentazione o se ne hai davvero bisogno nel SELEZIONA

Ho avuto lo stesso problema, è così che ho risolto ... Semplice ed elegante. Il "4" è la lunghezza della stringa, indipendentemente dalla lunghezza dell'intero passato, si riempirà con zero fino a "4".

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

Nel mio caso volevo che il mio campo avesse 0 iniziali in un campo di 10 caratteri (NVARCHAR (10)). Il file sorgente non ha gli 0 iniziali necessari per unirsi a un'altra tabella. Lo ha fatto semplicemente perché si trovava su SQL Server 2008 R2:

Set Field = right (('0000000000' + [Field]), 10) (Can't use Format () as this is pre SQL2012)

Eseguito rispetto ai dati esistenti. Quindi in questo modo 1 o 987654321 riempirà ancora tutti i 10 spazi con 0 iniziali.

Poiché i nuovi dati vengono importati e quindi scaricati nella tabella tramite un database di Access, sono in grado di utilizzare Formato ([Campo], "0000000000") quando si aggiunge da Access alla tabella del server SQL per eventuali nuovi record.

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

- Senza "RTRIM", il valore restituito è 3__!!!

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

- Senza 'RTRIM', il valore restituito è 867___!!!

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

L'utilizzo RIGHTè una buona opzione ma puoi anche fare quanto segue:

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

dove Nè il numero totale di cifre che si desidera visualizzare. Quindi per un valore di 3 cifre con zeri iniziali ( N = 3):

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

o alternativamente

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

Ciò che sta facendo è aggiungere il valore desiderato a una potenza di 10 abbastanza grande da generare abbastanza zeri iniziali, quindi tagliare l'1 iniziale.

Il vantaggio di questa tecnica è che il risultato sarà sempre della stessa lunghezza, consentendo l'uso al SUBSTRINGposto di RIGHT, che non è disponibile in alcuni linguaggi di query (come HQL).

Questo funziona per me in 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

Per esempio:

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

Spero che questo ti aiuti. I migliori saluti

Funziona in 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)

Godere

Mi chiedevo, ti sarebbe utile?

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