into - varchar sql




Il modo T-SQL più efficiente per riempire un varchar sulla sinistra con una certa lunghezza? (12)

Cosa ne pensi di questo:

replace((space(3 - len(MyField))

3 è il numero di zeros da riempire

Rispetto a dire:

REPLICATE(@padchar, @len - LEN(@str)) + @str

Diverse persone hanno dato versioni di questo:

right('XXXXXXXXXXXX'+ @str, @n)

fai attenzione perché troncerà i tuoi dati effettivi se è più lungo di n.


Ecco la mia soluzione, che evita le stringhe troncate e utilizza semplicemente l'SQL. Grazie a @AlexCuse , @Kevin e @Sklivvz , le cui soluzioni sono alla base di questo codice.

 --[@charToPadStringWith] is the character you want to pad the string with.
declare @charToPadStringWith char(1) = 'X';

-- Generate a table of values to test with.
declare @stringValues table (RowId int IDENTITY(1,1) NOT NULL PRIMARY KEY, StringValue varchar(max) NULL);
insert into @stringValues (StringValue) values (null), (''), ('_'), ('A'), ('ABCDE'), ('1234567890');

-- Generate a table to store testing results in.
declare @testingResults table (RowId int IDENTITY(1,1) NOT NULL PRIMARY KEY, StringValue varchar(max) NULL, PaddedStringValue varchar(max) NULL);

-- Get the length of the longest string, then pad all strings based on that length.
declare @maxLengthOfPaddedString int = (select MAX(LEN(StringValue)) from @stringValues);
declare @longestStringValue varchar(max) = (select top(1) StringValue from @stringValues where LEN(StringValue) = @maxLengthOfPaddedString);
select [@longestStringValue][email protected], [@maxLengthOfPaddedString][email protected];

-- Loop through each of the test string values, apply padding to it, and store the results in [@testingResults].
while (1=1)
begin
    declare
        @stringValueRowId int,
        @stringValue varchar(max);

    -- Get the next row in the [@stringLengths] table.
    select top(1) @stringValueRowId = RowId, @stringValue = StringValue
    from @stringValues 
    where RowId > isnull(@stringValueRowId, 0) 
    order by RowId;

    if (@@ROWCOUNT = 0) 
        break;

    -- Here is where the padding magic happens.
    declare @paddedStringValue varchar(max) = RIGHT(REPLICATE(@charToPadStringWith, @maxLengthOfPaddedString) + @stringValue, @maxLengthOfPaddedString);

    -- Added to the list of results.
    insert into @testingResults (StringValue, PaddedStringValue) values (@stringValue, @paddedStringValue);
end

-- Get all of the testing results.
select * from @testingResults;

Forse un colpo secco ho queste UDF da battere a sinistra ea destra

ALTER   Function [dbo].[fsPadLeft](@var varchar(200),@padChar char(1)='0',@len int)
returns varchar(300)
as
Begin

return replicate(@PadChar,@len-Len(@var))[email protected]

end

e a destra

ALTER function [dbo].[fsPadRight](@var varchar(200),@padchar char(1)='0', @len int) returns varchar(201) as
Begin

--select @padChar=' ',@len=200,@var='hello'


return  @var+replicate(@PadChar,@len-Len(@var))
end

Io uso questo. Ti permette di determinare la lunghezza che vuoi che sia il risultato e un carattere di riempimento predefinito, se non ne viene fornito uno. Ovviamente è possibile personalizzare la lunghezza dell'input e dell'output per i massimi in cui si sta eseguendo.

/*===============================================================
 Author         : Joey Morgan
 Create date    : November 1, 2012
 Description    : Pads the string @MyStr with the character in 
                : @PadChar so all results have the same length
 ================================================================*/
 CREATE FUNCTION [dbo].[svfn_AMS_PAD_STRING]
        (
         @MyStr VARCHAR(25),
         @LENGTH INT,
         @PadChar CHAR(1) = NULL
        )
RETURNS VARCHAR(25)
 AS 
      BEGIN
        SET @PadChar = ISNULL(@PadChar, '0');
        DECLARE @Result VARCHAR(25);
        SELECT
            @Result = RIGHT(SUBSTRING(REPLICATE('0', @LENGTH), 1,
                                      (@LENGTH + 1) - LEN(RTRIM(@MyStr)))
                            + RTRIM(@MyStr), @LENGTH)

        RETURN @Result

      END

Il tuo chilometraggio può variare. :-)

Joey Morgan
Programmatore / Analista Principal I.
Business Unit WellPoint Medicaid


Mi è piaciuta la soluzione vnRocks, qui è sotto forma di udf

create function PadLeft(
      @String varchar(8000)
     ,@NumChars int
     ,@PadChar char(1) = ' ')
returns varchar(8000)
as
begin
    return stuff(@String, 1, 0, replicate(@PadChar, @NumChars - len(@String)))
end

Per fornire valori numerici arrotondati a due cifre decimali ma riempiti a destra con zeri, se necessario, ho:

DECLARE @value = 20.1
SET @value = ROUND(@value,2) * 100
PRINT LEFT(CAST(@value AS VARCHAR(20)), LEN(@value)-2) + '.' + RIGHT(CAST(@value AS VARCHAR(20)),2)

Se qualcuno può pensare a un modo più ordinato, sarebbe apprezzato - quanto sopra sembra maldestro .

Nota : in questo caso, sto utilizzando SQL Server per inviare i report via email in formato HTML e quindi desidero formattare le informazioni senza coinvolgere uno strumento aggiuntivo per analizzare i dati.


Questo è semplicemente un uso inefficiente di SQL, indipendentemente da come lo si fa.

forse qualcosa di simile

right('XXXXXXXXXXXX'+ rtrim(@str), @n)

dove X è il tuo carattere di riempimento e @n è il numero di caratteri nella stringa risultante (supponendo che hai bisogno del padding perché hai a che fare con una lunghezza fissa).

Ma come ho detto dovresti davvero evitare di farlo nel tuo database.


Spero che questo aiuti qualcuno.

STUFF (character_expression, start, length, character_expression)

selezionare elementi (@str, 1, 0, replicare ('0', @n - len (@str)))


probabilmente eccessivo, uso spesso questa UDF:

CREATE FUNCTION [dbo].[f_pad_before](@string VARCHAR(255), @desired_length INTEGER, @pad_character CHAR(1))
RETURNS VARCHAR(255) AS  
BEGIN

-- Prefix the required number of spaces to bulk up the string and then replace the spaces with the desired character
 RETURN ltrim(rtrim(
        CASE
          WHEN LEN(@string) < @desired_length
            THEN REPLACE(SPACE(@desired_length - LEN(@string)), ' ', @pad_character) + @string
          ELSE @string
        END
        ))
END

In modo che tu possa fare cose come:

select dbo.f_pad_before('aaa', 10, '_')

@padstr = REPLICATE(@padchar, @len) -- this can be cached, done only once

SELECT RIGHT(@padstr + @str, @len)

select right(replicate(@padchar, @len) + @str, @len)




tsql