Remplissez une chaîne avec des zéros de début pour qu'elle comporte 3 caractères dans SQL Server 2008

J'ai une chaîne de 3 caractères maximum lorsqu'elle est créée pour la première fois dans SQL Server 2008 R2.

Je voudrais le remplir avec des zéros en tête, donc si sa valeur d'origine était '1' alors la nouvelle valeur serait '001'. Ou si sa valeur d'origine était '23', la nouvelle valeur est '023'. Ou si sa valeur d'origine est «124», la nouvelle valeur est identique à la valeur d'origine.

J'utilise SQL Server 2008 R2. Comment pourrais-je faire cela en utilisant T-SQL?

Si le champ est déjà une chaîne, cela fonctionnera

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

Si vous souhaitez que les valeurs nulles s'affichent en tant que '000'

Ce pourrait être un entier - alors vous voudriez

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

Comme requis par la question, cette réponse ne fonctionne que si la longueur <= 3, si vous voulez quelque chose de plus grand, vous devez changer la constante de chaîne et les deux constantes entières à la largeur nécessaire. par exemple'0000' and VARCHAR(4)),4

Bien que la question soit pour SQL Server 2008 R2, au cas où quelqu'un lirait ceci avec la version 2012 et supérieure, depuis, cela est devenu beaucoup plus facile grâce à l'utilisation de FORMAT .

Vous pouvez soit passer une chaîne de format numérique standard ou une chaîne de format numérique personnalisée comme argument de format (merci Vadim Ovchinnikov pour cet indice).

Pour cette question par exemple un code comme

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#');

les sorties

001
001

La méthode sûre:

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

Cela a l'avantage de renvoyer la chaîne '***'pour n <0 ou n> 999, ce qui est un indicateur agréable et évident d'une entrée hors limites. Les autres méthodes répertoriées ici échoueront en silence en tronquant l'entrée à une sous-chaîne à 3 caractères.

Voici une technique plus générale pour le rembourrage gauche à n'importe quelle largeur souhaitée:

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)

Cependant, si vous avez affaire à des valeurs négatives et à un remplissage avec des zéros non significatifs, ni cela, ni aucune autre technique suggérée ne fonctionnera. Vous obtiendrez quelque chose qui ressemble à ceci:

00-123

[Probablement pas ce que vous vouliez]

Donc ... vous devrez sauter à travers quelques cerceaux supplémentaires Voici une approche qui formatera correctement les nombres négatifs:

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
         )

Il convient de noter que les convert()appels doivent spécifier une [n]varcharlongueur suffisante pour contenir le résultat converti avec troncature.

Voici une variante de la réponse de Hogan que j'utilise dans SQL Server Express 2012:

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

Au lieu de vous inquiéter si le champ est une chaîne ou non, je viens de le CONCATfaire, car il produira de toute façon une chaîne. De plus, si le champ peut être un NULL, l'utilisation ISNULLpeut être nécessaire pour éviter que la fonction n'obtienne des NULLrésultats.

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

J'ai toujours trouvé la méthode suivante très utile.

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

Utilisez cette fonction qui convient à toutes les situations.

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

Exemple de sortie

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 

Pour ceux qui souhaitent mettre à jour leurs données existantes, voici la requête:

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

Pour les entiers, vous pouvez utiliser la conversion implicite de int en varchar:

SELECT RIGHT(1000 + field, 3)

Je connais son ancien ticket je pensais juste le partager.

J'ai trouvé ce code à la recherche d'une solution. Je ne sais pas si cela fonctionne sur toutes les versions de MSSQL, j'ai MSSQL 2016.

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

renvoie "0023" Le 4 dans la fonction STR est la longueur totale, y compris la valeur. Les exemples 4, 23 et 123 auront tous 4 en STR et la quantité correcte de zéros sera ajoutée. Vous pouvez l'augmenter ou le diminuer. Pas besoin d'avoir la longueur du 23.

Edit: je vois que c'est la même chose que @Anon post.

Essayez ceci avec une longueur fixe.

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

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

J'ai eu un problème similaire avec la colonne entière en entrée lorsque j'avais besoin d'une sortie varchar (ou chaîne) de taille fixe. Par exemple, 1 à «01», 12 à «12». Ce code fonctionne:

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

Si l'entrée est également une colonne de varchar, vous pouvez éviter la partie de coulée.

Pour une approche plus dynamique, essayez ceci.

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

A écrit cela parce que j'avais des exigences pour une longueur spécifique (9). Remplit la gauche avec @pattern UNIQUEMENT lorsque l'entrée doit être complétée. Doit toujours renvoyer la longueur définie dans @pattern.

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

Renvoie 1234input

C'est simple

Comme:

DECLARE @DUENO BIGINT
SET @DUENO=5

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

Je suis venu ici spécifiquement pour trouver comment convertir mon décalage horaire en une chaîne de fuseau horaire pour convertir les dates en DATETIMEOFFSET dans SQL Server 2008. Brut, mais nécessaire.

J'ai donc besoin d'une méthode capable de gérer les nombres négatifs et positifs, en les formatant en deux caractères avec un zéro en tête si nécessaire. La réponse Anons m'a rapproché, mais les valeurs de fuseau horaire négatives sortiraient 0-5plutôt que celles requises-05

Donc, avec un petit ajustement sur sa réponse, cela fonctionne pour toutes les conversions d'heure de fuseau horaire

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'

J'ai créé cette fonction qui s'adresse à bigint et un zéro à gauche ou un autre caractère unique (max 20 caractères retournés) et permet une longueur des résultats inférieure à la longueur du numéro d'entrée:

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