Jak przekonwertować int na char z wiodącymi zerami?

Muszę przekonwertować int datafield na nvarchar z wiodącymi zerami

przykład:

1 zamień na '001'

867 konwertuj na '000867' itd.

dzięki.

To moja odpowiedź 4 godziny później ...

Przetestowałem ten skrypt T-SQL i dla mnie działa dobrze!

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

Stworzyłem tę funkcję użytkownika

Kod 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

Przykład:

WYBIERZ dbo.CIntToChar (867, 6) jako COD_ID

WYNIK

000867

Spróbuj tego: select right('00000' + cast(Your_Field as varchar(5)), 5)

Otrzyma wynik w postaci 5 cyfr, np. 00001, ...., 01234

Możesz również użyć funkcji FORMAT () wprowadzonej w 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')

Użyj, REPLICATEaby nie trzeba było na stałe kodować wszystkich wiodących zer:

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

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

WYNIK:

0000000123

Nie do High-Jacka na to pytanie, ale należy zauważyć, że należy użyć typu danych (N) VARCHAR zamiast (N) CHAR.

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

Powyższy segment nie wygeneruje poprawnej odpowiedzi z SQL 2005

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

Powyższy segment wygeneruje żądaną odpowiedź z SQL 2005

Varchar zapewni Ci żądaną długość prefiksu w locie. Gdzie jako typ danych o stałej długości będzie wymagał oznaczenia długości i dostosowań.

Lubię używać

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

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

to daje mi

000000004

Typ danych „int” nie może zawierać więcej niż 10 cyfr, dodatkowo funkcja „Len ()” działa na liczbach całkowitych, więc nie ma potrzeby konwertowania int na łańcuch przed wywołaniem funkcji len ().

Wreszcie, nie bierzesz pod uwagę przypadku, w którym rozmiar int> całkowita liczba cyfr, do których chcesz go dopełnić (@intLen).

Dlatego bardziej zwięzłym / poprawnym rozwiązaniem jest:

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

Niezbyt eleganckie, ale dodaję ustawioną wartość z taką samą liczbą wiodących zer, które chcę, do liczby, którą chcę przekonwertować, i używam funkcji PRAWO.

Przykład:

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

Wynik: `` 000867 ''

Rozwiązanie jednoprzewodowe ( per se ) dla SQL Server 2008 lub nowszego:

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

Mnożenie przez SIGNwyrażenie jest równoważne MAX(0, @DesiredLenght-LEN([Column])). Problem w tym, że MAX()akceptuje tylko jeden argument ...

Znalazłem dobry artykuł tutaj :

Wypełnienie łańcucha wiodącymi zerami

Muszę to zrobić wiele razy, gdy wyprowadzam eksport danych o stałej długości, w którym na przykład kolumna numeryczna ma 9 znaków i trzeba poprzedzić początkowe 0.

    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)

BTW jeśli jest to kolumna int to nadal nie zachowa zer Po prostu zrób to w warstwie prezentacji lub jeśli naprawdę potrzebujesz w SELECT

Miałem ten sam problem, oto jak rozwiązałem ... Prosty i elegancki. „4” to długość łańcucha, bez względu na to, jaka liczba całkowita zostanie przekazana, będzie wypełniona od zera do „4”.

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

W moim przypadku chciałem, aby moje pole miało wiodące 0 w polu 10 znaków (NVARCHAR (10)). Plik źródłowy nie ma wiodących zer, które należy dołączyć do innej tabeli. Czy to po prostu dzięki korzystaniu z programu SQL Server 2008R2:

Ustaw Pole = right (('0000000000' + [Pole]), 10) (Nie można użyć formatu (), ponieważ jest to wersja sprzed SQL2012)

Wykonano to na istniejących danych. W ten sposób 1 lub 987654321 nadal wypełni wszystkie 10 spacji wiodącymi zerami.

Ponieważ nowe dane są importowane, a następnie zrzucane do tabeli za pośrednictwem bazy danych programu Access, mogę użyć formatu ([pole], „0000000000”) podczas dołączania z programu Access do tabeli serwera SQL dla wszelkich nowych rekordów.

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

- Bez „RTRIM” zwracana wartość to 3__!!!

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

- Bez „RTRIM” zwracana wartość to 867___!!!

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

Używanie RIGHTjest dobrą opcją, ale możesz też wykonać następujące czynności:

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

gdzie Njest łączną liczbą cyfr, które chcesz wyświetlić. A więc dla 3-cyfrowej wartości z wiodącymi zerami ( N = 3):

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

lub na przemian

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

To, co robi, to dodanie żądanej wartości do potęgi 10 wystarczająco dużej, aby wygenerować wystarczającą liczbę zer wiodących, a następnie odcięcie wiodącej 1.

Zaletą tej techniki jest to, że wynik będzie zawsze tej samej długości, co pozwala na użycie SUBSTRINGzamiast RIGHT, co nie jest dostępne w niektórych językach zapytań (takich jak HQL).

Ta praca dla mnie w 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

Na przykład:

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

Mam nadzieję, że to pomoże. Z poważaniem

Działa w 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)

Cieszyć się

Zastanawiałem się, czy to ci się przyda?

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