Destinazioni per gli eventi estesi in SQL ServerTargets for Extended Events in SQL Server

QUESTO ARGOMENTO SI APPLICA A:sìSQL Server (a partire dalla versione 2014)sìDatabase SQL di AzurenoAzure SQL Data Warehouse noParallel Data Warehouse THIS TOPIC APPLIES TO:yesSQL Server (starting with 2014)yesAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

Questo articolo illustra quando e come usare le destinazioni package0 per gli eventi estesi in SQL Server.This article explains when and how to use the package0 targets for extended events in SQL Server. Per ogni destinazione, l'articolo presenta le informazioni seguenti:For each target, the present article explains:

  • Le funzionalità di raccolta e creazione di report dei dati inviati dagli eventi.Its abilities in gathering and reporting the data sent by events.
  • I parametri, tranne nei casi in cui il parametro è facilmente comprensibile.Its parameters, except where the parameter is self-explanatory.

Esempio di XQueryXQuery example

La sezione ring_buffer include un esempio d'uso di XQuery in Transact-SQL per copiare una stringa XML in un set di righe relazionale.The ring_buffer section includes an example of using XQuery in Transact-SQL to copy a string of XML into a relational rowset.

PrerequisitiPrerequisites

  • Avere una certa familiarità con le nozioni di base relative agli eventi estesi, come descritto in Avvio rapido: Eventi estesi in SQL Server.Be generally familiar with the basics of extended events, as described in Quick Start: Extended events in SQL Server.

  • Avere installato una versione recente dell'utilità SQL Server Management Studio (SSMS.exe) aggiornata di frequente.Have installed a recent version of the frequently updated utility SQL Server Management Studio (SSMS.exe). Per informazioni dettagliate, vedere:For details see:

  • In SSMS.exe sapere come usare Esplora oggetti per fare clic con il pulsante destro del mouse sul nodo di destinazione nella sessione eventi per semplificare la visualizzazione dei dati di output.In SSMS.exe, know how to use the Object Explorer to right-click the target node under your event session, for easy viewing of the output data.

    • I dati dell'evento vengono acquisiti come stringa XML,The event data is captured as an XML string. ma in questo articolo sono visualizzati in righe relazionali.Yet in this article the data is displayed in relational rows. Per visualizzare i dati è stato usato SSMS e quindi i dati sono stati copiati e incollati in questo articolo.SSMS was used to view the data, and then was copied and pasted into this article.
    • La tecnica T-SQL alternativa per la generazione di set di righe da XML viene spiegata nella sezione ring_buffer.The alternative T-SQL technique for generating rowsets from XML is explained in the ring_buffer section. Questa operazione implica l'uso di XQuery.It involves XQuery.

Parametri, azioni e campiParameters, actions, and fields

In Transact-SQL l'istruzione CREATE EVENT SESSION è fondamentale per gli eventi estesi.In Transact-SQL, the CREATE EVENT SESSION statement is central to extended events. Per scrivere l'istruzione sono spesso necessari un elenco e una descrizione dei dati seguenti:To write the statement you often need a list and description of the following:

  • I campi associati all'evento selezionato.The fields associated with your chosen event.
  • I parametri associati alla destinazione selezionata.The parameters associated with your chosen target.

Le istruzioni SELECT che restituiscono tali elenchi dalle visualizzazioni di sistema possono essere copiate dalla sezione C dell'articolo seguente:SELECT statements which return such lists from system views are available to copy from the following article, in its section C:

È possibile visualizzare i parametri, le azioni e i campi usati nel contesto di un'istruzione CREATE EVENT SESSION effettiva, in questo collegamento.You can see parameters, fields, and actions used in the context of an actual CREATE EVENT SESSION statement, at this link.

Destinazione etw_classic_sync_targetetw_classic_sync_target target

Gli eventi estesi di SQL Server possono interagire con Event Tracing for Windows (ETW) per monitorare l'attività del sistema.SQL Server extended events can inter-operate with Event Tracing for Windows (ETW) to monitor system activity. Per altre informazioni, vedere:For more information, see:

Questa destinazione di ETW elabora in modalità sincrona i dati ricevuti, mentre la maggior parte delle destinazioni esegue l'elaborazione in modalità asincrona.This ETW target processes synchronously the data it receives, whereas most targets process asynchronously.

Destinazione event_counterevent_counter target

La destinazione event_counter calcola semplicemente la frequenza con cui si verifica ogni evento specificato.The event_counter target merely counts how many times each specified event occurs.

A differenza di quasi tutte le altre destinazioni:Unlike most other targets:

  • La destinazione event_counter non ha parametri.The event_counter has no parameters.

  • A differenza di quasi tutte le destinazioni, event_counter elabora in modalità sincrona i dati ricevuti.Unlike most targets, the event_counter target processes synchronously the data it receives.

    • La modalità sincrona è accettabile per la destinazione event_counter semplice perché questa destinazione richiede poche operazioni di elaborazione.Synchronous is acceptable for the simple event_counter because the event_counter involves so little processing.
    • Il motore di database viene disconnesso da qualsiasi destinazione che risulta troppo lenta e che pertanto rischia di rallentare le prestazioni del motore.The database engine will disconnect from any target which is too slow and which thereby threatens to slow the performance of the database engine. Questo è uno dei motivi per cui la maggior parte delle destinazioni elabora i dati in modalità asincrona.This is one reason why most targets process asynchronously.

Output di esempio acquisito da event_counterExample output captured by event_counter

package_name   event_name         count
------------   ----------         -----
sqlserver      checkpoint_begin   4

Di seguito è riportata l'istruzione CREATE EVENT SESSION che ha generato i risultati precedenti.Next is the CREATE EVENT SESSION that led to the previous results. Per questo test, nella clausola EVENT...WHERE è stato usato il campo package0.counter per arrestare il conteggio dopo che è stato raggiunto 4.For this test, on the EVENT...WHERE clause, the package0.counter field was used to cease the counting after the count climbed to 4.

CREATE EVENT SESSION [event_counter_1]
    ON SERVER 
    ADD EVENT sqlserver.checkpoint_begin   -- Test by issuing CHECKPOINT; statements.
    (
        WHERE ([package0].[counter] <= (4))   -- A predicate filter.
    )
    ADD TARGET package0.event_counter
    WITH
    (
        MAX_MEMORY = 4096 KB,
        MAX_DISPATCH_LATENCY = 3 SECONDS
    );

Destinazione event_fileevent_file target

La destinazione event_file scrive l'output della sessione eventi dal buffer in un file su disco:The event_file target writes event session output from buffer to a disk file:

  • Specificare il parametro filename= nella clausola ADD TARGET.You specify the filename= parameter on the ADD TARGET clause.

    • L'estensione del file deve esserexel ..xel must be the extension of the file.
  • Il nome di file selezionato viene usato dal sistema come prefisso a cui viene aggiunto un valore long integer basato su data-ora, seguito dall'estensione xel.The file name you choose is used by the system as a prefix to which a date-time based long integer is appended, followed by the .xel extension.

CREATE EVENT SESSION con destinazione event_fileCREATE EVENT SESSION with event_file target

Di seguito è riportata l'estensione CREATE EVENT SESSION usata per eseguire il test.Next is the CREATE EVENT SESSION that we used to test with. Una delle clausole ADD TARGET specifica una destinazione event_file.One of the ADD TARGET clauses specifies an event_file.

CREATE EVENT SESSION [locks_acq_rel_eventfile_22]
    ON SERVER 
    ADD EVENT sqlserver.lock_acquired
    (
        SET
            collect_database_name=(1),
            collect_resource_description=(1)

        ACTION (sqlserver.sql_text,sqlserver.transaction_id)

        WHERE
        (
            [database_name]=N'InMemTest2'
            AND
            [object_id]=(370100359)
        )
    ),
    ADD EVENT sqlserver.lock_released
    (
        SET
            collect_database_name=(1),
            collect_resource_description=(1)

        ACTION(sqlserver.sql_text,sqlserver.transaction_id)

        WHERE
        (
            [database_name]=N'InMemTest2'
            AND
            [object_id]=(370100359)
        )
    )
    ADD TARGET package0.event_counter,
    ADD TARGET package0.event_file
    (
        SET     filename=N'C:\Junk\locks_acq_rel_eventfile_22-.xel'
    )
    WITH
    (
        MAX_MEMORY=4096 KB,
        MAX_DISPATCH_LATENCY=10 SECONDS
    );

Funzione sys.fn_xe_file_target_read_filesys.fn_xe_file_target_read_file function

La destinazione event_file archivia i dati ricevuti in un formato binario che non è leggibile.The event_file target stores the data it receives in a binary format that is not human readable. Transact-SQL può riportare il contenuto del file con estensione xel eseguendo un'istruzione SELECT FROM sui dati restituiti dalla funzione sys.fn_xe_file_target_read_file .Transact-SQL can report the contents of the .xel file by SELECTing FROM the sys.fn_xe_file_target_read_file function.

Per SQL Server 2016 e versioni successive, i dati sono stati riportati dall'istruzione T-SQL SELECT seguente.For SQL Server 2016 and later, the following T-SQL SELECT reported the data. Nel codice viene usato il suffisso *.xel.The *.xel suffix in the

SELECT f.*
        --,CAST(f.event_data AS XML)  AS [Event-Data-Cast-To-XML]  -- Optional
    FROM
        sys.fn_xe_file_target_read_file(
            'C:\junk\locks_acq_rel_eventfile_22-*.xel',
            null, null, null)  AS f;

Per SQL Server 2014, i dati verrebbero riportati da un'istruzione SELECT simile alla seguente.For SQL Server 2014, a SELECT similar to the following would report the data. Dopo SQL Server 2014, i file con estensione xem non sono stati più usati.After SQL Server 2014, the .xem files are no longer used.

SELECT f.*
        --,CAST(f.event_data AS XML)  AS [Event-Data-Cast-To-XML]  -- Optional
    FROM
        sys.fn_xe_file_target_read_file(
            'C:\junk\locks_acq_rel_eventfile_22-*.xel',
            'C:\junk\metafile.xem',
            null, null)  AS f;

Naturalmente, per vedere i dati del file con estensione xel è possibile anche usare manualmente l'interfaccia utente di SSMS:Of course, you can also manually use the SSMS UI to see the .xel data:

Dati archiviati nella destinazione event_fileData stored in the event_file target

Di seguito è illustrato il report dell'esecuzione di SELECT FROM sui dati restituiti da sys.fn_xe_file_target_read_file, in SQL Server 2016.Next is the report from SELECTing from sys.fn_xe_file_target_read_file, in SQL Server 2016.

module_guid                            package_guid                           object_name     event_data                                                                                                                                                                                                                                                                                          file_name                                                      file_offset
-----------                            ------------                           -----------     ----------                                                                                                                                                                                                                                                                                          ---------                                                      -----------
D5149520-6282-11DE-8A39-0800200C9A66   03FDA7D0-91BA-45F8-9875-8B6DD0B8E9F2   lock_acquired   <event name="lock_acquired" package="sqlserver" timestamp="2016-08-07T20:13:35.827Z"><action name="transaction_id" package="sqlserver"><value>39194</value></action><action name="sql_text" package="sqlserver"><value><![CDATA[  select top 1 * from dbo.T_Target;  ]]></value></action></event>   C:\junk\locks_acq_rel_eventfile_22-_0_131150744126230000.xel   11776
D5149520-6282-11DE-8A39-0800200C9A66   03FDA7D0-91BA-45F8-9875-8B6DD0B8E9F2   lock_released   <event name="lock_released" package="sqlserver" timestamp="2016-08-07T20:13:35.832Z"><action name="transaction_id" package="sqlserver"><value>39194</value></action><action name="sql_text" package="sqlserver"><value><![CDATA[  select top 1 * from dbo.T_Target;  ]]></value></action></event>   C:\junk\locks_acq_rel_eventfile_22-_0_131150744126230000.xel   11776

Destinazione histogramhistogram target

La destinazione histogram è più complessa rispetto a event_counter.The histogram target is fancier than the event_counter target. Questa destinazione può eseguire le operazioni seguenti:The histogram can do the following:

  • Contare le occorrenze per più elementi separatamente.Count occurrences for several items separately.
  • Contare le occorrenze di diversi tipi di elementi:Count occurrences of different types of items:
    • Campi di evento.Event fields.
    • Azioni.Actions.

Il parametro source_type è l'elemento chiave per il controllo della destinazione histogram:The source_type parameter is the key to controlling the histogram target:

  • source_type=0 indica la raccolta di dati per i campi di evento.source_type=0 - Means collect data for event fields).
  • source_type=1 indica la raccolta di dati per le azioni.source_type=1 - Means collect data for actions.
    • Il valore predefinito è 1.1 is the default.

Il valore predefinito del parametro 'slots' è 256.The 'slots' parameter default is 256. Se si assegna un altro valore, il valore viene arrotondato alla successiva potenza di 2.If you assign another value, the value is rounded up to the next power of 2.

  • Ad esempio, slots=59 viene arrotondato a =64.For example, slots=59 would be rounded up to =64.

Esempio diazione per histogramAction example for histogram

Nella clausola TARGET...SET, l'istruzione Transact-SQL CREATE EVENT SESSION seguente specifica l'assegnazione del parametro di destinazione source_type=1.On its TARGET...SET clause, the following Transact-SQL CREATE EVENT SESSION statement specifies the target parameter assignment of source_type=1. Il valore 1 significa che la destinazione histogram tiene traccia di un'azione.The 1 means the histogram target tracks an action.

In questo esempio, la clausola EVENT...ACTION consente di selezionare una sola azione per la destinazione, ovvero sqlos.system_thread_id.In the present example, the EVENT...ACTION clause offer happens to offer only one action for the target to choose, namely sqlos.system_thread_id. Nella clausola TARGET...SET viene visualizzata l'assegnazione source=N'sqlos.system_thread_id' .On the TARGET...SET clause, we see the assignment source=N'sqlos.system_thread_id' assignment.

  • Per tener traccia di più azioni di origine, è possibile aggiungere una seconda destinazione histogram all'istruzione CREATE EVENT SESSION.To track more than one source action, you can add a second histogram target to your CREATE EVENT SESSION statement.
CREATE EVENT SESSION [histogram_lockacquired]
    ON SERVER 
    ADD EVENT sqlserver.lock_acquired
        (
        ACTION
            (
            sqlos.system_thread_id
            )
        )
    ADD TARGET package0.histogram
        (
        SET
            filtering_event_name=N'sqlserver.lock_acquired',
            slots=(16),
            source=N'sqlos.system_thread_id',
            source_type=1
        )
    WITH
        (
        <.... (For brevity, numerous parameter assignments generated by SSMS.exe are not shown here.) ....>
        );

Sono stati acquisiti i dati seguenti.The following data was captured. I valori della colonna value sono valori di system_thread_id.The values under the value column were system_thread_id values. Ad esempio, sono stati acquisiti 236 blocchi nell'ambito del thread 6540.For instance, a total of 236 locks were taken under thread 6540.

value   count
-----   -----
 6540     236
 9308      91
 9668      74
10144      49
 5244      44
 2396      28

Istruzione SELECT per individuare le azioni disponibiliSELECT to discover available actions

L'istruzione SELECT C.3 può trovare le azioni che il sistema consente di specificare nell'istruzione CREATE EVENT SESSION.The C.3 SELECT statement can find the actions that the system has available for you to specify on your CREATE EVENT SESSION statement. Nella clausola WHERE modificare prima di tutto il filtro o.name LIKE in modo da filtrare le azioni a cui si è interessati.In the WHERE clause, you would first edit the o.name LIKE filter to match the actions that interest you.

Di seguito è riportato un set di righe di esempio restituito da C.3 SELECT.Next is a sample rowset returned by the C.3 SELECT. L'azione system_thread_id è visualizzata nella seconda riga.The system_thread_id action is seen in the second row.

Package-Name   Action-Name                 Action-Description
------------   -----------                 ------------------
package0       collect_current_thread_id   Collect the current Windows thread ID
sqlos          system_thread_id            Collect current system thread ID
sqlserver      create_dump_all_threads     Create mini dump including all threads
sqlserver      create_dump_single_thread   Create mini dump for the current thread

Esempio di campo di evento per histogramEvent field example for histogram

L'esempio seguente imposta source_type=0.The following example sets source_type=0. Il valore assegnato a source= è un campo di evento (non un'azione).The value assigned to source= is an event field (not an action).

CREATE EVENT SESSION [histogram_checkpoint_dbid]
    ON SERVER 
    ADD EVENT  sqlserver.checkpoint_begin
    ADD TARGET package0.histogram
    (
    SET
        filtering_event_name = N'sqlserver.checkpoint_begin',
        source               = N'database_id',
        source_type          = (0)
    )
    WITH
    ( <....> );

I dati seguenti sono stati acquisiti dalla destinazione histogram.The following data was captured by the histogram target. I dati mostrano che nel database ID=5 si sono verificati 7 eventi checkpoint_begin.The data shows that the database that is ID=5 experienced 7 checkpoint_begin events.

value   count
-----   -----
5       7
7       4
6       3

Istruzione SELECT per individuare i campi disponibili nell'evento selezionatoSELECT to discover available fields on your chosen event

L'istruzione C.4 SELECT mostra i campi di evento che è possibile selezionare.The C.4 SELECT statement shows event fields that you can choose from. Modificare prima di tutto il filtro o.name LIKE in modo da restituire il nome dell'evento selezionato.You would first edit the o.name LIKE filter to be your chosen event name.

C.4 SELECT ha restituito il set di righe seguente.The following rowset was returned by the C.4 SELECT. Il set di righe mostra che database_id è l'unico campo dell'evento checkpoint_begin che può fornire valori per la destinazione histogram.The rowset shows that database_id is the only one field on the checkpoint_begin event that can supply values for the histogram target.

Package-Name   Event-Name         Field-Name   Field-Description
------------   ----------         ----------   -----------------
sqlserver      checkpoint_begin   database_id  NULL
sqlserver      checkpoint_end     database_id  NULL

Destinazione pair_matchingpair_matching target

La destinazione pair_matching consente di individuare gli eventi iniziali che si verificano senza un evento finale corrispondente.The pair_matching target enables you to detect start events that occurs without a corresponding end event. Ad esempio, se si verifica un evento lock_acquired che non è seguito tempestivamente da un evento lock_released, questo può costituire un problema.For instance, it might be a problem when a lock_acquired event occurs but no matching lock_released event follows in a timely manner.

Il sistema non stabilisce automaticamente la corrispondenza tra eventi iniziali ed eventi finali.The system does not automatically match start and end events. Al contrario, la corrispondenza viene definita nell'istruzione CREATE EVENT SESSION.Instead, you explain the matching to the system in your CREATE EVENT SESSION statement. Quando viene stabilita una corrispondenza tra un evento iniziale e uno finale, la coppia viene eliminata per consentire di concentrarsi sugli eventi iniziali senza eventi finali corrispondenti.When a start and end event are matched, the pair is discarded so everyone can focus on the unmatched start events.

Ricerca di campi associabili per la coppia di eventi iniziale e finaleFinding matchable fields for the start and end event pair

Usando C.4 SELECT, è possibile notare che nel set di righe seguente sono presenti circa 16 campi per l'evento lock_acquired.By using the C.4 SELECT, we see in the following rowset there are about 16 fields for the lock_acquired event. Il set di righe visualizzato qui è stato suddiviso manualmente per mostrare i campi in base ai quali è stata stabilita la corrispondenza.The rowset displayed here has been manually split to show which fields our example matched on. Per alcuni campi sarebbe inutile provare a stabilire la corrispondenza, come nel caso del campo duration di entrambi gli eventi.Some fields would be silly to try matching, such as on the duration of both events.

Package-Name   Event-Name   Field-Name               Field-Description
------------   ----------   ----------               -----------------
sqlserver   lock_acquired   database_name            NULL
sqlserver   lock_acquired   mode                     NULL
sqlserver   lock_acquired   resource_0               The ID of the locked object, when lock_resource_type is OBJECT.
sqlserver   lock_acquired   resource_1               NULL
sqlserver   lock_acquired   resource_2               The ID of the lock partition, when lock_resource_type is OBJECT, and resource_1 is 0.
sqlserver   lock_acquired   transaction_id           NULL

sqlserver   lock_acquired   associated_object_id     The ID of the object that requested the lock that was acquired.
sqlserver   lock_acquired   database_id              NULL
sqlserver   lock_acquired   duration                 The time (in microseconds) between when the lock was requested and when it was canceled.
sqlserver   lock_acquired   lockspace_nest_id        NULL
sqlserver   lock_acquired   lockspace_sub_id         NULL
sqlserver   lock_acquired   lockspace_workspace_id   NULL
sqlserver   lock_acquired   object_id                The ID of the locked object, when lock_resource_type is OBJECT. For other lock resource types it will be 0
sqlserver   lock_acquired   owner_type               NULL
sqlserver   lock_acquired   resource_description     The description of the lock resource. The description depends on the type of lock. This is the same value as the resource_description column in the sys.dm_tran_locks view.
sqlserver   lock_acquired   resource_type            NULL

Esempio di pair_matchingExample of pair_matching

L'istruzione CREATE EVENT SESSION seguente specifica due eventi e due destinazioni.The following CREATE EVENT SESSION statement specifies two events, and two targets. La destinazione pair_matching specifica due set di campi in modo da stabilire la corrispondenza tra gli eventi.The pair_matching target specifies two sets of fields to match the events into pairs. La sequenza di campi delimitati da virgole assegnati a begin_matching_columns= e end_matching_columns= deve essere identica.The sequence of comma-delimited fields assigned to begin_matching_columns= and end_matching_columns= must be the same. Tra i campi indicati nel valore delimitato da virgole non sono consentiti caratteri di tabulazione o di nuova riga, ma possono essere usati gli spazi.No tabs or newlines are allowed between the fields mentioned in the comma-delimited value, although spaces are okay.

Per limitare i risultati, si è prima eseguita l'istruzione SELECT su sys.objects per trovare il valore di object_id della tabella di test.To narrow the results, we first SELECTed from sys.objects to find the object_id of our test table. Per lo specifico ID si è aggiunto un filtro alla clausola EVENT...WHERE.We added a filter for that one ID to the EVENT...WHERE clause.

CREATE EVENT SESSION [pair_matching_lock_a_r_33]
    ON SERVER 
    ADD EVENT sqlserver.lock_acquired
    (
        SET
            collect_database_name = (1),
            collect_resource_description = (1)

        ACTION (sqlserver.transaction_id)

        WHERE
        (
            [database_name] = 'InMemTest2'
            AND
            [object_id] = 370100359
        )
    ),
    ADD EVENT sqlserver.lock_released
    (
        SET
            collect_database_name = (1),
            collect_resource_description = (1)

        ACTION (sqlserver.transaction_id)

        WHERE
        (
            [database_name] = 'InMemTest2'
            AND
            [object_id] = 370100359
        )
    )
    ADD TARGET package0.event_counter,
    ADD TARGET package0.pair_matching
    (
        SET
            begin_event = N'sqlserver.lock_acquired',
            begin_matching_columns =
                N'resource_0, resource_1, resource_2, transaction_id, database_id',

            end_event = N'sqlserver.lock_released',
            end_matching_columns =
                N'resource_0, resource_1, resource_2, transaction_id, database_id',

            respond_to_memory_pressure = (1)
    )
    WITH
    (
        MAX_MEMORY = 8192 KB,
        MAX_DISPATCH_LATENCY = 15 SECONDS
    );

Per testare la sessione eventi, si è intenzionalmente impedito il rilascio di blocchi acquisiti.To test the event session, we purposely prevented to acquired locks from being released. A tal fine, si sono eseguiti i passaggi T-SQL seguenti:We did this with the following T-SQL steps:

  1. BEGIN TRANSACTION.BEGIN TRANSACTION.
  2. UPDATE MyTable....UPDATE MyTable....
  3. Non si è intenzionalmente eseguita un'istruzione COMMIT TRANSACTION finché non si sono esaminate le destinazioni.Purposely not issue a COMMIT TRANSACTION, until after we examined the targets.
  4. Successivamente, dopo il testing, si è eseguita un'istruzione COMMIT TRANSACTION.Later after testing, we issued a COMMIT TRANSACTION.

La semplice destinazione event_counter ha fornito le righe di output seguenti.The simple event_counter target provided the following output rows. Poiché 52-50=2, l'output indica che, quando si esamina l'output della destinazione pair-matching, dovrebbero essere visibili due eventi lock_acquired non abbinati.Because 52-50=2, the output tells us we should see 2 unpaired lock_acquired events when we examine the output from the pair-matching target.

package_name   event_name      count
------------   ----------      -----
sqlserver      lock_acquired   52
sqlserver      lock_released   50

La destinazione pair_matching ha fornito l'output seguente.The pair_matching target provided the following output. Come indicato dall'output event_counter, sono effettivamente visibili due righe lock_acquired.As suggested by the event_counter output, we do indeed see 2 lock_acquired rows. Ciò significa che questi due eventi lock_acquired non sono abbinati.The fact that we see these rows at all means these two lock_acquired events are unpaired.

package_name   event_name      timestamp                     database_name   duration   mode   object_id   owner_type   resource_0   resource_1   resource_2   resource_description   resource_type   transaction_id
------------   ----------      ---------                     -------------   --------   ----   ---------   ----------   ----------   ----------   ----------   --------------------   -------------   --------------
sqlserver      lock_acquired   2016-08-05 12:45:47.9980000   InMemTest2      0          S      370100359   Transaction  370100359    3            0            [INDEX_OPERATION]      OBJECT          34126
sqlserver      lock_acquired   2016-08-05 12:45:47.9980000   InMemTest2      0          IX     370100359   Transaction  370100359    0            0                                   OBJECT          34126

Le righe relative agli eventi lock_acquired non abbinati possono includere il testo T-SQL, o sqlserver.sql_text, che ha acquisito i blocchi,The rows for the unpaired lock_acquired events could include the T-SQL text, or sqlserver.sql_text, that took the locks. ma in questo caso il testo è stato omesso per limitare le dimensioni dell'immagine.But we did not want to bloat the display.

Destinazione ring_bufferring_buffer target

La destinazione ring_buffer è utile per eseguire in modo semplice e rapido il test degli eventi.The ring_buffer target is handy for quick and simple event testing. Quando si arresta la sessione eventi, l'output archiviato viene rimosso.When you stop the event session, the stored output is discarded.

In questa sezione ring_buffer viene inoltre illustrato come usare l'implementazione Transact-SQL di XQuery per copiare il contenuto XML di ring_buffer in un set di righe relazionale più leggibile.In this ring_buffer section we also show how you can use the Transact-SQL implementation of XQuery to copy the XML contents of the ring_buffer into a more readable relational rowset.

CREATE EVENT SESSION con ring_bufferCREATE EVENT SESSION with ring_buffer

Questa istruzione CREATE EVENT SESSION che usa la destinazione ring_buffer non presenta caratteristiche particolari.There is nothing special about this CREATE EVENT SESSION statement, which uses the ring_buffer target.

CREATE EVENT SESSION [ring_buffer_lock_acquired_4]
    ON SERVER 
    ADD EVENT sqlserver.lock_acquired
    (
        SET collect_resource_description=(1)

        ACTION(sqlserver.database_name)

        WHERE
        (
            [object_id]=(370100359)  -- ID of MyTable
            AND
            sqlserver.database_name='InMemTest2'
        )
    )
    ADD TARGET package0.ring_buffer
    (
        SET max_events_limit=(98)
    )
    WITH
    (
        MAX_MEMORY=4096 KB,
        MAX_DISPATCH_LATENCY=3 SECONDS
    );

Output XML ricevuto per lock_acquired da ring_bufferXML output received for lock_acquired by ring_buffer

Quando è recuperato da un'istruzione SELECT, il contenuto è riportato in forma di stringa XML.When retrieved by a SELECT statement, the content is in the form of a string of XML. Di seguito è riportata la stringa XML archiviata dalla destinazione ring_buffer durante il testing.The XML string that was stored by the ring_buffer target in our testing, is shown next. Tuttavia, per limitare la quantità di codice XML visualizzata, sono stati cancellati tutti gli elementi tranne due <event>.However, for brevity of the following XML display, all but two <event> elements have been erased. Inoltre, per ogni elemento <event> sono stati eliminati diversi elementi <data> estranei.Further, within each <event>, a handful of extraneous <data> elements have been deleted.

<RingBufferTarget truncated="0" processingTime="0" totalEventsProcessed="6" eventCount="6" droppedCount="0" memoryUsed="1032">
  <event name="lock_acquired" package="sqlserver" timestamp="2016-08-05T23:59:53.987Z">
    <data name="mode">
      <type name="lock_mode" package="sqlserver"></type>
      <value>1</value>
      <text><![CDATA[SCH_S]]></text>
    </data>
    <data name="transaction_id">
      <type name="int64" package="package0"></type>
      <value>111030</value>
    </data>
    <data name="database_id">
      <type name="uint32" package="package0"></type>
      <value>5</value>
    </data>
    <data name="resource_0">
      <type name="uint32" package="package0"></type>
      <value>370100359</value>
    </data>
    <data name="resource_1">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="resource_2">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="database_name">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[]]></value>
    </data>
    <action name="database_name" package="sqlserver">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[InMemTest2]]></value>
    </action>
  </event>
  <event name="lock_acquired" package="sqlserver" timestamp="2016-08-05T23:59:56.012Z">
    <data name="mode">
      <type name="lock_mode" package="sqlserver"></type>
      <value>1</value>
      <text><![CDATA[SCH_S]]></text>
    </data>
    <data name="transaction_id">
      <type name="int64" package="package0"></type>
      <value>111039</value>
    </data>
    <data name="database_id">
      <type name="uint32" package="package0"></type>
      <value>5</value>
    </data>
    <data name="resource_0">
      <type name="uint32" package="package0"></type>
      <value>370100359</value>
    </data>
    <data name="resource_1">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="resource_2">
      <type name="uint32" package="package0"></type>
      <value>0</value>
    </data>
    <data name="database_name">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[]]></value>
    </data>
    <action name="database_name" package="sqlserver">
      <type name="unicode_string" package="package0"></type>
      <value><![CDATA[InMemTest2]]></value>
    </action>
  </event>
</RingBufferTarget>

Per visualizzare il codice XML precedente, è possibile eseguire l'istruzione SELECT seguente mentre è attiva la sessione eventi.To see the preceding XML, you can issue the following SELECT while the event session is active. I dati XML attivi vengono recuperati dalla visualizzazione di sistema sys.dm_xe_session_targets.The active XML data is retrieved from the system view sys.dm_xe_session_targets.

SELECT
        CAST(LocksAcquired.TargetXml AS XML)  AS RBufXml,
    INTO
        #XmlAsTable
    FROM
        (
        SELECT
                CAST(t.target_data AS XML)  AS TargetXml
            FROM
                     sys.dm_xe_session_targets  AS t
                JOIN sys.dm_xe_sessions         AS s

                    ON s.address = t.event_session_address
            WHERE
                t.target_name = 'ring_buffer'
                AND
                s.name        = 'ring_buffer_lock_acquired_4'
        )
            AS LocksAcquired;


SELECT * FROM #XmlAsTable;

XQuery per visualizzare il codice XML come set di righeXQuery to see the XML as a rowset

Per visualizzare il codice XML precedente come set di righe relazionale, continuare dall'istruzione SELECT precedente ed eseguire il codice T-SQL seguente.To see the preceding XML as a relational rowset, continue from the preceding SELECT statement by issuing the following T-SQL. Le righe commentate spiegano ogni uso di XQuery.The commented lines explain each use of XQuery.

SELECT
         -- (A)
         ObjectLocks.value('(@timestamp)[1]',
            'datetime'     )  AS [OccurredDtTm]

        -- (B)
        ,ObjectLocks.value('(data[@name="mode"]/text)[1]',
            'nvarchar(32)' )  AS [Mode]

        -- (C)
        ,ObjectLocks.value('(data[@name="transaction_id"]/value)[1]',
            'bigint' )  AS [TxnId]

        -- (D)
        ,ObjectLocks.value('(action[@name="database_name" and @package="sqlserver"]/value)[1]',
            'nvarchar(128)')  AS [DatabaseName]
    FROM
        #TableXmlCell
    CROSS APPLY
        -- (E)
        TargetDateAsXml.nodes('/RingBufferTarget/event[@name="lock_acquired"]')  AS T(ObjectLocks);

Note di XQuery dall'istruzione SELECT precedenteXQuery notes from preceding SELECT

(A)(A)

  • Valore dell'attributo timestamp= sull'elemento <event>.timestamp= attribute's value, on <event> element.
  • Il costrutto '(...)[1]' garantisce la restituzione di un solo valore per iterazione, poiché questa è una limitazione obbligatoria del metodo .value() di XQuery per variabili e colonne di tipo XML.The '(...)[1]' construct ensures only 1 value returned per iteration, as is a required limitation of the .value() XQuery method of XML data type variable and columns.

(B)(B)

  • Valore interno dell'elemento <text>, in un elemento <data> con l'attributo name= impostato su "mode".<text> element's inner value, within a <data> element which has its name= attribute equal to "mode".

(C)(C)

  • Valore interno dell'elemento <value>, in un elemento <data> con l'attributo name= impostato su "transaction_id".<value> elements inner value, within a <data> element which has its name= attribute equal to "transaction_id".

(D)(D)

  • L'elemento <event> contiene l'elemento <action>.<event> contains <action>.
  • L'elemento <action> con l'attributo name= impostato su "database_name" e l'attributo package= impostato su "sqlserver" (non su "package0"), ottiene il valore interno dell'elemento <value>.<action> having name= attribute equal to "database_name", and package= attribute equal to "sqlserver" (not "package0"), get the inner value of <value> element.

(E)(E)

  • C.A.C.A. determina la ripetizione dell'elaborazione per ogni singolo elemento <event> con l'attributo name= impostato su "lock_acquired".causes processing to repeat for every individual <event> element which has its name= attribute equal to "lock_acquired".
  • Questo vale per il codice XML restituito dalla clausola FROM precedente.This applies to the XML returned by the preceding FROM clause.

Output di XQuery SELECTOutput from XQuery SELECT

Di seguito è riportato il set di righe generato dal codice T-SQL precedente che include XQuery.Next is the rowset generated by the preceding T-SQL which includes XQuery.

OccurredDtTm              Mode    DatabaseName
------------              ----    ------------
2016-08-05 23:59:53.987   SCH_S   InMemTest2
2016-08-05 23:59:56.013   SCH_S   InMemTest2

Spazi dei nomi XEvent .NET e C#XEvent .NET namespaces and C#

Package0 ha altre due destinazioni che però non possono essere usate in Transact-SQL:Package0 has two more targets, but they cannot be used in Transact-SQL:

  • compressed_historycompressed_history
  • event_streamevent_stream

Un motivo noto per cui queste due destinazioni non possono essere usate in T-SQL consiste nel fatto che i relativi valori non null nella colonna sys.dm_xe_objects.capabilities non includono il bit 0x1.One way we know those two targets cannot be used in T-SQL is that their non-null values in the column sys.dm_xe_objects.capabilities do not include the bit 0x1.

La destinazione event_stream può essere usata nei programmi .NET scritti in linguaggi come C#.The event_stream target can be used in .NET programs written in languages like C#. Gli sviluppatori C# e altri sviluppatori .NET possono accedere a un flusso di eventi tramite una classe .NET Framework, ad esempio nello spazio dei nomi Microsoft.SqlServer.XEvents.Linq.C# and other .NET developers can access an event stream through a .NET Framework class, such as in namespace Microsoft.SqlServer.XEvents.Linq.

Se rilevato, l'errore 25726 indica che il flusso di eventi riempito più velocemente rispetto al client può avere determinato il consumo dei dati.If encountered, error 25726 means the event stream filled up with data faster than the client could consume the data. Di conseguenza, il motore di database si è disconnesso dal flusso di eventi per evitare il rallentamento delle prestazioni del server.This caused the database engine to disconnect from the event stream to avoid slowing the performance of the server.

Spazi dei nomi XEventXEvent namespaces