SQL Modulo Function dá valor errado?

De acordo com a Wikipedia , o padrão SQL implementa a versão truncada do %operador que para um número a = nq + r onde q é um número inteiro, define o resto r como:

r = a - n [ a / n ] onde [] é a função de parte inteira (parte inteira) ¹

Portanto, inserir o exemplo na equação resulta

r = -34086.1576962834 - 360.0[-34086.1576962834/360.0] 

  = -34086.1576962834 - 360.0[-94.68377138]

  = -34086.1576962834 - 360.0(-94)

  = -246.1576962834

Portanto, de acordo com o padrão SQL, a %função está funcionando conforme o esperado. Consulte Postgres e MySQL implementando o padrão de maneira semelhante.

Se você deseja obter o mesmo resultado de um método que usa divisão horizontal em vez da parte integral quando o dividendo é negativo, você pode adicionar o divisor ao resultado como [ x ] + 1 = FLOOR( x ) quando x é negativo .

r + n = a - n[a/n] + n

      = a - n([a/n] + 1) 

      = a - n(FLOOR(a/n))

Ou, conforme demonstrado neste SO, a resposta (n + a % n) % n) converterá para o método de divisão por piso, independentemente de o dividendo ser positivo ou negativo ² .

Isto é o que o SQL Standard tem a dizer: (graças a ypercubeᵀᴹ e esta postagem no blog ):

<modulus expression> ::=
  MOD <left paren>
      <numeric value expression dividend>
      <comma>
      <numeric value expression divisor>
      <right paren>
...
If <modulus expression> is specified,
then the declared type of each
<numeric value expression>
shall be exact numeric with scale 0 (zero).
The declared type of the result is the
declared type of the immediately contained
<numeric value expression divisor>.
...
9)If <modulus expression> is specified,
  then let N be the value of the immediately
  contained <numeric value expression
  dividend> and let M be the value of the
  immediately contained <numeric value
  expression divisor>.
  Case:
    a)If at least one of N and M is the null
      value, then the result is the null value.
    b)If M is zero,
      then an exception condition is raised:
      data exception—division by zero.
    c)Otherwise, the result is the unique exact
      numeric value R with scale 0 (zero) such
      that all of the following are true:
      i)R has the same sign as N.
      ii)The absolute value of R is less than
         the absolute value of M.
      iii)N = M * K + R for some exact numeric 
          value K with scale 0 (zero).

Portanto, você notará muita "escala de zero", mas isso não é relevante, pois se removermos essa restrição de N , M e R , o cálculo permanecerá inalterado. Movendo as coisas temos:

R = N - M * K com || R || < || M || e SIGN( R ) = SIGN( N ).

Isso não é math.stackexchange.com , então não farei uma prova formal, mas essas duas restrições implicam que K nessa instância é [ N / M ] e não FLOOR( N / M ).

Usando seu exemplo temos então:

R = -34086.1576962834 - 360.0*(-94)
  = -246.1576962834

¹ Isso não é o mesmo que a FLOORfunção quando aplicada a valores negativos.

² A prova é deixada como um exercício para o leitor porque o autor não toca em um livro de matemática há mais de 10 anos.

Isso parece ser um problema de como o SQL Server calcula o módulo com números negativos.

Você notará que, se pegar sua calculadora científica (estou usando o Windows embutido calc.exeno modo científico) e fizer as contas para um quociente positivo e um quociente negativo, obterá 113.nnn e 246. números nnn:

Se dividirmos a matemática do módulo e fizermos "o caminho mais longo", poderemos ver o que o SQL Server está fazendo:

DECLARE @dividend numeric(30,15) = -34086.1576962834;
DECLARE @divisor numeric(30,15)  = 360.0;

SELECT QuotientFloor          = FLOOR(@dividend / @divisor),
       QuotientCeiling        = CEILING(@dividend / @divisor),
       Remainder              = @dividend % @divisor,
       DividendInput          = @dividend,
       DivisorInput           = @divisor,
       QuotientFloorPlusMod   = ( FLOOR(@dividend / @divisor) * @divisor ) + (@dividend % @divisor),
       QuotientCeilingPlusMod = ( CEILING(@dividend / @divisor) * @divisor ) + (@dividend % @divisor);

IMHO, isso é um bug

O SQL Server está sempre fazendo um FLOORpara calcular o quociente, em vez de sempre arredondar para zero. Na minha opinião, isso é um bug, pois as regras da matemática nos dizem que devemos arredondar para zero, em vez de arredondar para baixo.

O artigo da Wikipedia sobre "operação de módulo" mostra que existem diferentes interpretações do que "módulo" significa, particularmente quando se move para números reais - embora os números naturais tenham uma definição de módulo mais universalmente compreendida.

De acordo com o artigo da Wikipedia vinculado acima, o padrão ISO SQL exige a fórmula de "divisão truncada":

Muitas implementações usam divisão truncada, para a qual o quociente é definido por onde [] é a função de parte integral (arredondamento para zero), ou seja, o truncamento para zero dígitos significativos. Assim, de acordo com a equação (1), o resto tem o mesmo sinal do dividendo:

Observe que isso exige arredondamento para zero . Este é o comportamento que a maioria das pessoas espera, porque o arredondamento para zero parece "natural" para muitas pessoas ao arredondar.

Em vez disso, o SQL Server usa o método "divisão por piso":

Donald Knuth promove a divisão floored, para a qual o quociente é definido por onde ⌊⌋ é a função floor (arredondamento para baixo). Assim, de acordo com a equação (1), o resto tem o mesmo sinal do divisor:

Observe que isso exige arredondamento para baixo .

A Microsoft provavelmente não mudará o comportamento

O SQL Server tem esse comportamento há tanto tempo que não esperaria que o SQL Server mudasse sua implementação para usar a fórmula de "divisão truncada" exigida pelo padrão ISO SQL para ambos %e mod(). Alterar essa funcionalidade agora resultaria em anos de código que dependem do comportamento existente para quebrar.

Em vez disso, eu esperaria que a Microsoft documentasse claramente a funcionalidade existente para deixar claro qual método eles estão usando para calcular o módulo. Se tivermos sorte, eles podem introduzir uma nova sintaxe que executa o módulo usando o outro método também, para que as pessoas possam selecionar o comportamento apropriado para suas necessidades.