Füllen Sie eine Zeichenfolge mit führenden Nullen auf, damit sie in SQL Server 2008 3 Zeichen lang ist

Ich habe eine Zeichenfolge, die bis zu 3 Zeichen lang ist, wenn sie zum ersten Mal in SQL Server 2008 R2 erstellt wird.

Ich möchte es mit führenden Nullen auffüllen. Wenn also sein ursprünglicher Wert '1' wäre, wäre der neue Wert '001'. Oder wenn der ursprüngliche Wert '23' war, ist der neue Wert '023'. Oder wenn der ursprüngliche Wert '124' ist, entspricht der neue Wert dem ursprünglichen Wert.

Ich verwende SQL Server 2008 R2. Wie würde ich das mit T-SQL machen?

Wenn das Feld bereits eine Zeichenfolge ist, funktioniert dies

 SELECT RIGHT('000'+ISNULL(field,''),3)

Wenn Sie möchten, dass Nullen als '000' angezeigt werden

Es könnte eine ganze Zahl sein - dann würden Sie wollen

 SELECT RIGHT('000'+CAST(field AS VARCHAR(3)),3)

Wie in der Frage gefordert, funktioniert diese Antwort nur, wenn die Länge <= 3 ist. Wenn Sie etwas Größeres wünschen, müssen Sie die Zeichenfolgenkonstante und die beiden Ganzzahlkonstanten auf die erforderliche Breite ändern. z.B'0000' and VARCHAR(4)),4

Obwohl die Frage für SQL Server 2008 R2 war, wurde sie durch die Verwendung von FORMAT viel einfacher, falls jemand dies mit Version 2012 und höher liest .

Sie können entweder eine Standardzeichenfolge im numerischen Format oder eine benutzerdefinierte Zeichenfolge im numerischen Format als Formatargument übergeben (danke Vadim Ovchinnikov für diesen Hinweis).

Für diese Frage zum Beispiel ein Code wie

DECLARE @myInt INT = 1;
-- One way using a standard numeric format string
PRINT FORMAT(@myInt,'D3');
-- Other way using a custom numeric format string
PRINT FORMAT(@myInt,'00#');

Ausgänge

001
001

Die sichere Methode:

SELECT REPLACE(STR(n,3),' ','0')

Dies hat den Vorteil, dass die Zeichenfolge '***'für n <0 oder n> 999 zurückgegeben wird, was ein netter und offensichtlicher Indikator für die Eingabe außerhalb der Grenzen ist. Die anderen hier aufgeführten Methoden schlagen stillschweigend fehl, indem die Eingabe in eine dreistellige Teilzeichenfolge abgeschnitten wird.

Hier ist eine allgemeinere Technik zum Auffüllen der linken Seite auf eine beliebige gewünschte Breite:

declare @x     int     = 123 -- value to be padded
declare @width int     = 25  -- desired width
declare @pad   char(1) = '0' -- pad character

select right_justified = replicate(
                           @pad ,
                           @width-len(convert(varchar(100),@x))
                           )
                       + convert(varchar(100),@x)

Wenn Sie jedoch mit negativen Werten arbeiten und mit führenden Nullen auffüllen, funktionieren weder diese noch andere vorgeschlagene Techniken. Sie erhalten etwas, das so aussieht:

00-123

[Wahrscheinlich nicht das, was du wolltest]

Also ... Sie müssen durch einige zusätzliche Rahmen springen. Hier ist ein Ansatz, mit dem negative Zahlen richtig formatiert werden:

declare @x     float   = -1.234
declare @width int     = 20
declare @pad   char(1) = '0'

select right_justified = stuff(
         convert(varchar(99),@x) ,                            -- source string (converted from numeric value)
         case when @x < 0 then 2 else 1 end ,                 -- insert position
         0 ,                                                  -- count of characters to remove from source string
         replicate(@pad,@width-len(convert(varchar(99),@x)) ) -- text to be inserted
         )

Man sollte beachten, dass die convert()Aufrufe eine [n]varcharausreichende Länge angeben sollten, um das konvertierte Ergebnis mit Kürzung zu halten.

Hier ist eine Variante von Hogans Antwort, die ich in SQL Server Express 2012 verwende:

SELECT RIGHT(CONCAT('000', field), 3)

Anstatt mir Sorgen zu machen, ob das Feld eine Zeichenfolge ist oder nicht, CONCATmache ich es einfach , da es sowieso eine Zeichenfolge ausgibt. Wenn das Feld ein Feld sein kann, ist möglicherweise eine NULLVerwendung ISNULLerforderlich, um zu vermeiden, dass die Funktion NULLErgebnisse erzielt.

SELECT RIGHT(CONCAT('000', ISNULL(field,'')), 3)

Ich habe die folgende Methode immer als sehr hilfreich empfunden.

REPLICATE('0', 5 - LEN(Job.Number)) + CAST(Job.Number AS varchar) as 'NumberFull'

Verwenden Sie diese Funktion, die für jede Situation geeignet ist.

CREATE FUNCTION dbo.fnNumPadLeft (@input INT, @pad tinyint)
RETURNS VARCHAR(250)
AS BEGIN
    DECLARE @NumStr VARCHAR(250)

    SET @NumStr = LTRIM(@input)

    IF(@pad > LEN(@NumStr))
        SET @NumStr = REPLICATE('0', @Pad - LEN(@NumStr)) + @NumStr;

    RETURN @NumStr;
END

Beispielausgabe

SELECT [dbo].[fnNumPadLeft] (2016,10) -- returns 0000002016
SELECT [dbo].[fnNumPadLeft] (2016,5) -- returns 02016
SELECT [dbo].[fnNumPadLeft] (2016,2) -- returns 2016
SELECT [dbo].[fnNumPadLeft] (2016,0) -- returns 2016 

Für diejenigen, die ihre vorhandenen Daten aktualisieren möchten, ist hier die Abfrage:

update SomeEventTable set eventTime=RIGHT('00000'+ISNULL(eventTime, ''),5)

Für Ganzzahlen können Sie die implizite Konvertierung von int nach varchar verwenden:

SELECT RIGHT(1000 + field, 3)

Ich kenne das alte Ticket, von dem ich nur dachte, dass ich es teilen möchte.

Ich habe diesen Code gefunden und nach einer Lösung gesucht. Ich bin mir nicht sicher, ob es auf allen Versionen von MSSQL funktioniert. Ich habe MSSQL 2016.

declare @value as nvarchar(50) = 23
select REPLACE(STR(CAST(@value AS INT) + 1,4), SPACE(1), '0') as Leadingzero

gibt "0023" zurück. Die 4 in der STR-Funktion ist die Gesamtlänge einschließlich des Werts. Beispiel 4, 23 und 123 haben alle 4 in STR und die richtige Anzahl von Nullen wird hinzugefügt. Sie können es erhöhen oder verringern. Keine Notwendigkeit, die Länge auf dem 23 zu bekommen.

Bearbeiten: Ich sehe es das gleiche wie @Anon Post.

Ich hatte ein ähnliches Problem mit der Ganzzahlspalte als Eingabe, als ich eine Varchar- (oder String-) Ausgabe mit fester Größe benötigte. Zum Beispiel 1 bis '01', 12 bis '12'. Dieser Code funktioniert:

SELECT RIGHT(CONCAT('00',field::text),2)

Wenn die Eingabe auch eine Spalte von Varchar ist, können Sie das Gussteil vermeiden.

Versuchen Sie dies für einen dynamischeren Ansatz.

declare @val varchar(5)
declare @maxSpaces int
set @maxSpaces = 3
set @val = '3'
select concat(REPLICATE('0',@maxSpaces-len(@val)),@val)

Versuchen Sie dies mit fester Länge.

select right('000000'+'123',5)

select REPLICATE('0', 5 - LEN(123)) + '123'

Schrieb dies, weil ich Anforderungen für bis zu einer bestimmten Länge hatte (9). Füllt die linke Seite NUR mit dem @ Muster auf, wenn die Eingabe aufgefüllt werden muss. Sollte immer die in @pattern definierte Länge zurückgeben.

declare @charInput as char(50) = 'input'

--always handle NULL :)
set @charInput = isnull(@charInput,'')

declare @actualLength as int = len(@charInput)

declare @pattern as char(50) = '123456789'
declare @prefLength as int = len(@pattern)

if @prefLength > @actualLength
    select Left(Left(@pattern, @prefLength-@actualLength) + @charInput, @prefLength)
else
    select @charInput

Gibt 1234input zurück

Einfach ist das

Mögen:

DECLARE @DUENO BIGINT
SET @DUENO=5

SELECT 'ND'+STUFF('000000',6-LEN(RTRIM(@DueNo))+1,LEN(RTRIM(@DueNo)),RTRIM(@DueNo)) DUENO

Ich bin speziell hierher gekommen, um herauszufinden, wie ich meinen Zeitzonenversatz in eine Zeitzonenzeichenfolge konvertieren kann, um Datumsangaben in SQL Server 2008 in DATETIMEOFFSET zu konvertieren. Brutto, aber notwendig.

Ich brauche also eine Methode, die negative und positive Zahlen verarbeitet und sie bei Bedarf auf zwei Zeichen mit einer führenden Null formatiert. Anons Antwort brachte mich in die Nähe, aber negative Zeitzonenwerte würden 0-5eher als die erforderlichen herauskommen-05

Mit ein wenig Optimierung seiner Antwort funktioniert dies für alle Zeitzonen-Stunden-Konvertierungen

DECLARE @n INT = 13 -- Works with -13, -5, 0, 5, etc
SELECT CASE 
    WHEN @n < 0 THEN '-' + REPLACE(STR(@n * -1 ,2),' ','0') 
    ELSE '+' + REPLACE(STR(@n,2),' ','0') END + ':00'

Ich habe diese Funktion erstellt, die Bigint und eine führende Null oder ein anderes einzelnes Zeichen (maximal 20 zurückgegebene Zeichen) berücksichtigt und eine Länge von Ergebnissen zulässt, die kleiner als die Länge der eingegebenen Nummer ist:

create FUNCTION fnPadNum (
  @Num BIGINT --Number to be padded, @sLen BIGINT --Total length of results , @PadChar varchar(1))
  RETURNS VARCHAR(20)
  AS
  --Pads bigint with leading 0's
            --Sample:  "select dbo.fnPadNum(201,5,'0')" returns "00201"
            --Sample:  "select dbo.fnPadNum(201,5,'*')" returns "**201"
            --Sample:  "select dbo.fnPadNum(201,5,' ')" returns "  201"
   BEGIN
     DECLARE @Results VARCHAR(20)
     SELECT @Results = CASE 
     WHEN @sLen >= len(ISNULL(@Num, 0))
     THEN replicate(@PadChar, @sLen - len(@Num)) + CAST(ISNULL(@Num, 0) AS VARCHAR)
     ELSE CAST(ISNULL(@Num, 0) AS VARCHAR)
     END

     RETURN @Results
     END
     GO

     --Usage:
      SELECT dbo.fnPadNum(201, 5,'0')
      SELECT dbo.fnPadNum(201, 5,'*')
      SELECT dbo.fnPadNum(201, 5,' ')