我真的被困在这个问题上了。我在 SQL 方面有广泛的背景，但我刚开始一份新工作，他们更喜欢使用 LINQ 进行简单查询。 于是本着学习的精神，我尝试重写了这个简单的SQL查询:

SELECT
    AVG([Weight] / [Count]) AS [Average],
    COUNT(*) AS [Count]
FROM [dbo].[Average Weight]
WHERE
    [ID] = 187

为了清楚起见，这里是表架构:

CREATE TABLE [dbo].[Average Weight]
(
    [ID] INT NOT NULL,
    [Weight] DECIMAL(8, 4) NOT NULL,
    [Count] INT NOT NULL,
    [Date] DATETIME NOT NULL,
    PRIMARY KEY([ID], [Date])
)

这是我想出的:

var averageWeight = Data.Context.AverageWeight
    .Where(i => i.ID == 187)
    .GroupBy(w => w.ID)
    .Select(i => new { Average = i.Average(a => a.Weight / a.Count), Count = i.Count() });

Data.Context.AverageWeight 是由 SQLMetal 生成的 Linq To SQL 对象。如果我尝试 averageWeight.First()，我会得到一个 OverflowException。我使用 SQL Profiler 查看 LINQ 生成的参数化查询是什么样的。重新缩进后看起来像这样:

EXEC sp_executesql N'
SELECT TOP(1)
    [t2].[value] AS [Average],
    [t2].[value2] AS [Count]
FROM (
        SELECT
            AVG([t1].[value]) AS [value],
            COUNT(*) AS [value2]
        FROM (
                SELECT
                    [t0].[Weight] / (CONVERT(DECIMAL(29, 4), [t0].[Count])) AS 
                    [value],
                    [t0].[ID]
                FROM [dbo].[Average Weight] AS [t0]
             ) AS [t1]
        WHERE
            ([t1].[ID] = @p0)
        GROUP BY
            [t1].[ID]
     ) AS [t2]',
    N'@p0 int',
     @p0 = 187

除了过多的嵌套，我只看到一个问题:DECIMAL(29, 4)。 (查询运行并给出预期结果。)据我了解，任何超过 28 的值都会溢出 C# 十进制数据类型。 [Count] 是一个 INT，所以它确实需要转换，但 [Weight] 是一个 DECIMAL(8, 4)。我不知道为什么 LINQ 会使用这么大的数据类型。

为什么 LINQ 会转换为导致溢出的数据类型？无论如何要改变这种行为？还是我走在正确的轨道上？

另外，Data.Context.AverageWeight 是由 SqlMetal 生成的，我验证了权重是小数并且列属性是正确的 (Decimal(8,4))。

提前致谢。

更新: 所以看起来 LINQ to SQL 可能是罪魁祸首。我像这样更改了我的 LINQ:

var averageWeight = Data.Context.AverageWeight
    .Where(i => i.ID == 187)
    .GroupBy(w => w.ID)
    .Select(i => new { Average = i.Average(a => a.Weight) / (decimal)i.Average(a => a.Count), Count = i.Count() });

现在生成的 SQL 看起来像这样:

SELECT TOP(1)
    [t2].[value] AS [Average],
    [t2].[value2] AS [Count]
FROM (
        SELECT
            AVG([t1].[value]) AS [value],
            COUNT(*) AS [value2]
        FROM (
                SELECT
                    [t0].[Weight] / (CONVERT(DECIMAL(16, 4), [t0].[Count])) AS [value],
                    [t0].[ID]
                FROM [dbo].[Average Weight] AS [t0]
             ) AS [t1]
        WHERE
            ([t1].[ID] = 187)
        GROUP BY
            [t1].[ID]
     ) AS [t2]

结果是:

Average                  Count
0.000518750000000        16

以前的方法给出了:

Average                  Count
0.000518750000000000000  16

不再有溢出，但查询效率降低了。我不知道为什么 LINQ to SQL 会转换为如此高的精度。没有其他变量如此精确。据我所知，我无法在 LINQ 中执行任何强制数据类型的操作。

有什么想法吗？

最佳答案

我不是专家，但是查看 SQL-CLR 类型映射表(例如 http://msdn.microsoft.com/en-us/library/bb386947.aspx)您可以看到 SQL 十进制值被转换为 CLR System.Decimal 类型和 CLR System.Decimal 值转换为 SQL DECIMAL(29,4) 类型。

因此在您的示例中，a.Weight 作为 SQL 小数被转换为 CLR System.Decimal. a.Weight 因此 a.Count 被视为 System.Decimal 除法，正确的操作数 (a.Count) 必须转换为 CLR System.Decimal. 然后，Linq 将此类型转换回 SQL，这导致 Count 被转换为 DECIMAL(29,4)。

不幸的是，

a.Weight / (double) a.Count

将不起作用，因为必须将正确的操作数转换为 System.Decimal 但 double 不能像 int 那样自动转换。然而，

(double) a.Weight / a.Count

将起作用，因为除法现在被视为 double 除法，而不是 System.Decimals，，因此生成的 SQL 如下所示:

SELECT (CONVERT(Float,[t0].[Weight])) / (CONVERT(Float,[t0].[Count])) AS [value]
...

您真正想要的是让 Linq 将 a.Count 视为已经是小数，而不是 int。您可以通过更改 DBML 文件 (see here) 中 Count 属性的类型来执行此操作。当我这样做时，Linq 查询:

var averageweight = context.AverageWeights
            .Where(i => i.ID == 187)
            .GroupBy(w => w.ID)
            .Select(i => new {Average = i.Average(a => a.Weight/a.Count), Count = i.Count()});

SQL 中的结果:

SELECT AVG([t0].[Weight] / [t0].[Count]) AS [Average], COUNT(*) AS [Count]
FROM [dbo].[AverageWeight] AS [t0]
WHERE [t0].[ID] = @p0
GROUP BY [t0].[ID]

这是期望的结果。但是，更改 DBML 文件中 Count 属性的类型可能会产生其他意想不到的副作用。

顺便说一句，从您更新的 Linq 查询生成的 SQL 似乎是错误的。 Linq 明确要求所有权重的平均值除以所有计数的平均值，但这不是 SQL 所做的。当我编写相同的 Linq 查询时，我得到的 SQL 是:

SELECT [t1].[value] / (CONVERT(Decimal(29,4),[t1].[value2])) AS [Average], [t1].[value3] AS [Count]
FROM (
    SELECT AVG([t0].[Weight]) AS [value], AVG([t0].[Count]) AS [value2], COUNT(*) AS [value3]
    FROM [dbo].[Average Weight] AS [t0]
    WHERE [t0].[ID] = @p0
    GROUP BY [t0].[ID]
    ) AS [t1]

请注意，有两次调用 AVG 而不是一次。另请注意，到 Decimal(29,4) 的转换仍然存在，因为 Linq 仍在执行 System.Decimal 除法。

关于c# - LINQ to SQL 转换溢出，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/5111903/