Rellene una cadena con ceros a la izquierda para que tenga 3 caracteres en SQL Server 2008

Tengo una cadena de hasta 3 caracteres cuando se creó por primera vez en SQL Server 2008 R2.

Me gustaría rellenarlo con ceros a la izquierda, por lo que si su valor original era '1', el nuevo valor sería '001'. O si su valor original era '23', el nuevo valor es '023'. O si su valor original es '124', entonces el nuevo valor es el mismo que el valor original.

Estoy usando SQL Server 2008 R2. ¿Cómo haría esto usando T-SQL?

Si el campo ya es una cadena, esto funcionará

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

Si desea que los valores nulos se muestren como '000'

Puede ser un número entero, entonces usted querría

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

Como lo requiere la pregunta, esta respuesta solo funciona si la longitud <= 3, si desea algo más grande, necesita cambiar la constante de cadena y las dos constantes enteras al ancho necesario. p.ej'0000' and VARCHAR(4)),4

Aunque la pregunta era para SQL Server 2008 R2, en caso de que alguien esté leyendo esto con la versión 2012 y superior, desde entonces se hizo mucho más fácil con el uso de FORMAT .

Puede pasar una cadena de formato numérico estándar o una cadena de formato numérico personalizado como argumento de formato (gracias a Vadim Ovchinnikov por esta pista).

Para esta pregunta, por ejemplo, un 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#');

salidas

001
001

El método seguro:

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

Esto tiene la ventaja de devolver la cadena '***'para n <0 or n> 999, que es un indicador agradable y obvio de entrada fuera de los límites. Los otros métodos enumerados aquí fallarán en silencio al truncar la entrada a una subcadena de 3 caracteres.

Aquí hay una técnica más general para el relleno izquierdo a cualquier ancho deseado:

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)

Sin embargo, si se trata de valores negativos y rellena con ceros a la izquierda, ni esta ni ninguna otra técnica sugerida funcionarán. Obtendrás algo parecido a esto:

00-123

[Probablemente no lo que querías]

Entonces ... tendrás que saltar algunos aros adicionales. Aquí hay un enfoque que formateará correctamente los 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
         )

Se debe tener en cuenta que las convert()llamadas deben especificar una [n]varcharde longitud suficiente para contener el resultado convertido con truncamiento.

Aquí hay una variante de la respuesta de Hogan que uso en SQL Server Express 2012:

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

En lugar de preocuparme si el campo es una cadena o no, lo hago CONCAT, ya que de todos modos generará una cadena. Además, si el campo puede ser un NULL, ISNULLpuede ser necesario usar para evitar que la función obtenga NULLresultados.

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

Siempre he encontrado que el siguiente método es muy útil.

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

Use esta función que se adapta a cada situación.

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

Salida de muestra

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 

Para aquellos que desean actualizar sus datos existentes aquí está la consulta:

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

Para enteros, puede usar la conversión implícita de int a varchar:

SELECT RIGHT(1000 + field, 3)

Sé que es un boleto viejo, solo pensé en compartirlo.

Encontré este código buscando una solución. No estoy seguro si funciona en todas las versiones de MSSQL Tengo MSSQL 2016.

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

devuelve "0023" El 4 en la función STR es la longitud total, incluido el valor. Los ejemplos 4, 23 y 123 tendrán 4 en STR y se agregará la cantidad correcta de ceros. Puedes aumentarlo o disminuirlo. No es necesario obtener la longitud en el 23.

Editar: veo que es lo mismo que @Anon post.

Prueba esto con una longitud fija.

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

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

Tuve un problema similar con la columna entera como entrada cuando necesitaba una salida varchar (o cadena) de tamaño fijo. Por ejemplo, 1 a '01', 12 a '12'. Este código funciona:

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

Si la entrada también es una columna de varchar, puede evitar la parte de fundición.

Para un enfoque más dinámico intente esto.

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

Escribí esto porque tenía requisitos para una longitud específica (9). Rellena la izquierda con @pattern SOLO cuando la entrada necesita relleno. Siempre debe devolver la longitud definida en @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

Devuelve 1234input

Simple es que

Me gusta:

DECLARE @DUENO BIGINT
SET @DUENO=5

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

Vine aquí específicamente para averiguar cómo podría convertir mi timezoneoffset en una cadena de zona horaria para convertir fechas a DATETIMEOFFSET en SQL Server 2008. Bruto, pero necesario.

Por lo tanto, necesito 1 método que haga frente a los números negativos y positivos, formateándolos a dos caracteres con un cero a la izquierda si es necesario. La respuesta de Anons me acercó, pero los valores negativos de zona horaria saldrían como0-5 lugar de los requeridos-05

Entonces, con un pequeño ajuste en su respuesta, esto funciona para todas las conversiones de hora de zona horaria

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'

Creé esta función que atiende a bigint y un cero inicial u otro carácter único (máximo 20 caracteres devueltos) y permite una longitud de resultados menor que la longitud del número de entrada:

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,' ')