DBCC FREEPROCCACHEnon funziona in Azure SQL DB. In quale altro modo posso forzare un piano a buttarsi fuori dalla cache in un modo che non danneggi un sistema di produzione (cioè non posso semplicemente andare a modificare le tabelle volenti o nolenti)? Questo è specificamente per SQL creato da Entity Framework, quindi non si tratta di processi memorizzati autogestiti: è effettivamente un SQL dinamico.

(La fonte era indici cattivi -> cattive statistiche, ecc. È tutto risolto, ma un piano cattivo non andrà via.)

AGGIORNAMENTO: Ho scelto la soluzione di @ mrdenny appena arrivata lì. Tuttavia, sto usando con successo la sceneggiatura di @Aaron Bertrand per eseguire il lavoro. Grazie a tutti per l'aiuto !!

Azure SQL ora supporta direttamente questo

Il database SQL di Azure supporta direttamente la cancellazione della cache proc del database utente corrente senza alcun hack:

ALTER DATABASE SCOPED CONFIGURATION CLEAR PROCEDURE_CACHE;

Informazioni aggiuntive

Il seguente script (di Shannon Gowen ) può essere utilizzato per seguire il processo passo dopo passo:

-- run this script against a user database, not master
-- count number of plans currently in cache
select count(*) from sys.dm_exec_cached_plans;

-- Executing this statement will clear the procedure cache in the current database, which means that all queries will have to recompile.
ALTER DATABASE SCOPED CONFIGURATION CLEAR PROCEDURE_CACHE;

-- count number of plans in cache now, after they were cleared from cache
select count(*) from sys.dm_exec_cached_plans;

-- list available plans
select * from sys.dm_exec_cached_plans;

Non esiste un modo esplicito per farlo oggi, ma questo non è uno scenario permanente (il comando DBCC non è ancora supportato, ma può essere letto su Query Store ). Anche quando l'hit di modifica dello schema è accettabile, potrebbe non essere quello che vuoi, perché invaliderà tutti i piani relativi all'oggetto sottostante, non solo quello cattivo.

Non cercare credito per questo, ma creare SQL dinamico per eseguire la stessa operazione su più tabelle è abbastanza semplice:

DECLARE @sql NVARCHAR(MAX) = N'';

SELECT @sql += N'ALTER TABLE '
  + QUOTENAME(SCHEMA_NAME([schema_id])) 
  + '.' + QUOTENAME(name) + ' ADD fake_column INT NULL;
  ALTER TABLE ' 
  + QUOTENAME(SCHEMA_NAME([schema_id]))
  + '.' + QUOTENAME(name) + ' DROP COLUMN fake_column;'
FROM sys.tables
--WHERE name IN, LIKE, etc.

PRINT @sql;

-- if the command > 8K, you can see the second chunk e.g.

PRINT SUBSTRING(@sql, 8001, 8000);

--EXEC sys.sp_executesql @sql;

(Ho scritto un suggerimento su questo problema "lunghezza di SQL dinamico" ...)

Aggiungi una colonna nullable alla tabella, quindi rilascia la colonna. Ciò costringerà SQL a svuotare la cache per quell'oggetto.

Per quanto riguarda tutte le tabelle, un cursore dovrebbe fare il trucco. Basta usare un nome di colonna che non esisterà mai in alcuna tabella come "zzzzzz_go_away" o qualcosa del genere.

Il database SQL di Azure attualmente non supporta DBCC FREEPROCCACHE, quindi non è possibile rimuovere manualmente un piano di esecuzione dalla cache. Tuttavia, se si apportano modifiche a una tabella o a una vista a cui fa riferimento la query ( ALTER TABLE/ ALTER VIEW), il piano verrà rimosso dalla cache. ( Riferimento .)

Per cancellare tutto il piano di esecuzione, utilizzare questo:

    SET NOCOUNT ON

DECLARE @lcl_name VARCHAR(100)
DECLARE @addcolumnSql nVARCHAR(MAX)
DECLARE @dropcolumnSql nVARCHAR(MAX)

DECLARE cur_name CURSOR FOR
SELECT name
FROM sysobjects
WHERE type = 'U'
OPEN cur_name
FETCH NEXT FROM cur_name INTO @lcl_name
WHILE @@Fetch_status = 0
BEGIN
set @addcolumnSql = 'alter table [' + @lcl_name + '] add temp_col_to_clear_exec_plan bit'
EXEcute sp_executesql @addcolumnSql
print @addcolumnSql
set @dropcolumnSql = 'alter table [' + @lcl_name + '] drop column temp_col_to_clear_exec_plan'
EXEcute sp_executesql @dropcolumnSql
print @dropcolumnSql
--  EXEC (@lcl_name )
FETCH NEXT FROM cur_name INTO @lcl_name
END
CLOSE cur_name
DEALLOCATE cur_name
SET NOCOUNT OFF

Se si modifica una tabella o si visualizza facendo riferimento a essa, il piano di esecuzione viene cancellato.

Un po 'più spiegato qui http://christianarg.wordpress.com/2013/08/22/remove-execution-plans-from-the-procedure-cache-in-sql-azure/