Die Ausführung kann nicht fortgesetzt werden, da sich die Sitzung im Kill-Status befindet. beim Erstellen eines Clustered-Index

Beim Versuch, einen Clustered-Index zu erstellen, wird die folgende Fehlermeldung angezeigt

Die Anweisung wurde beendet.
Meldung 596, Ebene 21,
Status 1, Zeile 0 Die Ausführung kann nicht fortgesetzt werden, da sich die Sitzung im Status "Töten" befindet.

Meldung 0, Ebene 20, Status 0, Zeile 0 Beim
aktuellen Befehl ist ein schwerwiegender Fehler aufgetreten. Die Ergebnisse, falls vorhanden, sollten verworfen werden.

Der Index lautet:

BEGIN TRANSACTION
SET QUOTED_IDENTIFIER ON
SET ARITHABORT ON
SET NUMERIC_ROUNDABORT OFF
SET CONCAT_NULL_YIELDS_NULL ON
SET ANSI_NULLS ON
SET ANSI_PADDING ON
SET ANSI_WARNINGS ON
COMMIT

BEGIN TRANSACTION
GO

CREATE CLUSTERED INDEX IX_CO_DES_INPUT 
ON dbo.CO_DES_INPUT(DESIGN_ID, PRODUCT_INPUT_NUM, INPUT_NAME)
          WITH(STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, 
               ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
GO

ALTER TABLE dbo.CO_DES_INPUT 
  SET (LOCK_ESCALATION = TABLE)
GO
COMMIT

Ich verwende Microsoft SQL Server 2012 (SP3) (KB3072779) - 11.0.6020.0 (X64) Standard Edition (64-Bit) unter Windows NT 6.3 (Build 9600 :)

ich bin gerannt

DBCC CheckDB ('concept-test') WITH NO_INFOMSGS, ALL_ERRORMSGS  

und es wurden keine Probleme gefunden

Ich befürchte, dass meine Datenbank beschädigt ist, da ich diesen Fehler erhalte. Wie kann ich mein Problem beheben und diesen Index auf den Tisch legen?

Nur ein Hinweis zu: SQL Server 2017 (wo ich diesen Fehler festgestellt habe) und einigen Versionen von 2016, um möglicherweise andere Zeit zu sparen:

Vor SQL Server 2017 CU8 (auch 2016 SP1 CU9 und 2016 SP2 CU1) gab es ein Problem, bei dem partitionierte Tabellen mit inkrementellen Statistiken diesen Fehler generierten, wenn der DML-Vorgang eine automatische Statistikaktualisierung verursachte.

Die minimale KB-Seite ist hier:

https://support.microsoft.com/en-us/help/4163478/fix-access-violation-when-incremental-statistics-automatically-updated

Die Installation einer späteren als der oben aufgeführten CU behebt das Problem.

Dies kann durch Korruption des Index verursacht werden,

Der beste Weg, dies zu verwalten, ist das Löschen des alten Index, der beschädigt ist.

DROP INDEX dbo.CO_DES_INPUT.IX_CO_DES_INPUT 

Und als die Abfrage in Fragen ausführen, sollte es gut funktionieren, wenn alle Datensätze eindeutig sind. in den angegebenen Spalten.

In einer Datenbank, die für Always On Availability Groups konfiguriert ist, kann dieses Verhalten auch auftreten, wenn sich die Availability Group im SYNCHRONOUS-Modus befindet und Secondaries offline sind oder angehalten wurden. Dies ist ein Nebeneffekt von Anwendungsservern. Vielen Dank,

Etwas, das ich unabsichtlich gefunden habe: Wenn Sie Indizes in einer indizierten Ansicht deaktivieren / neu erstellen, wird der gleiche Fehler angezeigt, wenn Sie versuchen, einen oder mehrere der nicht gruppierten Indizes neu zu erstellen, bevor Sie die gruppierten Indizes erstellen oder REBUILD ALL verwenden.

Ich erhalte immer diesen Fehler, wenn ich eine laufende Abfrage habe, einen Always On AG-Listener verwende, eine der AG-Datenbanken verwende und ein Failover vorliegt:

.Net SqlClient-Datenprovider: Nachricht 596, Ebene 21, Status 1, Zeile 0 Die Ausführung kann nicht fortgesetzt werden, da sich die Sitzung im Kill-Status befindet. .Net SqlClient-Datenprovider: Nachricht 0, Ebene 20, Status 0, Zeile 0 Beim aktuellen Befehl ist ein schwerwiegender Fehler aufgetreten. Die Ergebnisse, falls vorhanden, sollten verworfen werden.

Sehr einfach zu reproduzieren! Natürlich kann es auch andere Gründe geben, aber dies ist die einzige Instanz, bei der ich diese Art von Fehler erhalte ...

Ich kann dieses Problem in einem relativ kleinen C # -Programm reproduzieren, das asynchrone Verbindungen verwendet, bin mir jedoch nicht zu 100% sicher, warum. Hier ist mein Repro-Programm für den Fall, dass andere es ausprobieren möchten - ich vermute, dass es eine Reihe von Dingen gibt, die perfekt aufeinander abgestimmt sein müssen, damit dies geschieht:

• Verbindungspooling aktiviert
• Verwenden des Identitätswechsels im Verbindungspool, Deaktivieren des Zurücksetzens dieses Identitätswechselkontexts im Verbindungspool

void Main()
{
    var impersonateMyself = System.Security.Principal.WindowsIdentity.GetCurrent().Name;

    var testCommand = "SELECT TOP 1 * FROM sys.objects";
    var calls = Enumerable.Repeat(
        $@"{testCommand};",
        10
    );
    var impersonatedCalls = Enumerable.Repeat(
        $@"EXECUTE AS LOGIN = '{impersonateMyself} WITH NO REVERT';  {testCommand}; REVERT;",
        10
    );
    Dictionary<string, object> dict = new Dictionary<string, object>()
    {
    };

    // Scenario 1: Impersonated Calls, With connection pooling -- will randomly fail
    Parallel.ForEach(
        impersonatedCalls,
        c => new SqlAsync("Data Source=devsql2;Initial Catalog=Test;Integrated Security=true;Max Pool Size=2;").AsyncSqlCall<List<A>>(c, CommandType.Text, handleResultAsync, dict).Dump());

    Parallel.ForEach(
        impersonatedCalls,
        c => new SqlSync("Data Source=devsql2;Initial Catalog=Test;Integrated Security=true;Max Pool Size=2;").SyncSqlCall<List<A>>(c, CommandType.Text, handleResultSync, dict).Dump());


    // Scenario 2: Normal calls, with connection pooling -- should succeed every time
    Parallel.ForEach(
        calls,
        c => new SqlAsync("Data Source=devsql2;Initial Catalog=Test;Integrated Security=true;Max Pool Size=2;").AsyncSqlCall<List<A>>(c, CommandType.Text, handleResultAsync, dict).Dump());

    Parallel.ForEach(
        calls,
        c => new SqlSync("Data Source=devsql2;Initial Catalog=Test;Integrated Security=true;Max Pool Size=2;").SyncSqlCall<List<A>>(c, CommandType.Text, handleResultSync, dict).Dump());



// Scenario 3: Impersonated Calls, WITHOUT connection pooling -- should succeed every time
    Parallel.ForEach(
        impersonatedCalls,
        c => new SqlAsync("Data Source=devsql2;Initial Catalog=Test;Integrated Security=true;Max Pool Size=200;").AsyncSqlCall<List<A>>(c, CommandType.Text, handleResultAsync, dict).Dump());

    Parallel.ForEach(
        impersonatedCalls,
        c => new SqlSync("Data Source=devsql2;Initial Catalog=Test;Integrated Security=true;Max Pool Size=200;").SyncSqlCall<List<A>>(c, CommandType.Text, handleResultSync, dict).Dump());
}

public class SqlSync
{
    private readonly string _connectionString;
    public int Timeout {get; set;}

    public SqlSync(string connString)
    {
        _connectionString = connString;
        Timeout = 30;
    }

    public T SyncSqlCall<T>(string commandText, CommandType type, Func<SqlDataReader, T> handleResult, Dictionary<string, object> parameters = null)
    {
        using (SqlConnection conn = new SqlConnection(_connectionString))
        using (SqlCommand cmd = new SqlCommand(commandText, conn))
        {
            cmd.CommandTimeout = Timeout;
            cmd.CommandType = CommandType.Text;

            if (parameters != null)
            {
                foreach (KeyValuePair<string, object> kvp in parameters)
                    cmd.Parameters.AddWithValue(kvp.Key, kvp.Value ?? DBNull.Value);
            }

            conn.Open();

            using (var rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                return handleResult(rdr);
        }
    }
}

public class SqlAsync
{
    private readonly string _connectionString;
    public int Timeout { get; set; }

    public SqlAsync(string connString)
    {
        _connectionString = connString;
        Timeout = 30;
    }

    public Task<T> AsyncSqlCall<T>(string sp, CommandType commandType, Func<SqlDataReader, Task<T>> handleResult, Dictionary<string, object> parameters = null)
    {
        return AsyncSqlCall<T>(sp, commandType, (reader, token) => handleResult(reader), CancellationToken.None, parameters);
    }

    public async Task<T> AsyncSqlCall<T>(string commandText, CommandType type, Func<SqlDataReader, CancellationToken, Task<T>> handleResult, CancellationToken cancellationToken, Dictionary<string, object> parameters = null)
    {
        using (SqlConnection conn = new SqlConnection(_connectionString))
        using (SqlCommand cmd = new SqlCommand(commandText, conn))
        {
            cmd.CommandTimeout = Timeout;
            cmd.CommandType = CommandType.Text;

            if (parameters != null)
            {
                foreach (KeyValuePair<string, object> kvp in parameters)
                    cmd.Parameters.AddWithValue(kvp.Key, kvp.Value ?? DBNull.Value);
            }

            await conn.OpenAsync(cancellationToken);

//          if (conn.State != ConnectionState.Open)
//              await Task.Delay(TimeSpan.FromMilliseconds(10));
            using (var rdr = await cmd.ExecuteReaderAsync(CommandBehavior.CloseConnection, cancellationToken))
                return await handleResult(rdr, cancellationToken);
        }
    }
}

public class A
{
    public string object_name { get; set; }
}

public static Func<SqlDataReader, Task<List<A>>> handleResultAsync = (SqlDataReader sdr) =>
{
    var result = new List<A>();
    while (sdr.Read())
    {
        result.Add(new A { object_name = sdr.GetFieldValue<string>(0) });
    }
    return Task.FromResult(result);
};

public static Func<SqlDataReader, List<A>> handleResultSync = (SqlDataReader sdr) =>
{
    var result = new List<A>();
    while (sdr.Read())
    {
        result.Add(new A { object_name = sdr.GetFieldValue<string>(0) });
    }
    return result;
};