Funzionalità supportate per i moduli T-SQL compilati in modo nativo

  • Articolo

Si applica a: SQL Server database SQL di Azure Istanza gestita di SQL di Azure

Questo argomento contiene un elenco delle superfici di attacco e delle funzionalità supportate di T-SQL nei moduli di T-SQL compilati in modo nativo, ad esempio stored procedure (CREATE PROCEDURE (Transact-SQL)), funzioni scalari definite dall'utente, funzioni inline con valori di tabella e trigger.

Per le funzionalità supportate relative alla definizione dei moduli nativi, vedere Supported DDL for Natively Compiled T-SQL modules(DDL supportate per moduli T-SQL compilati in modo nativo).

Per informazioni complete sui costrutti non supportati e per informazioni su come sopperire ad alcune funzionalità non supportate nei moduli compilati in modo nativo, vedere Migration Issues for Natively Compiled Stored Procedures. Per altre informazioni su funzionalità non supportate, vedere Costrutti Transact-SQL non supportati da OLTP in memoria.

Superficie di attacco delle query nei moduli nativi

Sono supportati i costrutti delle query indicati di seguito:

Espressione CASE: CASE può essere utilizzata in qualsiasi istruzione o clausola che consenta un'espressione valida.

  • Si applica a: SQL Server 2017 (14.x).
    A partire da SQL Server 2017 (14.x), le istruzioni CASE sono supportate per i moduli T-SQL compilati in modo nativo.

Clausola SELECT:

  • Alias di nomi e colonne (usando la sintassi AS o =).

  • Sottoquery scalari

    • Si applica a: SQL Server 2016 (13.x). A partire da SQL Server 2016 (13.x), le sottoquery scalari sono supportate per i moduli compilati in modo nativo.

  • TOP*

  • SELECT DISTINCT

    • Si applica a: SQL Server 2016 (13.x). A partire da SQL Server 2016 (13.x), l'operatore DISTINCT è supportato in moduli compilati in modo nativo.

      • Le aggregazioni DISTINCT non sono supportate.

  • UNION e UNION ALL

    • Si applica a: SQL Server 2016 (13.x). A partire da SQL Server 2016 (13.x), gli operatori UNION e UNION ALL sono supportati in moduli compilati in modo nativo.

  • Assegnazioni di variabili

Clausola FROM:

  • FROM <tabella o variabile di tabella ottimizzata per la memoria>

  • FROM <funzione con valori di tabella inline compilata in modo nativo>

  • LEFT OUTER JOIN, RIGHT OUTER JOIN, CROSS JOIN e INNER JOIN.

    • Si applica a: SQL Server 2016 (13.x). A partire da SQL Server 2016 (13.x), gli operatori JOINS sono supportati in moduli compilati in modo nativo.

  • Sottoquery [AS] table_alias. Per ulteriori informazioni, vedere FROM (Transact-SQL).

    • Si applica a: SQL Server 2016 (13.x). A partire da SQL Server 2016 (13.x), le sottoquery sono supportate per i moduli compilati in modo nativo.

Clausola WHERE:

  • Predicato del filtro IS [NOT] NULL

  • AND, BETWEEN

  • OR, NOT, IN, EXISTS

    • Si applica a: SQL Server 2016 (13.x). A partire da SQL Server 2016 (13.x), gli operatori OR/NOT/IN/EXISTS sono supportati in moduli compilati in modo nativo.

ClausolaGROUP BY :

  • Funzioni di aggregazione AVG, COUNT, COUNT_BIG, MIN, MAX e SUM.

  • MIN e MAX non sono supportate per i tipi nvarchar, char, varchar, varchar, varbinary e binary.

ClausolaORDER BY :

  • DISTINCT non è supportato nella clausola ORDER BY .

  • Supportata con GROUP BY (Transact-SQL) se un'espressione nell'elenco ORDER BY appare in modo identico nell'elenco GROUP BY.

    • Ad esempio, l'espressione GROUP BY a + b ORDER BY a + b è supportata, ma GROUP BY a, b ORDER BY a + b non lo è.

Clausola HAVING:

  • Soggetta alle stesse limitazioni delle espressioni della clausola WHERE.

ORDER BY e TOP sono supportati nei moduli compilati in modo nativo con alcune limitazioni

  • WITH TIES o PERCENT non è supportata nella clausola TOP .

  • DISTINCT non è supportato nella clausola ORDER BY .

  • TOP in combinazione con ORDER BY non supporta un valore superiore a 8.192 quando si utilizza una costante nella clausola TOP .

    • Questo limite può risultare più basso nel caso in cui la query contenga funzioni di aggregazione o dei join. Ad esempio, con un join (due tabelle) il limite scende a 4.096 righe. Con due join (tre tabelle) il limite è 2.730 righe.
    • È possibile che si ottengano risultati maggiori di 8.192 archiviando il numero di righe in una variabile:
DECLARE @v INT = 9000;
SELECT TOP (@v) ... FROM ... ORDER BY ...

Tuttavia, una costante nella clausola TOP assicura prestazioni migliori rispetto a una variabile.

Queste limitazioni di Transact-SQL con compilazione nativa non si applicano all'accesso Transact-SQL interpretato nelle tabelle ottimizzate per la memoria.

Modifica dei dati

Sono supportate le istruzioni DML seguenti.

  • INSERT VALUES (una riga per istruzione) e INSERT ... SELECT

  • UPDATE

  • DELETE

  • La clausola WHERE è supportata con le istruzioni UPDATE e DELETE.

Elementi del linguaggio per il controllo di flusso

Sono supportati i seguenti costrutti degli elementi del linguaggio per il controllo di flusso.

Operatori supportati

Di seguito vengono elencati gli operatori supportati.

  • Operatori di confronto (Transact-SQL) (ad esempio >, <, >= e <=)

  • Operatori unari (+, -).

  • Operatori binari (*, /, +, -, % (modulo)).

    • L'operatore di addizione (+) è supportato sia con i numeri che con le stringhe.

  • Operatori logici (AND, OR, NOT).

  • Operatori bit per bit ~, &, | e ^

  • APPLY - operatore

    • Si applica a: SQL Server 2017 (14.x).
      A partire da SQL Server 2017 (14.x), l'operatore APPLY è supportato in moduli compilati in modo nativo.

Funzioni integrate nei moduli compilati in modo nativo

Le seguenti funzioni sono supportate nei vincoli nelle tabelle ottimizzate per la memoria e nei moduli T-SQL compilati in modo nativo.

  • Tutte le funzioni matematiche (Transact-SQL)

  • Funzioni di data: CURRENT_TIMESTAMP, DATEADD, DATEDIFF, DATEFROMPARTS, DATEPART, DATETIME2FROMPARTS, DATETIMEFROMPARTS, DAY, EOMONTH, GETDATE, GETUTCDATE, MONTH, SMALLDATETIMEFROMPARTS, SYSDATETIME, SYSUTCDATETIME e YEAR.

  • Funzioni stringa: LEN, LTRIM, RTRIM e SUBSTRING.

    • Si applica a: SQL Server 2017 (14.x).
      A partire da SQL Server 2017 (14.x), sono supportate anche le funzioni integrate seguenti: TRIM, TRANSLATE e CONCAT_WS.

  • Funzione di identità: SCOPE_IDENTITY

  • Funzioni NULL: ISNULL

  • Funzioni di identificazione univoca: NEWID e NEWSEQUENTIALID

  • Funzioni JSON

    • Si applica a: SQL Server 2017 (14.x).
      A partire da SQL Server 2017 (14.x), le funzioni JSON sono supportate nei moduli compilati in modo nativo.

  • Funzioni di errore: ERROR_LINE, ERROR_MESSAGE, ERROR_NUMBER, ERROR_PROCEDURE, ERROR_SEVERITY e ERROR_STATE

  • Funzioni di sistema: @@rowcount. Tramite le istruzioni all'interno di stored procedure compilate in modo nativo viene aggiornato @@rowcount, che può essere utilizzato in una stored procedure compilata in modo nativo per determinare il numero di righe interessate dall'ultima istruzione eseguita all'interno di questa stored procedure compilata in modo nativo. Tuttavia, @@rowcount viene reimpostato su 0 all'inizio e alla fine dell'esecuzione di una stored procedure compilata in modo nativo.

  • Funzioni di sicurezza: IS_MEMBER({'group' | 'role'}), IS_ROLEMEMBER ('role' [, 'database_principal']), IS_SRVROLEMEMBER ('role' [, 'login']), ORIGINAL_LOGIN(), SESSION_USER, CURRENT_USER, SUSER_ID(['login']), SUSER_SID(['login'] [, Param2]), SUSER_SNAME([server_user_sid]), SYSTEM_USER, SUSER_NAME, USER, USER_ID(['user']), USER_NAME([id]), CONTEXT_INFO().

  • Le esecuzioni dei moduli nativi possono essere annidate.

Controllo

Il controllo a livello di routine è supportato nelle stored procedure compilate in modo nativo.

Per ulteriori informazioni sul controllo, vedere Creazione di un controllo del server e di una specifica del controllo del database.

Hint di tabella e per la query

Sono supportati gli elementi seguenti:

Per altre informazioni, vedere Hint per la query (Transact-SQL).

Limitazioni relative all'ordinamento

È possibile ordinare più di 8.000 righe in una query che usa TOP (Transact-SQL) e una clausola ORDER BY Clause (Transact-SQL). Tuttavia, senza la clausola ORDER BY (Transact-SQL), TOP (Transact-SQL) può ordinare fino a 8.000 righe, meno se sono presenti join.

Se la query usa sia l'operatore TOP (Transact-SQL) che una clausola ORDER BY (Transact-SQL), è possibile specificare fino a 8192 righe per l'operatore TOP. Se si specificano più di 8192 righe, viene visualizzato il messaggio di errore: Messaggio 41398, livello 16, stato 1, procedura <nomeProcedura>, riga <numeroRiga>. L'operatore TOP può restituire un massimo di 8192 righe. Il numero richiesto è <numero>.

Se non si dispone di una clausola TOP, è possibile ordinare qualsiasi numero di righe con ORDER BY.

Se non si utilizza una clausola ORDER BY, è possibile utilizzare qualsiasi valore intero con l'operatore TOP.

Esempio con TOP N = 8192: compila

CREATE PROCEDURE testTop  
WITH EXECUTE AS OWNER, SCHEMABINDING, NATIVE_COMPILATION  
  AS  
  BEGIN ATOMIC WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')  
    SELECT TOP 8192 ShoppingCartId, CreatedDate, TotalPrice FROM dbo.ShoppingCart  
    ORDER BY ShoppingCartId DESC  
  END;  
GO

Esempio con TOP N > 8192: non riesce a compilare.

CREATE PROCEDURE testTop  
WITH EXECUTE AS OWNER, SCHEMABINDING, NATIVE_COMPILATION  
  AS  
  BEGIN ATOMIC WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')  
    SELECT TOP 8193 ShoppingCartId, CreatedDate, TotalPrice FROM dbo.ShoppingCart  
    ORDER BY ShoppingCartId DESC  
  END;  
GO

Il limite di 8192 righe si applica solo a TOP NN dove è una costante, come negli esempi precedenti. Se è necessario un valore N maggiore di 8192 è possibile assegnare il valore a una variabile e utilizzare tale variabile con TOP.

Esempio di utilizzo di una variabile: compila

CREATE PROCEDURE testTop  
WITH EXECUTE AS OWNER, SCHEMABINDING, NATIVE_COMPILATION  
  AS  
  BEGIN ATOMIC WITH (TRANSACTION ISOLATION LEVEL = SNAPSHOT, LANGUAGE = N'us_english')  
    DECLARE @v int = 8193   
    SELECT TOP (@v) ShoppingCartId, CreatedDate, TotalPrice FROM dbo.ShoppingCart  
    ORDER BY ShoppingCartId DESC  
  END;  
GO

Limitazioni per le righe restituite. In due casi è possibile che il numero di righe che possono essere restituite dall'operatore TOP venga ridotto:

  • Utilizzando JOIN nella query. L'influenza di JOIN sulla limitazione dipende dal piano di query.

  • Utilizzando funzioni di aggregazione o riferimenti a funzioni di aggregazione nella clausola ORDER BY.

La formula per calcolare un valore N massimo supportato nel caso peggiore in TOP N è: N = floor ( 65536 / number_of_tables * 8 + total_size+of+aggs ).

Vedi anche

Stored procedure compilate in modo nativo
Problemi di migrazione relativi alle stored procedure compilate in modo nativo