Não é possível continuar a execução porque a sessão está no estado de interrupção. ao criar o índice clusterizado

Recebo o seguinte erro ao tentar criar um índice em cluster

A instrução foi encerrada.
Msg 596, Nível 21, Estado 1, Linha 0
Não é possível continuar a execução porque a sessão está no estado de interrupção.

Msg 0, Nível 20, Estado 0, Linha 0
Ocorreu um erro grave no comando atual. Os resultados, se existirem, deveriam ser descartados.

O índice é:

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

Estou usando o Microsoft SQL Server 2012 (SP3) (KB3072779) - 11.0.6020.0 (X64) Standard Edition (64 bits) no Windows NT 6.3 (Build 9600:)

eu corri

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

e não encontrou problemas

Receio que meu banco de dados esteja corrompido, pois estou recebendo esse erro. Como corrijo meu problema e coloco esse índice em cima da mesa?

Apenas um ponteiro sobre: ​​SQL Server 2017 (onde eu estava atingindo esse erro) e algumas versões de 2016 para potencialmente economizar outras em algum momento:

Antes do SQL Server 2017 CU8 (também 2016 SP1 CU9 e 2016 SP2 CU1), havia um problema em que tabelas particionadas com estatísticas incrementais geravam esse erro se a operação DML causasse uma atualização automática de estatísticas.

A página mínima de KB está aqui:

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

A instalação de uma UC posterior às listadas acima corrige o problema.

Isso pode ser causado por corrupção do índice,

A melhor maneira de gerenciar isso é Eliminar o índice antigo, que está corrompido.

DROP INDEX dbo.CO_DES_INPUT.IX_CO_DES_INPUT 

E, em seguida, Executar a consulta em perguntas, deve funcionar bem se todos os registros forem exclusivos. nas colunas fornecidas.

Em um banco de dados configurado para os Grupos de Disponibilidade AlwaysOn, você também pode encontrar esse comportamento se o Grupo de Disponibilidade estiver no modo SINCRÔNICO e os secundários ficarem offline ou estiverem suspensos. Esse é um efeito colateral experimentado pelos servidores de aplicativos. Obrigado,

Algo que eu descobri sem querer: Quando você está desabilitando / reconstruindo índices em uma exibição indexada, receberá esse mesmo erro se tentar reconstruir mais um ou mais dos índices não agrupados em cluster antes de criar o cluster ou usar REBUILD ALL.

Eu sempre recebo esse erro quando tenho uma consulta em execução, usando um ouvinte do Always On AG, usando um dos bancos de dados AG e há um failover:

Provedor de dados do .net SqlClient: mensagem 596, nível 21, estado 1, linha 0 Não é possível continuar a execução porque a sessão está no estado de interrupção. Provedor de dados do .NET SqlClient: Msg 0, Nível 20, Estado 0, Linha 0 Ocorreu um erro grave no comando atual. Os resultados, se existirem, deveriam ser descartados.

Muito fácil de reproduzir! Claro, pode haver outras razões, mas esta é a única instância em que estou recebendo esse tipo de erro ...

Posso reproduzir esse problema em um programa C # razoavelmente pequeno que usa Conexões Assíncronas, mas não sei 100% por quê. Aqui está o meu programa de reprodução, caso outras pessoas tentem experimentá-lo - suspeito que há uma série de coisas que precisam ser alinhadas perfeitamente para que isso ocorra:

• Pool de conexão ativado
• Usando representação no conjunto de conexões, não permitindo reverter esse contexto de representação no conjunto de conexões

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