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

11

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?

user2904235
fonte
Eu recebo o mesmo erro quando adiciono um índice não clusterizado na mesma tabela. Tentei adicionar o não clusterizado primeiro. Eu recebi esse erro. Por isso, pensei que poderia ter corrupção de índice e tentei eliminar todos os índices e recriá-los. Foi quando recebi a mensagem de erro que eu publiquei originalmente. Devo acrescentar que a verificação de integridade do Idera SQL encontrou corrupção nos índices desta tabela. Agora a questão é: como faço para corrigir isso.
precisa saber é o seguinte
Seria possível que sua operação falhe ao descobrir que há uma violação de restrição ou algo assim? Dê uma olhada nisto: http://stackoverflow.com/questions/34518205/c-sharp-cmd-executescalar-cannot-continue-the-execution-because-the-session
Victor Barajas

Respostas:

4

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.

cbailiss
fonte
3

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.

MarmiK
fonte
3

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,

Kangeles
fonte
2

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.

PseudoToad
fonte
2

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 ...

HansLindgren
fonte
0

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;
};
John Zabroski
fonte