假设我们的类具有相同类型的属性（我将在C＃中描述类，但这在这里无关紧要）
class Exception
{
public string Message { get; set; }
public string StackTrace { get; set; }
public Exception InnerException { get; set; }
}
从上面的代码中可以看到，存在带有嵌套异常的异常类。
让我们创建用于存储这些异常的表
CREATE TABLE Exceptions
(
Id INT IDENTITY(1,1) NOT NULL PRIMARY KEY,
[Message] NVARCHAR(MAX) NOT NULL,
StackTrace NVARCHAR(MAX) NULL,
InnerExceptionId INT NULL,
CONSTRAINT FK__Exceptions_Id__Exceptions_InnerExceptionId
FOREIGN KEY(InnerExceptionId) REFERENCES Exceptions (Id)
);
当然，我可以创建一些可以正常工作的代码：例如一些以TVP为参数，然后循环遍历TVP的行并逐行插入新行的存储过程。
但是是否有任何SQL代码可以优雅地通过嵌套插入异常？
答案 0 :(得分：8)
Exceptions表中，获取链接到原始代理ID的生成的IDENTITY值因此，@original_list应该是输入参数。然后，您需要一个MERGE做得很好的技巧-插入后将src.id链接到dst.id。然后只需将旧值转换为新值即可。所有命令都是基于集合的，没有循环。
DECLARE @original_list TABLE (
surrogate_no int not null,
msg varchar(100) not null,
inner_surrogate_no int null
);
insert into @original_list (surrogate_no, msg, inner_surrogate_no)
values
(1000, 'err 1000', null),
(1010, 'err 1010->1000', 1000),
(1020, 'err 1020', null),
(1030, 'err 1030->1010', 1010)
-- args prepared, starting migration
DECLARE @migration TABLE (
src_id int not null,
dst_id int not null
)
merge Exceptions t
using @original_list s
on 1=0 --<< we are not looking for updates
when not matched by target then
insert (message)
values (s.msg)
output s.surrogate_no, inserted.id ---<<< here is the main trick: src.id and matching dst.id
into @migration(src_id, dst_id)
;
-- now all error messages are inserted, but none of them have InnerExceptionId
update e set
InnerExceptionId = mp.dst_id
from Exceptions e
inner join @migration m --<< get original surrogate_no
on m.dst_id = e.id
inner join @original_list o --<< grab original row
on o.surrogate_no = m.src_id
inner join @migration mp --<< locate dst.id for inner_surrogate_no
on mp.src_id = o.inner_surrogate_no
这是用于此类任务的常见解决方案。 Full source
最终数据：
| Id | Message | StackTrace | InnerExceptionId |
|----|----------------|------------|------------------|
| 1 | err 1000 | (null) | (null) |
| 2 | err 1010->1000 | (null) | 1 |
| 3 | err 1020 | (null) | (null) |
| 4 | err 1030->1010 | (null) | 2 |
通过递归CTE的Treeview：
| Message | Lvl | id | InnerExceptionID |
|------------------------------------------------|-----|----|------------------|
| err 1000 | 1 | 1 | (null) |
| err 1020 | 1 | 3 | (null) |
| err 1010->1000>>>(err 1000) | 2 | 2 | 1 |
| err 1030->1010>>>(err 1010->1000>>>(err 1000)) | 3 | 4 | 2 |
请注意，sqlfiddle不允许我在更大的脚本中运行MERGE（它总是失败，并带有分号例外），因此我将@表转换为持久性表并将合并到动态sql中，但是您不需要在真实的服务器上完成该操作。
答案 1 :(得分：3)
一些评论：
ExceptionTableType没有“订单”字段，因此，当您加载信息时，您假定读取记录的顺序将是创建记录的顺序。这绝不能保证，实际上可能会对您的结果产生奇怪的影响！InnerExceptoinId列感觉“向后”，似乎意味着“当填充时，该记录是引用记录中的InnerException”，而我不知何故希望它的使用应以其他方式起作用： “填写时，引用的记录是我的InnerException”。现在，您需要扫描整个表以查看给定记录是否存在InnerException，然后一遍又一遍，直到再也找不到任何内容。无论如何，为了与您的解决方案保持紧密联系，我创建了一个基于集合的版本。不确定它在性能方面是否会起很大作用，但是从原则上讲，它比基于游标的方法更可取=）
CREATE PROCEDURE LogException2
@exceptions ExceptionTableType READONLY
AS
DECLARE @rowcount int
SELECT source_id = IDENTITY(int, 1, 1),
insert_id = Convert(int, 0),
Message,
StackTrace
INTO #loading
FROM @exceptions
-- really should have ORDER BY here!
SELECT source_id = source_id + 0,
insert_id
INTO #feedback
FROM #loading
WHERE 1 = 2
INSERT INTO Exceptions ([Message], StackTrace, InnerExceptionId)
OUTPUT l.source_id, [inserted].Id INTO #feedback (source_id, insert_id)
SELECT l.Message,
l.StackTrace,
NULL
FROM #loading
UPDATE upd
SET InnerExceptionID = f.insert_id + 1
FROM Exceptions upd
JOIN #feedback f
ON f.insert_id = upd.Id
AND f.source_id <> 1 -- first row has no InnerExpectionId
Return(0)
GO
答案 2 :(得分：2)
想到两种方法。首先是将整个异常（嵌套和全部）序列化为XML或某种东西，并将其存储下来。我不知道在异常存储后您打算如何处理这些异常，但是序列化的文档可能是最直接的实现方法。如果需要，您可以将XML切成表格格式，如果您更喜欢的话。
另一种方法是执行您描述的内容，但不要弄乱SQL中的层次结构，而是在应用程序代码中进行。这样，当您实际上将某些东西传递到过程中时，您可以在一个集合中完成所有操作，而不必在SQL中进行循环（这在难度和难度上（从字面上看））。
在关系最好的日子里，使用关系数据库中的层次结构数据是一件痛苦的事情，因此，除非您有非常特定的需求以这种方式表示异常链，否则我将尽量避免这种情况。
答案 3 :(得分：2)
我最终用TVP和光标循环创建了存储过程。
这是我的表值参数定义：
CREATE TYPE ExceptionTableType AS TABLE
(
[Message] NVARCHAR(MAX) NOT NULL,
StackTrace NVARCHAR(MAX) NULL
);
这里是带有光标循环的存储过程
CREATE PROCEDURE LogException
@exceptions ExceptionTableType READONLY
AS
BEGIN
DECLARE @cursor CURSOR;
DECLARE @message NVARCHAR(MAX);
DECLARE @stackTrace NVARCHAR(MAX);
DECLARE @innerExceptionId INT = NULL;
DECLARE @outputTable TABLE (Id INT);
BEGIN
SET @cursor = CURSOR FOR
SELECT [Message], StackTrace
FROM @exceptions;
OPEN @cursor
FETCH NEXT FROM @cursor
INTO @message, @stackTrace;
WHILE @@FETCH_STATUS = 0
BEGIN
INSERT INTO Exceptions
([Message], StackTrace, InnerExceptionId)
OUTPUT INSERTED.Id INTO @outputTable (Id)
VALUES
(@message, @stackTrace, @innerExceptionId);
SELECT @innerExceptionId = Id
FROM @outputTable;
FETCH NEXT FROM @cursor
INTO @message, @stackTrace;
END;
CLOSE @cursor;
DEALLOCATE @cursor;
END
END
通过SQL调用存储过程的示例：
DECLARE @exceptions AS ExceptionTableType;
INSERT INTO @exceptions
([Message], [StackTrace])
VALUES
('My exception', 'Some stack trace here'),
('My inner exception', 'Dummy data'),
('My inner exception 2', 'Dummy data 2');
EXEC LogException @exceptions;
答案 4 :(得分：2)
我以前经历过这个问题，我所做的就是创建一个处理所有异常的表，然后使用标量函数来检索异常消息。然后，我们从那里开始管理一切。之后，我们仅使用标量函数来检索错误消息。
这是一个简单的示例：
CREATE TABLE tblError (
ErrorID VARCHAR(50) NOT NULL
, ErrorMsg VARCHAR(8000) NOT NULL
, CONSTRAINT PK_tblError PRIMARY KEY(ErrorID)
)
CREATE FUNCTION Error (@ErrorID VARCHAR(20))
RETURNS VARCHAR(8000)
AS
BEGIN
DECLARE
@Error VARCHAR(8000)
SELECT
@Error = ErrorMsg
FROM
tblError
WHERE
ErrorID = @ErrorID
RETURN ISNULL(@Error , 'Undefined Error')
END
INSERT INTO tblError (ErrorID, ErrorMsg)
VALUES
('0x0000','Cannot Divide by ZERO')
DECLARE
@ErrorMessage VARCHAR(250)
, @Demo INT = 0
IF @Demo = 0
BEGIN
SET @ErrorMessage = dbo.Error('0x0000')
RAISERROR(@ErrorMessage,11,1)
END
ELSE
BEGIN
SELECT CAST(100 AS FLOAT)/@Demo
END
对于ErrorID，我们为不同的错误组定义了唯一的序列。因此，您可以根据需要进行扩展。