Lepsze techniki przycinania zer wiodących w programie SQL Server?

Używam tego od jakiegoś czasu:

SUBSTRING(str_col, PATINDEX('%[^0]%', str_col), LEN(str_col))

Jednak ostatnio napotkałem problem z kolumnami zawierającymi wszystkie znaki „0”, takie jak „00000000”, ponieważ nigdy nie znaleziono znaku innego niż „0” do dopasowania.

Alternatywną techniką, którą widziałem, jest użycie TRIM:

REPLACE(LTRIM(REPLACE(str_col, '0', ' ')), ' ', '0')

Występuje to problem, jeśli istnieją osadzone spacje, ponieważ zostaną zamienione na „0”, gdy spacje zostaną zamienione z powrotem na „0”.

Staram się uniknąć skalarnego UDF. Znalazłem wiele problemów z wydajnością związanych z funkcjami UDF w SQL Server 2005.

SUBSTRING(str_col, PATINDEX('%[^0]%', str_col+'.'), LEN(str_col))

Dlaczego po prostu nie rzucisz wartości na, INTEGERa potem z powrotem do VARCHAR?

SELECT  CAST(CAST('000000000' AS INTEGER) AS VARCHAR)

--------
       0

Inne odpowiedzi tutaj, aby nie brać pod uwagę, jeśli masz wszystkie zero (lub nawet jedno zero).
Niektórzy zawsze domyślnie ustawiają pusty ciąg na zero, co jest błędne, gdy ma pozostać puste.
Przeczytaj ponownie oryginalne pytanie. To odpowiada na to, czego chce Pytający.

Rozwiązanie nr 1:

--This example uses both Leading and Trailing zero's.
--Avoid losing those Trailing zero's and converting embedded spaces into more zeros.
--I added a non-whitespace character ("_") to retain trailing zero's after calling Replace().
--Simply remove the RTrim() function call if you want to preserve trailing spaces.
--If you treat zero's and empty-strings as the same thing for your application,
--  then you may skip the Case-Statement entirely and just use CN.CleanNumber .
DECLARE @WackadooNumber VarChar(50) = ' 0 0123ABC D0 '--'000'--
SELECT WN.WackadooNumber, CN.CleanNumber,
       (CASE WHEN WN.WackadooNumber LIKE '%0%' AND CN.CleanNumber = '' THEN '0' ELSE CN.CleanNumber END)[AllowZero]
 FROM (SELECT @WackadooNumber[WackadooNumber]) AS WN
 OUTER APPLY (SELECT RTRIM(RIGHT(WN.WackadooNumber, LEN(LTRIM(REPLACE(WN.WackadooNumber + '_', '0', ' '))) - 1))[CleanNumber]) AS CN
--Result: "123ABC D0"

Rozwiązanie nr 2 (z przykładowymi danymi):

SELECT O.Type, O.Value, Parsed.Value[WrongValue],
       (CASE WHEN CHARINDEX('0', T.Value)  > 0--If there's at least one zero.
              AND LEN(Parsed.Value) = 0--And the trimmed length is zero.
             THEN '0' ELSE Parsed.Value END)[FinalValue],
       (CASE WHEN CHARINDEX('0', T.Value)  > 0--If there's at least one zero.
              AND LEN(Parsed.TrimmedValue) = 0--And the trimmed length is zero.
             THEN '0' ELSE LTRIM(RTRIM(Parsed.TrimmedValue)) END)[FinalTrimmedValue]
  FROM 
  (
    VALUES ('Null', NULL), ('EmptyString', ''),
           ('Zero', '0'), ('Zero', '0000'), ('Zero', '000.000'),
           ('Spaces', '    0   A B C '), ('Number', '000123'),
           ('AlphaNum', '000ABC123'), ('NoZero', 'NoZerosHere')
  ) AS O(Type, Value)--O is for Original.
  CROSS APPLY
  ( --This Step is Optional.  Use if you also want to remove leading spaces.
    SELECT LTRIM(RTRIM(O.Value))[Value]
  ) AS T--T is for Trimmed.
  CROSS APPLY
  ( --From @CadeRoux's Post.
    SELECT SUBSTRING(O.Value, PATINDEX('%[^0]%', O.Value + '.'), LEN(O.Value))[Value],
           SUBSTRING(T.Value, PATINDEX('%[^0]%', T.Value + '.'), LEN(T.Value))[TrimmedValue]
  ) AS Parsed

Wyniki:

Podsumowanie:

Możesz użyć tego, co mam powyżej, do jednorazowego usunięcia wiodących zer.
Jeśli planujesz często go używać, umieść go w funkcji Inline-Table-Valued (ITVF).
Twoje obawy dotyczące problemów z wydajnością UDF są zrozumiałe.
Jednak ten problem dotyczy tylko funkcji All-Scalar i Multi-Statement-Table Functions.
Używanie ITVF jest w porządku.

Mam ten sam problem z naszą bazą danych innej firmy.
W przypadku pól alfanumerycznych wielu jest wprowadzanych bez wiodących spacji, do cholery!
To sprawia, że ​​łączenie jest niemożliwe bez usunięcia brakujących zer wiodących.

Wniosek:

Zamiast usuwać zera wiodące, możesz rozważyć po prostu uzupełnienie przyciętych wartości zerami wiodącymi podczas łączenia.
Jeszcze lepiej, wyczyść dane w tabeli, dodając wiodące zera, a następnie odbuduj indeksy.
Myślę, że byłoby to DUŻO szybsze i mniej złożone.

SELECT RIGHT('0000000000' + LTRIM(RTRIM(NULLIF(' 0A10  ', ''))), 10)--0000000A10
SELECT RIGHT('0000000000' + LTRIM(RTRIM(NULLIF('', ''))), 10)--NULL --When Blank.

Zamiast spacji zamień 0 na „rzadki” biały znak, który normalnie nie powinien znajdować się w tekście kolumny. Podawanie wiersza jest prawdopodobnie wystarczające dla takiej kolumny. Następnie możesz normalnie LTrim i ponownie zamienić znak specjalny na 0.

Poniższe polecenie zwróci „0”, jeśli ciąg składa się wyłącznie z zer:

CASE WHEN SUBSTRING(str_col, PATINDEX('%[^0]%', str_col+'.'), LEN(str_col)) = '' THEN '0' ELSE SUBSTRING(str_col, PATINDEX('%[^0]%', str_col+'.'), LEN(str_col)) END AS str_col

To jest fajna funkcja ....

DROP FUNCTION [dbo].[FN_StripLeading]
GO
CREATE FUNCTION [dbo].[FN_StripLeading] (@string VarChar(128), @stripChar VarChar(1))
RETURNS VarChar(128)
AS
BEGIN
-- http://stackoverflow.com/questions/662383/better-techniques-for-trimming-leading-zeros-in-sql-server
    DECLARE @retVal VarChar(128),
            @pattern varChar(10)
    SELECT @pattern = '%[^'+@stripChar+']%'
    SELECT @retVal = CASE WHEN SUBSTRING(@string, PATINDEX(@pattern, @string+'.'), LEN(@string)) = '' THEN @stripChar ELSE SUBSTRING(@string, PATINDEX(@pattern, @string+'.'), LEN(@string)) END
    RETURN (@retVal)
END
GO
GRANT EXECUTE ON [dbo].[FN_StripLeading] TO PUBLIC

cast (wartość jak int) będzie zawsze działać, jeśli łańcuch jest liczbą

Moja wersja jest adaptacją pracy Arvo, z dodatkiem trochę więcej, aby zapewnić dwa inne przypadki.

1) Jeśli mamy wszystkie zera, powinniśmy zwrócić cyfrę 0.

2) Jeśli mamy spację, powinniśmy nadal zwracać pusty znak.

CASE 
    WHEN PATINDEX('%[^0]%', str_col + '.') > LEN(str_col) THEN RIGHT(str_col, 1) 
    ELSE SUBSTRING(str_col, PATINDEX('%[^0]%', str_col + '.'), LEN(str_col))
 END

replace(ltrim(replace(Fieldname.TableName, '0', '')), '', '0')

Sugestia Thomasa G. spełniła nasze potrzeby.

Pole w naszym przypadku było już ciągiem i trzeba było przyciąć tylko zera wiodące. Przeważnie wszystko jest numeryczne, ale czasami są litery, więc poprzednia konwersja INT się zawiesiła.

SELECT CAST(CAST('000000000' AS INTEGER) AS VARCHAR)

Ma to ograniczenie długości łańcucha, który można przekonwertować na INT

Jeśli używasz Snowflake SQL, możesz użyć tego:

ltrim(str_col,'0')

Funkcja ltrim usuwa wszystkie instancje wyznaczonego zestawu znaków z lewej strony.

Więc ltrim (str_col, '0') on '00000008A' zwróci '8A'

A rtrim (str_col, „0.”) Na „$ 125.00” zwróci „$ 125”

  SUBSTRING(str_col, IIF(LEN(str_col) > 0, PATINDEX('%[^0]%', LEFT(str_col, LEN(str_col) - 1) + '.'), 0), LEN(str_col))

Działa dobrze nawet z „0”, „00” i tak dalej.

Spróbuj tego:

replace(ltrim(replace(@str, '0', ' ')), ' ', '0')

Jeśli nie chcesz konwertować na int, wolę tę logikę poniżej, ponieważ może obsługiwać wartości null IFNULL (pole, LTRIM (pole, '0'))

W MySQL możesz to zrobić ...

Trim(Leading '0' from your_column)