No se puede continuar con la ejecución porque la sesión está en estado de interrupción. mientras se construye el índice agrupado

Recibo el siguiente error al intentar crear un índice agrupado

La instrucción se ha terminado.
Msg 596, Nivel 21, Estado 1, Línea 0
No se puede continuar la ejecución porque la sesión está en estado de interrupción.

Mensaje 0, Nivel 20, Estado 0, Línea 0
Se produjo un error grave en el comando actual. Los resultados, si los hay, deben descartarse.

El índice es:

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

Estoy usando Microsoft SQL Server 2012 (SP3) (KB3072779) - 11.0.6020.0 (X64) Standard Edition (64-bit) en Windows NT 6.3 (Build 9600:)

he corrido

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

y no encontró problemas

Me temo que mi base de datos está dañada porque recibo este error. ¿Cómo corrijo mi problema y obtengo este índice sobre la mesa?

Solo un puntero re: SQL Server 2017 (donde estaba detectando este error) y algunas versiones de 2016 para potencialmente ahorrar tiempo a otras:

Antes de SQL Server 2017 CU8 (también 2016 SP1 CU9 y 2016 SP2 CU1), había un problema en el que las tablas particionadas con estadísticas incrementales generarían este error si la operación DML causaba una actualización automática de estadísticas.

La página mínima de KB está aquí:

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

Instalar una CU posterior a las mencionadas anteriormente soluciona el problema.

Esto puede ser causado por la corrupción del índice,

La mejor manera de gestionar esto es soltar el índice antiguo que está dañado.

DROP INDEX dbo.CO_DES_INPUT.IX_CO_DES_INPUT 

Y que Ejecutar la consulta en preguntas, debería funcionar bien si todos los registros son únicos. en las columnas dadas

En una base de datos configurada para Grupos de disponibilidad siempre activa, también puede encontrar este comportamiento si el Grupo de disponibilidad está en modo SINCRÓNICO y las secundarias se han desconectado o están suspendidas. Este es un efecto secundario experimentado por los servidores de aplicaciones. Gracias,

Algo que he encontrado involuntariamente: cuando deshabilita / reconstruye índices en una vista indexada, obtendrá este mismo error si intenta reconstruir uno o más de los índices no agrupados antes de construir el grupo o usar RECUPERAR TODO.

Siempre recibo este error cuando tengo una consulta en ejecución, usando un oyente Always On AG, usando una de las bases de datos AG y hay una conmutación por error:

.Net SqlClient Data Provider: Msg 596, Level 21, State 1, Line 0 No se puede continuar la ejecución porque la sesión está en estado de interrupción. .Net SqlClient Data Provider: Msg 0, Level 20, State 0, Line 0 Se produjo un error grave en el comando actual. Los resultados, si los hay, deben descartarse.

Muy fácil de reproducir! Por supuesto, puede haber otras razones, pero esta es la única instancia en particular que recibo este tipo de error ...

Puedo reproducir este problema en un programa C # bastante pequeño que usa conexiones asincrónicas, pero no estoy seguro al 100% de por qué. Aquí está mi programa de repro en caso de que otros quieran probarlo. Sospecho que hay una serie de cosas que tienen que alinearse perfectamente para que esto suceda:

• Agrupación de conexiones habilitada
• Usar la suplantación en el grupo de conexiones, no permitir revertir ese contexto de suplantación en el grupo de conexiones

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;
};