Wie konvertiere ich int in char mit führenden Nullen?

Ich muss int datafield in nvarchar mit führenden Nullen konvertieren

Beispiel:

1 konvertiere zu '001'

867 konvertieren zu '000867' usw.

Vielen Dank.

Dies ist meine Antwort 4 Stunden später ...

Ich habe dieses T-SQL-Skript getestet und arbeite gut für mich!

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

Ich habe diese Benutzerfunktion erstellt

T-SQL-Code:

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

Beispiel:

SELECT dbo.CIntToChar (867, 6) AS COD_ID

AUSGABE

000867

Versuche dies: select right('00000' + cast(Your_Field as varchar(5)), 5)

Das Ergebnis wird in 5 Ziffern angezeigt, z. B. 00001, ...., 01234

Sie können auch die in SQL Server 2012 eingeführte Funktion FORMAT () verwenden . 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')

Verwenden REPLICATESie diese Option, damit Sie nicht alle führenden Nullen fest codieren müssen:

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

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

AUSGABE:

0000000123

Nicht um diese Frage zu beantworten, sondern es muss beachtet werden, dass Sie (N) VARCHAR anstelle des Datentyps (N) CHAR verwenden müssen.

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

Über dem Segment wird nicht die richtige Antwort von SQL 2005 erzeugt

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

Über dem Segment wird die gewünschte Antwort von SQL 2005 erzeugt

Mit dem Varchar erhalten Sie im Handumdrehen die gewünschte Präfixlänge. Wobei der Datentyp mit fester Länge eine Längenbezeichnung und Anpassungen erfordert.

Ich benutze gerne

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

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

das gibt mir

000000004

Der Datentyp "int" darf nicht länger als 10 Stellen sein. Außerdem funktioniert die Funktion "Len ()" für Ints, sodass das int nicht in einen String konvertiert werden muss, bevor die Funktion len () aufgerufen wird.

Schließlich berücksichtigen Sie nicht den Fall, in dem die Größe Ihres int> die Gesamtzahl der Stellen ist, auf die es aufgefüllt werden soll (@intLen).

Daher ist eine präzisere / korrektere Lösung:

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

Nicht sehr elegant, aber ich addiere einen festgelegten Wert mit der gleichen Anzahl führender Nullen, die ich möchte, zu der Zahl, die ich konvertieren möchte, und verwende die RECHTS-Funktion.

Beispiel:

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

Ergebnis: '000867'

Einzeilige Lösung ( per se ) für SQL Server 2008 oder höher:

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

Die Multiplikation mit dem SIGNAusdruck entspricht MAX(0, @DesiredLenght-LEN([Column])). Das Problem ist, dass MAX()nur ein Argument akzeptiert wird ...

Ich habe hier einen guten Artikel gefunden :

Auffüllen einer Zeichenfolge mit führenden Nullen

Ich muss dies oft tun, wenn ich einen Datenexport mit fester Länge ausgeben möchte, bei dem beispielsweise eine numerische Spalte 9 Zeichen lang ist und Sie führenden Nullen voranstellen müssen.

    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)

Übrigens, wenn es sich um eine int-Spalte handelt, werden die Nullen immer noch nicht beibehalten. Tun Sie dies einfach in der Präsentationsebene oder wenn Sie dies wirklich in SELECT benötigen

Hatte das gleiche Problem, so habe ich es gelöst ... Einfach und elegant. Die "4" gibt an, wie lang die Zeichenfolge sein soll, unabhängig davon, welche Länge der Ganzzahl übergeben wird, wird sie mit Nullen bis zu "4" aufgefüllt.

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

In meinem Fall wollte ich, dass mein Feld führende Nullen in einem 10-Zeichen-Feld hat (NVARCHAR (10)). Die Quelldatei enthält nicht die führenden Nullen, die für die Verknüpfung mit einer anderen Tabelle erforderlich sind. Dies geschah einfach aufgrund von SQL Server 2008R2:

Set Field = right (('0000000000' + [Field]), 10) (Format () kann nicht verwendet werden, da dies vor SQL2012 ist)

Dies wurde für die vorhandenen Daten durchgeführt. Auf diese Weise füllt 1 oder 987654321 immer noch alle 10 Felder mit führenden Nullen.

Da die neuen Daten importiert und dann über eine Access-Datenbank in die Tabelle kopiert werden, kann ich das Format ([Feld], "0000000000") verwenden, wenn neue Datensätze von Access an die SQL Server-Tabelle angehängt werden.

DECLARE @number1 INT, @number2 INT

SET @number1 = 1

SET @number2 = 867

- Ohne 'RTRIM' ist der zurückgegebene Wert 3__!!!

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

- Ohne 'RTRIM' ist der zurückgegebene Wert 867___!!!

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

Die Verwendung RIGHTist eine gute Option, Sie können jedoch auch Folgendes tun:

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

Wo Nist die Gesamtzahl der Stellen, die angezeigt werden sollen? Also für einen dreistelligen Wert mit führenden Nullen ( N = 3):

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

oder alternativ

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

Dies führt dazu, dass der gewünschte Wert zu einer Potenz von 10 addiert wird, die groß genug ist, um genügend führende Nullen zu erzeugen, und dann die führende 1 abgeschnitten wird.

Der Vorteil dieser Technik besteht darin, dass das Ergebnis immer dieselbe Länge hat und die Verwendung von SUBSTRINGanstelle von ermöglicht RIGHT, was in einigen Abfragesprachen (wie HQL) nicht verfügbar ist.

Diese Arbeit für mich in 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

Beispielsweise:

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

Hoffe das wird helfen. Freundliche Grüße

Funktioniert in 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)

Genießen

Ich habe mich gefragt, ob dies für Sie von Nutzen ist.

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