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

98

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

RicardoBalda
quelle
1
In Ihrem ersten Beispiel sollten CASTs NVARCHAR anstelle von NCHAR-Typen sein, da NCHAR (3) immer eine Länge von 3 hat.
Nzeemin

Antworten:

99

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

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

Nguyen Tran
quelle
1
Beachten Sie, dass Sie für Postgres das + durch || ersetzen müssen, alsoselect right('00000' || cast(Your_Field as varchar(5)), 5)
ronedg
56

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')
Darek.K
quelle
Ich werde dem SQL2012 zustimmen, aber für SQL 2008r2 und älter wird meine Lösung das Ergebnis erhalten
GoldBishop
1
Gerade getestet FORMAT Sql Server 2012 - es ist langsam, wie in "eine Zahl pro mehrere Sekunden" langsam. Bleib weg.
Muposat
@ Muposat, können Sie bitte den Code für diesen Test angeben? Es ist sehr wichtig. Danke im Voraus.
Diomedes Domínguez
3
@Diomedes Domínguez es ist ein Jahr her, also habe ich den ursprünglichen Test nicht mehr. Ich habe gerade einen weiteren Test auf einem sehr schnellen Server ausgeführt und 32 Sekunden Zeit, um 1 Million Zahlen zu formatieren. Nicht das Ende der Welt, aber die von Nguyen Tran veröffentlichte Lösung schafft es in 1 Sekunde. Zum Testen erstellen Sie einfach eine Schleife von @i int = 0 bis 10000000.
Muposat
22

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
KM.
quelle
13

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.

Goldbischof
quelle
6

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
Sedecimdies
quelle
1
Fühlt sich ein bisschen hackig an, aber es hat bei mir in DB2 funktioniert. Ich konnte die obigen Antworten nicht zum Laufen bringen.
Nathan M.
2
Ich mag es auch. Wenn die Länge fest codiert ist, können Sie einfach RIGHT(1000+Number, 3)- schön, kurz und schnell
maf-soft
1
Dies funktioniert auf allen SQL Server-Varianten ab 2005. Bevorzugte Antwort.
Fandango68
1
Was bedeuten die 10?
Fandango68
1
@ Fandango68 Die '10' in 'POWER (10, @Length)' oben ist, weil wir die Arithmetik der Basis 10 verwenden - daher entspricht das '1000'-Literal in der obigen maf-soft-Antwort POWER (10, 3) - 10 ^ 3 = 1000.
qxotk
4

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
C.List
quelle
3

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'

Brute Force SQL
quelle
2

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

Piotr Nawrot
quelle
1

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.

Andrew Hare
quelle
1
    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

Tarun Gupta
quelle
1

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)))
user2096582
quelle
1

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.

jhimes
quelle
0
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
John Lonberger
quelle
0

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.

Peter Gluck
quelle
0

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

Tricky Silence
quelle
0

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

Johnny Driesen
quelle
-2

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

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