web-dev-qa-db-ja.com

SQLでは199.96 - 0 = 200なのはなぜですか？

私は何人かの顧客におかしな請求書をもらっています。私は中心的な問題を切り分けることができました：

SELECT 199.96 - (0.0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4)))) -- 200 what the?
SELECT 199.96 - (0.0 * FLOOR(1.0 * CAST(199.96 AS DECIMAL(19, 4)))) -- 199.96
SELECT 199.96 - (0.0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * 199.96)) -- 199.96

SELECT 199.96 - (CAST(0.0 AS DECIMAL(19, 4)) * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4)))) -- 199.96
SELECT 199.96 - (CAST(0.0 AS DECIMAL(19, 4)) * FLOOR(1.0 * CAST(199.96 AS DECIMAL(19, 4))))                         -- 199.96
SELECT 199.96 - (CAST(0.0 AS DECIMAL(19, 4)) * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * 199.96))                         -- 199.96

-- It gets weirder...
SELECT (0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4)))) -- 0
SELECT (0 * FLOOR(1.0 * CAST(199.96 AS DECIMAL(19, 4))))                         -- 0
SELECT (0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * 199.96))                         -- 0

-- so... ... 199.06 - 0 equals 200... ... right???
SELECT 199.96 - 0 -- 199.96 ...NO....

誰かが手掛かりを持っている、一体何がここで起こっているのか？つまり、それは確かにdecimalデータ型と関係があるのですが、頭を包むことはできません。

数値リテラルがどのようなデータ型であるかについては多くの混乱がありましたので、私は実際の行を表示することにしました。

PS.SharePrice - (CAST((@InstallmentCount - 1) AS DECIMAL(19, 4)) * CAST(FLOOR(@InstallmentPercent * PS.SharePrice) AS DECIMAL(19, 4))))

PS.SharePrice DECIMAL(19, 4)

@InstallmentCount INT

@InstallmentPercent DECIMAL(19, 4)

DECIMAL(19, 4)とは異なる型のオペランドを持つ各操作の結果が、外部コンテキストに適用される前に明示的にキャストされるようにしました。

それにもかかわらず、結果は200.00のままです。

私は今、皆さんがあなたのコンピュータ上で実行できる煮詰めたサンプルを作成しました。

DECLARE @InstallmentIndex INT = 1
DECLARE @InstallmentCount INT = 1
DECLARE @InstallmentPercent DECIMAL(19, 4) = 1.0
DECLARE @PS TABLE (SharePrice DECIMAL(19, 4))
INSERT INTO @PS (SharePrice) VALUES (599.96)

-- 2000
SELECT
  IIF(@InstallmentIndex < @InstallmentCount,
  FLOOR(@InstallmentPercent * PS.SharePrice),
  1999.96)
FROM @PS PS

-- 2000
SELECT
  IIF(@InstallmentIndex < @InstallmentCount,
  FLOOR(@InstallmentPercent * CAST(599.96 AS DECIMAL(19, 4))),
  1999.96)
FROM @PS PS

-- 1996.96
SELECT
  IIF(@InstallmentIndex < @InstallmentCount,
  FLOOR(@InstallmentPercent * 599.96),
  1999.96)
FROM @PS PS

-- Funny enough - with this sample explicitly converting EVERYTHING to DECIMAL(19, 4) - it still doesn't work...
-- 2000
SELECT
  IIF(@InstallmentIndex < @InstallmentCount,
  FLOOR(@InstallmentPercent * CAST(199.96 AS DECIMAL(19, 4))),
  CAST(1999.96 AS DECIMAL(19, 4)))
FROM @PS PS

今私は何かを持っています...

-- 2000
SELECT
  IIF(1 = 2,
  FLOOR(CAST(1.0 AS decimal(19, 4)) * CAST(199.96 AS DECIMAL(19, 4))),
  CAST(1999.96 AS DECIMAL(19, 4)))

-- 1999.9600
SELECT
  IIF(1 = 2,
  CAST(FLOOR(CAST(1.0 AS decimal(19, 4)) * CAST(199.96 AS DECIMAL(19, 4))) AS INT),
  CAST(1999.96 AS DECIMAL(19, 4)))

とにかく地面の底が整数を返すことになっているもの。何が起きてる？ :-D

私は今、本当にそれを本質的なものにすることができたと思います。

-- 1.96
SELECT IIF(1 = 2,
  CAST(1.0 AS DECIMAL (36, 0)),
  CAST(1.96 AS DECIMAL(19, 4))
)

-- 2.0
SELECT IIF(1 = 2,
  CAST(1.0 AS DECIMAL (37, 0)),
  CAST(1.96 AS DECIMAL(19, 4))
)

-- 2
SELECT IIF(1 = 2,
  CAST(1.0 AS DECIMAL (38, 0)),
  CAST(1.96 AS DECIMAL(19, 4))
)
sql-servertsqlprecisionsql-server-2016sqldatatypes
83
Silverdust

何が起こっているのかを見ることができるように、これを少し展開することから始める必要があります。

SELECT 199.96 - 
    (
        0.0 * 
        FLOOR(
            CAST(1.0 AS DECIMAL(19, 4)) * 
            CAST(199.96 AS DECIMAL(19, 4))
        )
    )

それでは、減算処理の両側でSQL Serverが使用している型を正確に見てみましょう。

SELECT  SQL_VARIANT_PROPERTY (199.96     ,'BaseType'),
    SQL_VARIANT_PROPERTY (199.96     ,'Precision'),
    SQL_VARIANT_PROPERTY (199.96     ,'Scale')

SELECT  SQL_VARIANT_PROPERTY (0.0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4)))  ,'BaseType'),
    SQL_VARIANT_PROPERTY (0.0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4)))  ,'Precision'),
    SQL_VARIANT_PROPERTY (0.0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4)))  ,'Scale')

結果：

数字5 2 
数字38 1

したがって199.96はnumeric(5,2)で、長いFloor(Cast(etc))はnumeric(38,1)です。

減算演算の 結果の精度と位取りの規則 （つまり：e1 - e2）は次のようになります。

精度：max（s1、s2）+ max（p1-s1、p2-s2）+ 1
スケール：最大（s1、s2）

これは次のように評価されます。

精度：max（1,2）+ max（38-1、5-2）+ 1 => 2 + 37 + 1 =>40
スケール：max（1,2）=>2

numeric(38,1)がどこから来たのかを知るためにルールリンクを使うこともできます（ヒント：2つの精度19の値を掛けた）。

しかし：

  • 結果の精度と位取りの絶対最大値は38です。結果の精度が38より大きい場合は38に減り、対応する位取りは結果の整数部分が切り捨てられないようにするために減ります。乗算や除算のような場合には、10進精度を維持するためにスケールファクタは減らされませんが、オーバーフローエラーは発生します。

おっとっと。精度は40です。精度を下げる必要があります。精度を下げると、常に最下位桁が切り捨てられるので、スケールも小さくなります。 式の最終的な結果の型はnumeric(38,0)になり、これは199.96の場合は200に丸められます

大部分の式の中からCAST()操作を式全体の結果を囲むようにoneCAST()に移動して統合することでおそらくこれを修正できます。したがって、この：

SELECT 199.96 - 
    (
        0.0 * 
        FLOOR(
            CAST(1.0 AS DECIMAL(19, 4)) * 
            CAST(199.96 AS DECIMAL(19, 4))
        )
    )

になります：

SELECT CAST( 199.96 - ( 0.0 * FLOOR(1.0 * 199.96) ) AS decimial(19,4))

私は外のキャストも削除するかもしれません。

ここでは、期待される結果ではなく、現在の精度に合わせて型を選択する必要があることをここで学びます。 SQL Serverは、オーバーフローを回避するために算術演算中にこれらの型を変換するため、大きな精度の数値を求めるだけでは意味がありません。

詳しくは：

77
Stanislav Kundii

次の文に含まれるデータ型に注目してください。

SELECT 199.96 - (0.0 * FLOOR(CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4))))
  1. NUMERIC(19, 4) * NUMERIC(19, 4)はNUMERIC(38, 7)です（下記参照）
    • FLOOR(NUMERIC(38, 7))はNUMERIC(38, 0)です（下記参照）
  2. 0.0はNUMERIC(1, 1) です。
    • NUMERIC(1, 1) * NUMERIC(38, 0)はNUMERIC(38, 1)です
  3. 199.96はNUMERIC(5, 2) です。
    • NUMERIC(5, 2) - NUMERIC(38, 1)はNUMERIC(38, 1)です（下記参照）

これが、なぜあなたが200.0の代わりに199.96（10進数の後の1桁で、0ではない）になったのかを説明します。

ノート：

FLOOR は、指定された数値式以下の最大の整数を返し、結果は入力と同じ型になります。 INTはINT、FLOATはFLOAT、NUMERIC（x、y）はNUMERIC（x、0）を返します。

によると アルゴリズム ：

Operation | Result precision                    | Result scale*
e1 * e2   | p1 + p2 + 1                         | s1 + s2
e1 - e2   | max(s1, s2) + max(p1-s1, p2-s2) + 1 | max(s1, s2)

*結果の精度と位取りの絶対最大値は38です。結果の精度が38より大きい場合は38に減り、結果の整数部分が切り捨てられないようにするために対応する位取りが減ります。

この説明には、加算演算と乗算演算の中でスケールがどれだけ正確に縮小されるかについての詳細も含まれています。その説明に基づいて：

  • NUMERIC(19, 4) * NUMERIC(19, 4)はNUMERIC(39, 8)で、NUMERIC(38, 7)に固定されています
  • NUMERIC(1, 1) * NUMERIC(38, 0)はNUMERIC(40, 1)で、NUMERIC(38, 1)に固定されています
  • NUMERIC(5, 2) - NUMERIC(38, 1)はNUMERIC(40, 2)で、NUMERIC(38, 1)に固定されています

これが私のJavaScriptでのアルゴリズムの実装の試みです。結果をSQL Serverと照合しました。それはあなたの質問の非常に本質的な部分に答えます。

// https://docs.Microsoft.com/en-us/sql/t-sql/data-types/precision-scale-and-length-transact-sql?view=sql-server-2017

function numericTest_mul(p1, s1, p2, s2) {
  // e1 * e2
  var precision = p1 + p2 + 1;
  var scale = s1 + s2;

  // see notes in the linked article about multiplication operations
  var newscale;
  if (precision - scale < 32) {
    newscale = Math.min(scale, 38 - (precision - scale));
  } else if (scale < 6 && precision - scale > 32) {
    newscale = scale;
  } else if (scale > 6 && precision - scale > 32) {
    newscale = 6;
  }

  console.log("NUMERIC(%d, %d) * NUMERIC(%d, %d) yields NUMERIC(%d, %d) clamped to NUMERIC(%d, %d)", p1, s1, p2, s2, precision, scale, Math.min(precision, 38), newscale);
}

function numericTest_add(p1, s1, p2, s2) {
  // e1 + e2
  var precision = Math.max(s1, s2) + Math.max(p1 - s1, p2 - s2) + 1;
  var scale = Math.max(s1, s2);

  // see notes in the linked article about addition operations
  var newscale;
  if (Math.max(p1 - s1, p2 - s2) > Math.min(38, precision) - scale) {
    newscale = Math.min(precision, 38) - Math.max(p1 - s1, p2 - s2);
  } else {
    newscale = scale;
  }

  console.log("NUMERIC(%d, %d) + NUMERIC(%d, %d) yields NUMERIC(%d, %d) clamped to NUMERIC(%d, %d)", p1, s1, p2, s2, precision, scale, Math.min(precision, 38), newscale);
}

function numericTest_union(p1, s1, p2, s2) {
  // e1 UNION e2
  var precision = Math.max(s1, s2) + Math.max(p1 - s1, p2 - s2);
  var scale = Math.max(s1, s2);

  // my idea of how newscale should be calculated, not official
  var newscale;
  if (precision > 38) {
    newscale = scale - (precision - 38);
  } else {
    newscale = scale;
  }

  console.log("NUMERIC(%d, %d) + NUMERIC(%d, %d) yields NUMERIC(%d, %d) clamped to NUMERIC(%d, %d)", p1, s1, p2, s2, precision, scale, Math.min(precision, 38), newscale);
}

/*
 * first example in question
 */

// CAST(1.0 AS DECIMAL(19, 4)) * CAST(199.96 AS DECIMAL(19, 4))
numericTest_mul(19, 4, 19, 4);

// 0.0 * FLOOR(...)
numericTest_mul(1, 1, 38, 0);

// 199.96 * ...
numericTest_add(5, 2, 38, 1);

/*
 * IIF examples in question
 * the logic used to determine result data type of IIF / CASE statement
 * is same as the logic used inside UNION operations
 */

// FLOOR(DECIMAL(38, 7)) UNION CAST(1999.96 AS DECIMAL(19, 4)))
numericTest_union(38, 0, 19, 4);

// CAST(1.0 AS DECIMAL (36, 0)) UNION CAST(1.96 AS DECIMAL(19, 4))
numericTest_union(36, 0, 19, 4);

// CAST(1.0 AS DECIMAL (37, 0)) UNION CAST(1.96 AS DECIMAL(19, 4))
numericTest_union(37, 0, 19, 4);

// CAST(1.0 AS DECIMAL (38, 0)) UNION CAST(1.96 AS DECIMAL(19, 4))
numericTest_union(38, 0, 19, 4);
20
Salman A