PadLeft-Funktion in T-SQL

Ich habe die folgende Tabelle A:

id
----
1
2
12
123
1234

Ich muss die idWerte mit Nullen auffüllen:

id
----
0001
0002
0012
0123
1234

Wie kann ich das erreichen?

Ich glaube, das ist vielleicht das, wonach Sie suchen:

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

FROM tableA

oder

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

FROM tableA

Ich habe die Syntax im zweiten Beispiel nicht getestet. Ich bin mir nicht sicher, ob dies zu 100% funktioniert - möglicherweise sind einige Anpassungen erforderlich -, aber es vermittelt die allgemeine Vorstellung, wie Sie die gewünschte Ausgabe erhalten.

BEARBEITEN

Um die in den Kommentaren aufgeführten Bedenken auszuräumen ...

@ pkr298 - Ja STR funktioniert nur mit Zahlen ... Das Feld des OP ist eine ID ... daher nur mit Zahlen.

@Desolator - Das funktioniert natürlich nicht ... der erste Parameter ist 6 Zeichen lang. Sie können so etwas tun wie:

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

Dies sollte theoretisch die Torpfosten verschieben ... wenn die Zahl größer wird, sollte es IMMER funktionieren ... unabhängig davon, ob es 1 oder 123456789 ist ...

Wenn Ihr Maximalwert also 123456 ist ... würden Sie 0000123456 sehen und wenn Ihr Minimalwert 1 ist, würden Sie 0000000001 sehen

SQL Server unterstützt jetzt die FORMAT- Funktion ab Version 2012, also:

SELECT FORMAT(id, '0000') FROM TableA

wird den Trick machen.

Wenn sich Ihre ID oder Spalte in a befindet varcharund eine Zahl darstellt, die Sie zuerst konvertieren:

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

Ergebnis

----
0001
0002
0012
0123
1234

Alter Beitrag, aber vielleicht hilft das jemandem:

So vervollständigen Sie, bis 4 nicht leere Zeichen angezeigt werden:

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

Bis 10 abschließen:

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

Wenn die Spalte numerisch ist , konvertieren Sie sie zuerst mit folgendem Code in varchar:

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

Und um bis 10 mit einem numerischen Feld zu vervollständigen:

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

Versuche dies:

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

- Bitte schauen Sie sich diese an.

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

- Ich hoffe, diese würden Ihnen helfen

Dies funktioniert für Zeichenfolgen, Ganzzahlen und Zahlen:

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

Wo 4ist die gewünschte Länge. Funktioniert für Zahlen mit mehr als 4 Ziffern und gibt eine leere Zeichenfolge für den NULLWert zurück.

Wenn noch jemand interessiert ist, habe ich diesen Artikel auf DATABASE.GUIDE gefunden:
Left Padding in SQL Server - 3 LPAD () -Äquivalenten

Kurz gesagt, in diesem Artikel werden drei Methoden erwähnt.
Angenommen, Ihre ID ist = 12 und muss als 0012 angezeigt werden.

Methode 1 - Verwenden der Funktion RIGHT ()
Die erste Methode verwendet die Funktion RIGHT (), um nach dem Hinzufügen einiger führender Nullen nur den am weitesten rechts stehenden Teil der Zeichenfolge zurückzugeben.

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

Ergebnis:
0012

Methode 2 - Verwenden Sie eine Kombination aus RIGHT () und REPLICATE ().
Diese Methode ist fast dieselbe wie die vorherige Methode. Der einzige Unterschied besteht darin, dass ich die drei Nullen einfach durch die Funktion REPLICATE () ersetze:

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

Ergebnis:
0012

Methode 3 - Verwenden Sie eine Kombination aus REPLACE () und STR ().
Diese Methode hat einen völlig anderen Blickwinkel als die vorherigen Methoden:

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

Ergebnis:
0012

Schauen Sie sich den Artikel an, es gibt eine eingehendere Analyse mit Beispielen.

Dies ist, was ich normalerweise verwende, wenn ich einen Wert auffüllen muss.

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

Ich brauchte dies in einer Funktion auf SQL Server und passte Patricks Antwort ein wenig an.

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'

Funktion erstellen:

    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

Beispiel:

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

Ich habe eine Funktion erstellt:

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;

Verwendung: Wählen Sie dbo.fnPadLeft (123, 10).

Rückgabe: 0000000123

Bei Bedarf kann Folgendes ziemlich ODBC-konform sein:

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

Dies basiert auf der Tatsache, dass die Anzahl der Ziffern für eine Basis-10-Zahl durch die integrale Komponente ihres Protokolls ermittelt werden kann. Davon können wir es von der gewünschten Polsterbreite abziehen. Wiederholen wird nullfür Werte unter 1 zurückgegeben, also brauchen wir ifnull.

Meine Lösung ist nicht effizient, hat mir aber in Situationen geholfen, in denen die Werte (Bankschecknummern und Überweisungsnummer) als varchar gespeichert wurden, wobei einige Einträge alphanumerische Werte enthielten und ich auffüllen musste, wenn die Länge kleiner als 6 Zeichen ist.

Dachte zu teilen, wenn jemand auf die gleiche Situation stößt

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

Ein einfaches Beispiel wäre

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

Dazu habe ich eine Funktion erstellt, in der Sie die gewünschte Länge der Ausgabezeichen angeben können:

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

Beispielergebnisse

Effizienter ist:

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

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