Función PadLeft en T-SQL

Tengo la siguiente tabla A:

id
----
1
2
12
123
1234

Necesito rellenar los idvalores con ceros a la izquierda :

id
----
0001
0002
0012
0123
1234

¿Cómo puedo conseguir esto?

Creo que esto puede ser lo que estás buscando:

SELECT padded_id = REPLACE(STR(id, 4), SPACE(1), '0') 

FROM tableA

o

SELECT REPLACE(STR(id, 4), SPACE(1), '0') AS [padded_id]

FROM tableA

No he probado la sintaxis en el segundo ejemplo. No estoy seguro de si eso funciona al 100%, puede requerir algunos ajustes, pero transmite la idea general de cómo obtener el resultado deseado.

EDITAR

Para abordar las preocupaciones enumeradas en los comentarios ...

@ pkr298 - Sí, STR solo funciona con números ... El campo del OP es una ID ... por lo tanto, solo un número.

@Desolator - Por supuesto que no funcionará ... el primer parámetro tiene 6 caracteres. Puedes hacer algo como:

SELECT REPLACE(STR(id,
(SELECT LEN(MAX(id)) + 4 FROM tableA)), SPACE(1), '0') AS [padded_id] FROM tableA

esto teóricamente debería mover los postes de la portería ... a medida que el número aumenta, SIEMPRE debería funcionar ... sin importar si es 1 o 123456789 ...

Entonces, si su valor máximo es 123456 ... verá 0000123456 y si su valor mínimo es 1, verá 0000000001

SQL Server ahora admite la función FORMAT a partir de la versión 2012, por lo que:

SELECT FORMAT(id, '0000') FROM TableA

hará el truco.

Si su identificación o columna está en un varchar y representa un número que convierte primero:

SELECT FORMAT(CONVERT(INT,id), '0000') FROM TableA

declare @T table(id int)
insert into @T values
(1),
(2),
(12),
(123),
(1234)

select right('0000'+convert(varchar(4), id), 4)
from @T

Resultado

----
0001
0002
0012
0123
1234

Publicación anterior, pero tal vez esto ayude a alguien:

Para completar hasta terminar con 4 caracteres que no estén en blanco:

SELECT RIGHT ('0000'+COLUMNNAME, 4) FROM TABLENAME;

Para completar hasta las 10:

SELECT RIGHT ('0000000000'+COLUMNNAME, 10) FROM TABLENAME;

En caso de que la columna sea numérica , conviértala a varchar primero con dicho código:

Select RIGHT('0000'+Convert(nvarchar(20), COLUMNNAME), 4)
From TABLENAME

Y para completar hasta el 10 con un campo numérico:

SELECT RIGHT ('0000000000'+Convert(nvarchar(20), COLUMNNAME), 10) FROM TABLENAME;

Prueba esto:

SELECT RIGHT(REPLICATE('0',4)+CAST(Id AS VARCHAR(4)),4) FROM [Table A]

- Por favor, mire estos.

select FORMAT(1, 'd4');
select FORMAT(2, 'd4');
select FORMAT(12, 'd4');
select FORMAT(123, 'd4');
select FORMAT(1234, 'd4');

- espero que estos te ayuden

Esto funciona para cadenas, enteros y numéricos:

SELECT CONCAT(REPLICATE('0', 4 - LEN(id)), id)

Donde 4es la longitud deseada. Funciona para números con más de 4 dígitos, devuelve una cadena vacía en el NULLvalor.

Si alguien todavía está interesado, encontré este artículo en DATABASE.GUIDE:
Left Padding in SQL Server - 3 LPAD () Equivalents

En resumen, hay 3 métodos mencionados en ese artículo.
Digamos que su id = 12 y necesita que se muestre como 0012.

Método 1: use la función RIGHT ()
El primer método usa la función RIGHT () para devolver solo la parte más a la derecha de la cadena, después de agregar algunos ceros a la izquierda.

SELECT RIGHT('00' + '12', 4);

Resultado:
0012

Método 2: use una combinación de RIGHT () y REPLICATE ()
Este método es casi el mismo que el método anterior, con la única diferencia de que simplemente reemplazo los tres ceros con la función REPLICATE ():

SELECT RIGHT(REPLICATE('0', 2) + '12', 4);

Resultado:
0012

Método 3: use una combinación de REPLACE () y STR ()
Este método proviene de un ángulo completamente diferente a los métodos anteriores:

SELECT REPLACE(STR('12', 4),' ','0');

Resultado:
0012

Consulte el artículo, hay un análisis más profundo con ejemplos.

Esto es lo que normalmente uso cuando necesito rellenar un valor.

SET @PaddedValue = REPLICATE('0', @Length - LEN(@OrigValue)) + CAST(@OrigValue as VARCHAR)

Necesitaba esto en una función en el servidor SQL y ajusté un poco la respuesta de Patrick.

declare @dossierId int = 123
declare @padded_id varchar(7)


set @padded_id = REPLACE(
              SPACE(7 - LEN(@dossierId)) + convert(varchar(7), @dossierId), 
              SPACE(1),  
              '0') 

SELECT @dossierId as '@dossierId'
      ,SPACE(LEN(@dossierId)) + convert(varchar(7)
      ,@dossierId) as withSpaces
      ,@padded_id as '@padded_id'

Crear función:

    Create FUNCTION [dbo].[PadLeft]
      (
        @Text NVARCHAR(MAX) ,
        @Replace NVARCHAR(MAX) ,
        @Len INT
      )
RETURNS NVARCHAR(MAX)
AS
    BEGIN 


        DECLARE @var NVARCHAR(MAX) 

        SELECT @var = ISNULL(LTRIM(RTRIM(@Text)) , '')


        RETURN   RIGHT(REPLICATE(@Replace,@Len)+ @var, @Len)


    END

Ejemplo:

Select dbo.PadLeft('123456','0',8)

Creé una función:

CREATE FUNCTION [dbo].[fnPadLeft](@int int, @Length tinyint)
RETURNS varchar(255) 
AS 
BEGIN
    DECLARE @strInt varchar(255)

    SET @strInt = CAST(@int as varchar(255))
    RETURN (REPLICATE('0', (@Length - LEN(@strInt))) + @strInt);
END;

Uso: seleccione dbo.fnPadLeft (123, 10)

Devoluciones: 0000000123

Algo bastante compatible con ODBC, si es necesario, podría ser lo siguiente:

select ifnull(repeat('0', 5 - (floor(log10(FIELD_NAME)) + 1)), '')
        + cast (FIELD as varchar(10))
  from TABLE_NAME

Esto se basa en el hecho de que la cantidad de dígitos para un número de base 10 se puede encontrar por el componente integral de su registro. De esto podemos restarlo del ancho de relleno deseado. La repetición devolverá los nullvalores por debajo de 1, por lo que necesitamos ifnull.

Mi solución no es eficiente, pero me ayudó en una situación en la que los valores (números de cheque bancario y número de referencia de transferencia bancaria) se almacenaron como varchar, donde algunas entradas tenían valores alfanuméricos y tuve que rellenar si la longitud es menor a 6 caracteres.

Pensado para compartir si alguien se encuentra en la misma situación.

declare @minlen int = 6
declare @str varchar(20)

set @str = '123'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 000123

set @str = '1234'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 001234

set @str = '123456'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 123456

set @str = '123456789'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 123456789

set @str = '123456789'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: 123456789


set @str = 'NEFT 123456789'
select case when len(@str) < @minlen then REPLICATE('0',@minlen-len(@str))+@str else @str end
--Ans: NEFT 123456789

Un ejemplo simple sería

    DECLARE @number INTEGER
    DECLARE @length INTEGER
    DECLARE @char   NVARCHAR(10)
    SET @number = 1
    SET @length = 5
    SET @char = '0'

    SELECT FORMAT(@number, replicate(@char, @length))

Creé una función para hacer esto, donde puede especificar la longitud de caracteres de salida deseada:

CREATE FUNCTION [dbo].[udfLeadingZero]
(
        @String VARCHAR(MAX)
,       @Len INT
)
RETURNS VARCHAR(MAX)
BEGIN
    SET @String = RIGHT(REPLICATE('0',@Len)+@String,@Len)
RETURN @String
END
GO

Resultados de ejemplo

La forma más eficiente es:

Select id, LEN(id)
From TableA
Order by 2,1 

The result :
id
----
1
2
12
123
1234