izquierda - rellenar con espacios a la derecha sql server

Rellene una cadena con ceros iniciales para que tenga 3 caracteres en SQL Server 2008

Question

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

Me gustaría rellenarlo con ceros iniciales, por lo que si su valor original fuera ''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'', el nuevo valor es el mismo que el valor original.

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

Answer 1

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 está tratando con valores negativos y rellenando con ceros iniciales, ni esta, ni ninguna otra técnica sugerida funcionarán. Obtendrás algo que se ve así:

00-123

[Probablemente no es lo que querías]

Entonces ... tendrás que saltar a través de algunos aros adicionales. Este es 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 llamadas a convert() deben especificar una [n]varchar de longitud suficiente para retener el resultado convertido con el truncamiento.

Answer 2

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, simplemente lo CONCAT , ya que de todos modos dará salida a una cadena. Además, si el campo puede ser NULL , se puede requerir el uso de ISNULL para evitar que la función obtenga resultados NULL .

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

Answer 3

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 sugerencia).

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

Answer 4

Escribí esto porque tenía requisitos para una longitud específica (9). Rellene la izquierda con @pattern SOLAMENTE cuando la entrada necesite 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

Answer 5

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

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

Answer 6

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

SELECT RIGHT(1000 + field, 3)

Answer 7

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)

Answer 8

Sé que su boleto viejo solo pensé en compartirlo.

Encontré este código buscando una solución. No estoy seguro de 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 aumentarla o disminuirla. No hay necesidad de obtener la longitud en el 23.

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

Answer 9

Si el campo ya es una cadena, esto funcionará.

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

Si quieres que los nulos se muestren como ''000''

Podría ser un entero, entonces querrías

 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 de enteros al ancho necesario. por ejemplo, ''0000'' and VARCHAR(4)),4

Answer 10

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

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

Answer 11

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

Answer 12

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

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

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

Answer 13

Utilice esta función que se adapte 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 

Answer 14

El método seguro:

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

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