Melhores técnicas para aparar zeros à esquerda no SQL Server?

Estou usando isso há algum tempo:

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

No entanto, recentemente, encontrei um problema com colunas com todos os caracteres "0", como '00000000', porque ele nunca encontra um caractere que não seja "0" para corresponder.

Uma técnica alternativa que eu vi é usar TRIM:

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

Isso tem um problema se houver espaços incorporados, porque eles serão transformados em "0" s quando os espaços forem transformados em "0" s.

Estou tentando evitar uma UDF escalar. Encontrei muitos problemas de desempenho com UDFs no SQL Server 2005.

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

Por que você simplesmente não lança o valor INTEGERe depois volta para VARCHAR?

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

--------
       0

Outras respostas aqui para não levar em consideração se você tiver todos os zero (ou mesmo um único zero).
Alguns sempre usam como padrão uma string vazia como zero, o que é errado quando deveria permanecer em branco.
Releia a pergunta original. Isso responde ao que o Questionador deseja.

Solução 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"

Solução # 2 (com dados de amostra):

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

Resultados:

Resumo:

Você pode usar o que tenho acima para remover os zero à esquerda.
Se você planeja reutilizá-lo muito, coloque-o em uma função com valor de tabela em linha (ITVF).
Suas preocupações sobre problemas de desempenho com UDFs são compreensíveis.
No entanto, esse problema se aplica apenas às funções All-Scalar e Functions-Table-Multi-Statement-Table.
O uso de ITVFs é perfeitamente adequado.

Eu tenho o mesmo problema com nosso banco de dados de terceiros.
Com os campos alfanuméricos, muitos são inseridos sem os espaços principais, humanos!
Isso impossibilita as junções sem limpar os zeros à esquerda ausentes.

Conclusão:

Em vez de remover os zeros à esquerda, considere apenas preencher os valores aparados com zeros antes de fazer as junções.
Melhor ainda, limpe seus dados na tabela adicionando zeros à esquerda e reconstruindo seus índices.
Eu acho que isso seria MUITO mais rápido e menos complexo.

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

Em vez de um espaço, substitua os 0 por um caractere de espaço em branco 'raro' que normalmente não deveria estar no texto da coluna. Um feed de linha provavelmente é bom o suficiente para uma coluna como esta. Então você pode LTrim normalmente e substituir o caractere especial por 0 novamente.

O seguinte retornará '0' se a sequência consistir inteiramente em zeros:

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

Isso faz uma boa função ....

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 (valor como int) sempre funcionará se string for um número

Minha versão disso é uma adaptação do trabalho de Arvo, com um pouco mais de acréscimo para garantir outros dois casos.

1) Se tivermos todos os 0s, devemos retornar o dígito 0.

2) Se temos um espaço em branco, ainda devemos retornar um caractere em branco.

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

A sugestão de Thomas G funcionou para as nossas necessidades.

O campo no nosso caso já era string e apenas os zeros à esquerda precisavam ser aparados. Principalmente, é tudo numérico, mas às vezes existem letras para que a conversão anterior do INT travasse.

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

Isso tem um limite no comprimento da string que pode ser convertida em um INT

Se você estiver usando o Snowflake SQL, poderá usar o seguinte:

ltrim(str_col,'0')

A função ltrim remove todas as instâncias do conjunto designado de caracteres do lado esquerdo.

Portanto, ltrim (str_col, '0') em '00000008A' retornaria '8A'

E rtrim (str_col, '0.') Em '$ 125,00' retornaria '$ 125'

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

Funciona bem mesmo com '0', '00' e assim por diante.

Tente o seguinte:

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

Se você não deseja converter em int, prefiro a lógica abaixo, pois ela pode manipular nulos IFNULL (campo, LTRIM (campo, '0'))

No MySQL você pode fazer isso ...

Trim(Leading '0' from your_column)