¿Cómo convertir int a char con ceros a la izquierda?

Necesito convertir int datafield a nvarchar con ceros a la izquierda

ejemplo:

1 convertir a '001'

867 convertir a '000867', etc.

Gracias.

Esta es mi respuesta 4 horas después ...

¡Probé este script T-SQL y funcionó bien para mí!

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

Creé esta función de usuario

Código 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

Ejemplo:

SELECCIONE dbo.CIntToChar (867, 6) COMO COD_ID

SALIDA

000867

Prueba esto: select right('00000' + cast(Your_Field as varchar(5)), 5)

Obtendrá el resultado en 5 dígitos, por ejemplo: 00001, ...., 01234

También puede utilizar la función FORMAT () introducida en 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')

Úselo REPLICATEpara que no tenga que codificar todos los ceros iniciales:

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

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

SALIDA:

0000000123

No para High-Jack esta pregunta, pero debe tomarse en cuenta que debe usar (N) VARCHAR en lugar de (N) CHAR tipo de datos.

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

El segmento anterior, no producirá la respuesta correcta de SQL 2005

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

El segmento anterior producirá la respuesta deseada de SQL 2005

El varchar le proporcionará la longitud de prefijo deseada sobre la marcha. Donde, como el tipo de datos de longitud fija, requerirá designación de longitud y ajustes.

Me gusta usar

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

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

esto me da

000000004

El tipo de datos "int" no puede tener más de 10 dígitos; además, la función "Len ()" funciona en ints, por lo que no es necesario convertir el int en una cadena antes de llamar a la función len ().

Por último, no está teniendo en cuenta el caso en el que el tamaño de su int> el número total de dígitos que desea rellenar (@intLen).

Por lo tanto, una solución más concisa / correcta es:

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

No es muy elegante, pero agrego un valor establecido con el mismo número de ceros iniciales que deseo al numérico que deseo convertir y uso la función DERECHA.

Ejemplo:

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

Resultado: '000867'

Solución de una línea ( per se ) para SQL Server 2008 o superior:

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

La multiplicación por SIGNexpresión es equivalente a MAX(0, @DesiredLenght-LEN([Column])). El problema es que MAX()solo acepta un argumento ...

Encontré un buen artículo aquí :

Relleno de una cadena con ceros iniciales

Necesito hacer esto muchas veces cuando genero una exportación de datos de longitud fija donde, por ejemplo, una columna numérica tiene 9 caracteres y necesita prefijar 0 a la izquierda.

    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)

Por cierto, si es una columna int, entonces todavía no mantendrá los ceros Solo hágalo en la capa de presentación o si realmente lo necesita en SELECT

Tenía el mismo problema, así es como lo resolví ... Simple y elegante. El "4" es la longitud que debe tener la cadena, no importa qué longitud de entero se pase, se rellenará con ceros hasta "4".

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

En mi caso, quería que mi campo tuviera 0 a la izquierda en un campo de 10 caracteres (NVARCHAR (10)). El archivo de origen no tiene los ceros iniciales necesarios para luego unirse a otra tabla. Hizo esto simplemente por estar en SQL Server 2008R2:

Establecer campo = derecha (('0000000000' + [Campo]), 10) (No se puede usar Format () ya que es anterior a SQL2012)

Realicé esto contra los datos existentes. De esta manera, 1 o 987654321 aún llenará los 10 espacios con ceros a la izquierda.

A medida que se importan los nuevos datos y luego se descargan en la tabla a través de una base de datos de Access, puedo usar el formato ([Campo], "0000000000") al agregar datos de Access a la tabla del servidor SQL para cualquier registro nuevo.

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

- Sin el 'RTRIM', el valor devuelto es 3__!!!

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

- Sin el 'RTRIM', el valor devuelto es 867___!!!

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

Usar RIGHTes una buena opción, pero también puede hacer lo siguiente:

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

donde Nes el número total de dígitos que desea mostrar. Entonces, para un valor de 3 dígitos con ceros a la izquierda ( N = 3):

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

o alternativamente

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

Lo que está haciendo es agregar el valor deseado a una potencia de 10 lo suficientemente grande como para generar suficientes ceros a la izquierda y luego cortar el 1 a la izquierda.

La ventaja de esta técnica es que el resultado siempre tendrá la misma longitud, lo que permitirá el uso de en SUBSTRINGlugar de RIGHT, que no está disponible en algunos lenguajes de consulta (como HQL).

Este trabajo para mí en 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

Por ejemplo:

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

Espero que esto ayude. Atentamente

Funciona en 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)

Disfrutar

Me preguntaba, ¿esto te sería útil?

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