Riempi una stringa con zeri iniziali in modo che sia lunga 3 caratteri in SQL Server 2008

Ho una stringa lunga fino a 3 caratteri quando viene creata per la prima volta in SQL Server 2008 R2.

Vorrei riempirlo con zeri iniziali, quindi se il suo valore originale fosse "1", il nuovo valore sarebbe "001". O se il suo valore originale era "23", il nuovo valore è "023". O se il suo valore originale è "124", il nuovo valore è uguale al valore originale.

Sto usando SQL Server 2008 R2. Come lo farei usando T-SQL?

Se il campo è già una stringa, funzionerà

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

Se si desidera che i null vengano visualizzati come '000'

Potrebbe essere un numero intero, quindi vorresti

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

Come richiesto dalla domanda, questa risposta funziona solo se la lunghezza <= 3, se si desidera qualcosa di più grande, è necessario modificare la costante di stringa e le due costanti di intero alla larghezza necessaria. per esempio'0000' and VARCHAR(4)),4

Sebbene la domanda fosse per SQL Server 2008 R2, nel caso qualcuno lo stia leggendo con la versione 2012 e successive, da allora è diventato molto più facile con l'uso di FORMAT .

Puoi passare una stringa di formato numerico standard o una stringa di formato numerico personalizzata come argomento del formato (grazie a Vadim Ovchinnikov per questo suggerimento).

Per questa domanda, ad esempio, un codice come

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#');

uscite

001
001

Il metodo sicuro:

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

Ciò ha il vantaggio di restituire la stringa '***'per n <0 o n> 999, che è un indicatore piacevole ed evidente dell'input fuori dai limiti. Gli altri metodi elencati qui falliranno silenziosamente troncando l'input su una sottostringa di 3 caratteri.

Ecco una tecnica più generale per l'imbottitura a sinistra di qualsiasi larghezza desiderata:

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)

Tuttavia, se hai a che fare con valori negativi e il riempimento con zero iniziali, né questo, né altre tecniche suggerite funzioneranno. Otterrai qualcosa che assomiglia a questo:

00-123

[Probabilmente non quello che volevi]

Quindi ... dovrai saltare alcuni cerchi aggiuntivi Ecco un approccio che formatterà correttamente i numeri negativi:

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
         )

Si noti che le convert()chiamate devono specificare una [n]varcharlunghezza sufficiente per contenere il risultato convertito con troncamento.

Ecco una variante della risposta di Hogan che utilizzo in SQL Server Express 2012:

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

Invece di preoccuparmi se il campo è una stringa o no, lo accetto CONCATe basta , poiché emetterà comunque una stringa. Inoltre, se il campo può essere un NULL, ISNULLpotrebbe essere necessario utilizzare per evitare che la funzione ottenga NULLrisultati.

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

Ho sempre trovato molto utile il seguente metodo.

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

Utilizzare questa funzione adatta a ogni situazione.

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

Uscita campione

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 

Per coloro che desiderano aggiornare i loro dati esistenti ecco la query:

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

Per i numeri interi è possibile utilizzare la conversione implicita da int a varchar:

SELECT RIGHT(1000 + field, 3)

Conosco il suo vecchio biglietto, ho solo pensato di condividerlo.

Ho trovato questo codice alla ricerca di una soluzione. Non sono sicuro che funzioni su tutte le versioni di MSSQL. Ho MSSQL 2016.

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

restituisce "0023" Il 4 nella funzione STR è la lunghezza totale compreso il valore. Gli esempi 4, 23 e 123 avranno tutti 4 in STR e verrà aggiunta la quantità corretta di zeri. Puoi aumentarlo o diminuirlo. Non c'è bisogno di ottenere la lunghezza sul 23.

Modifica: vedo che è uguale al post @Anon.

Prova questo con lunghezza fissa.

select right('000000'+'123',5)

select REPLICATE('0', 5 - LEN(123)) + '123'

Ho avuto un problema simile con la colonna intera come input quando avevo bisogno di output varchar (o stringa) di dimensioni fisse. Ad esempio, da 1 a '01', da 12 a '12'. Questo codice funziona:

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

Se l'input è anche una colonna di varchar, puoi evitare la parte di casting.

Per un approccio più dinamico prova questo.

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

Ho scritto questo perché avevo i requisiti per una lunghezza specifica (9). Riempie la sinistra con @pattern SOLO quando l'ingresso necessita di riempimento. Dovrebbe sempre restituire la lunghezza definita in @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

Restituisce 1234 input

È semplice

Piace:

DECLARE @DUENO BIGINT
SET @DUENO=5

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

Sono venuto qui specificamente per capire come convertire il mio fuso orario in una stringa di fuso orario per convertire le date in DATETIMEOFFSET in SQL Server 2008. Lordo, ma necessario.

Quindi ho bisogno di 1 metodo per far fronte a numeri negativi e positivi, formattandoli su due caratteri con uno zero iniziale, se necessario. La risposta di Anons mi ha avvicinato, ma i valori di fuso orario negativi sarebbero emersi come0-5 piuttosto che quelli richiesti-05

Quindi, con un po 'di ottimizzazione sulla sua risposta, questo funziona per tutte le conversioni dell'ora del fuso orario

DECLARE @n INT = 13 -- Works with -13, -5, 0, 5, etc
SELECT CASE 
    WHEN @n < 0 THEN '-' + REPLACE(STR(@n * -1 ,2),' ','0') 
    ELSE '+' + REPLACE(STR(@n,2),' ','0') END + ':00'

Ho creato questa funzione che si rivolge a bigint e uno zero iniziale o altro carattere singolo (restituiti max 20 caratteri) e consente una lunghezza dei risultati inferiore alla lunghezza del numero di input:

create FUNCTION fnPadNum (
  @Num BIGINT --Number to be padded, @sLen BIGINT --Total length of results , @PadChar varchar(1))
  RETURNS VARCHAR(20)
  AS
  --Pads bigint with leading 0's
            --Sample:  "select dbo.fnPadNum(201,5,'0')" returns "00201"
            --Sample:  "select dbo.fnPadNum(201,5,'*')" returns "**201"
            --Sample:  "select dbo.fnPadNum(201,5,' ')" returns "  201"
   BEGIN
     DECLARE @Results VARCHAR(20)
     SELECT @Results = CASE 
     WHEN @sLen >= len(ISNULL(@Num, 0))
     THEN replicate(@PadChar, @sLen - len(@Num)) + CAST(ISNULL(@Num, 0) AS VARCHAR)
     ELSE CAST(ISNULL(@Num, 0) AS VARCHAR)
     END

     RETURN @Results
     END
     GO

     --Usage:
      SELECT dbo.fnPadNum(201, 5,'0')
      SELECT dbo.fnPadNum(201, 5,'*')
      SELECT dbo.fnPadNum(201, 5,' ')