Partilhar via

Recursos com suporte para módulos T-SQL compilados nativamente

  • Artigo

Aplica-se a: SQL Server Banco de Dados SQL do Azure Instância Gerenciada de SQL do Azure

Este tópico contém uma lista da área da superfície do T-SQL e os recursos com suporte no corpo de módulos T-SQL compilados nativamente, como procedimentos armazenados (CREATE PROCEDURE (Transact-SQL)), gatilhos, funções escalares definidas pelo usuário e funções embutidas com valor de tabela.

Para ver os recursos com suporte na definição de módulos nativos, consulte DDL com suporte para módulos nativamente compilados do T-SQL.

Para obter informações completas sobre construções sem suporte e sobre como resolver problemas de alguns recursos sem suporte em módulos compilados nativamente, consulte Migration Issues for Natively Compiled Stored Procedures. Para mais informações sobre os recursos sem suporte, veja Constructos do Transact-SQL sem suporte no OLTP in-memory.

Área da superfície da consulta em módulos nativos

Há suporte para as seguintes construções de consulta:

Expressão CASE: CASE pode ser usado em qualquer instrução ou cláusula que permita uma expressão válida.

  • Aplica-se a: SQL Server 2017 (14.x).
    Desde o SQL Server 2017 (14.x), as instruções CASE são compatíveis com módulos T-SQL compilados nativamente.

Cláusula SELECT:

  • Aliases de nome e colunas (usando a sintaxe = ou então AS).

  • Subconsultas escalares

    • Aplica-se a: SQL Server 2016 (13.x). Desde o SQL Server 2016 (13.x), as subconsultas escalares são compatíveis com módulos compilados nativamente.

  • INÍCIO*

  • SELECT DISTINCT

    • Aplica-se a: SQL Server 2016 (13.x). Desde o SQL Server 2016 (13.x), o operador DISTINCT é compatível com módulos compilados nativamente.

      • Não há suporte para agregações de DISTINCT.

  • UNION e UNION ALL

    • Aplica-se a: SQL Server 2016 (13.x). Desde o SQL Server 2016 (13.x), os operadores UNION e UNION ALL são compatíveis com módulos compilados nativamente.

  • Atribuições de variável

Cláusula FROM:

  • FROM <tabela com otimização de memória ou variável de tabela>

  • FROM <TVF embutida compilada nativamente>

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

    • Aplica-se a: SQL Server 2016 (13.x). Desde o SQL Server 2016 (13.x), JOINS são compatíveis com módulos compilados nativamente.

  • Subconsultas [AS] table_alias. Para obter mais informações, confira FROM (Transact-SQL).

    • Aplica-se a: SQL Server 2016 (13.x). Desde o SQL Server 2016 (13.x), as subconsultas são compatíveis com módulos compilados nativamente.

Cláusula WHERE:

  • Predicado de filtro IS [NOT] NULL

  • AND, BETWEEN

  • OR, NOT, IN, EXISTS

    • Aplica-se a: SQL Server 2016 (13.x). Desde o SQL Server 2016 (13.x), os operadores OR/NOT/IN/EXISTS são compatíveis com módulos compilados nativamente.

CláusulaGROUP BY :

  • Funções de agregação AVG, COUNT, COUNT_BIG, MIN, MAX e SUM.

  • MIN e MAX não têm suporte para os tipos nvarchar, char, varchar, varchar, varbinary e binary.

CláusulaORDER BY :

  • Não há suporte para DISTINCT na cláusula ORDER BY .

  • É compatível com GROUP BY (Transact-SQL) se uma expressão na lista ORDER BY é exibida literalmente na lista GROUP BY.

    • Por exemplo, GROUP BY + b ORDER BY a + b tem suporte, mas GROUP BY a, b ORDER BY a + b, não.

Cláusula HAVING:

  • sujeito às mesmas limitações de expressão que a cláusula WHERE.

ORDER BY e TOP têm suporte em módulos compilados nativamente, com algumas restrições

  • Não há suporte para WITH TIES ou PERCENT na cláusula TOP .

  • Não há suporte para DISTINCT na cláusula ORDER BY .

  • TOP combinado com ORDER BY não dá suporte a mais de 8.192 ao usar uma constante na cláusula TOP .

    • Esse limite poderá ser diminuído caso a consulta contenha junções ou funções de agregação. (Por exemplo, com uma junção (duas tabelas), o limite é 4.096 linhas. Com duas junções (três tabelas), o limite é 2.730 linhas.)
    • Você pode obter resultados maiores que 8.192 armazenando o número de linhas em uma variável:
DECLARE @v INT = 9000;
SELECT TOP (@v) ... FROM ... ORDER BY ...

No entanto, uma constante na cláusula TOP resulta em um desempenho melhor comparado a usar uma variável.

Essas restrições no Transact-SQL compilado nativamente não se aplicam ao acesso ao Transact-SQL interpretado em tabelas com otimização de memória.

Modificação de dados

Há suporte para as instruções DML a seguir.

  • INSERT VALUES (uma linha por instrução) e INSERT ... SELECT

  • UPDATE

  • DELETE

  • WHERE tem suporte com instruções UPDATE e DELETE.

Linguagem de controle de fluxo

Há suporte para as construções de linguagem de controle de fluxo a seguir.

Operadores de suportados

Há suporte para os operadores que se seguem.

  • Operadores de comparação (Transact-SQL) (por exemplo, >, <, >= e <=)

  • Operadores unários (+, -).

  • Operadores binários (*, /, +, -, % (módulo)).

    • O operador de adição (+) tem suporte em números e cadeias de caracteres.

  • Operadores lógicos (AND, OR, NOT).

  • Operadores bit a bit ~, &, |, e ^

  • operador APPLY

    • Aplica-se a: SQL Server 2017 (14.x).
      Desde o SQL Server 2017 (14.x), o operador APPLY é compatível com módulos compilados nativamente.

Funções internas em módulos compilados nativamente

As funções a seguir têm suporte em restrições nas tabelas com otimização de memória e em módulos T-SQL compilados nativamente.

  • Todas as Funções matemáticas (Transact-SQL)

  • Funções de data: CURRENT_TIMESTAMP, DATEADD, DATEDIFF, DATEFROMPARTS, DATEPART, DATETIME2FROMPARTS, DATETIMEFROMPARTS, DAY, EOMONTH, GETDATE, GETUTCDATE, MONTH, SMALLDATETIMEFROMPARTS, SYSDATETIME, SYSUTCDATETIME e YEAR.

  • Funções de cadeia de caracteres: LEN, LTRIM, RTRIM e SUBSTRING.

    • Aplica-se a: SQL Server 2017 (14.x).
      Desde o SQL Server 2017 (14.x), as seguintes funções internas também são compatíveis: TRIM, TRANSLATE e CONCAT_WS.

  • Funções de identidade: SCOPE_IDENTITY

  • Funções NULL: ISNULL

  • Funções Uniqueidentifier: NEWID e NEWSEQUENTIALID

  • Funções JSON

    • Aplica-se a: SQL Server 2017 (14.x).
      Desde o SQL Server 2017 (14.x), as funções JSON são compatíveis com módulos compilados nativamente.

  • Funções de erro: ERROR_LINE, ERROR_MESSAGE, ERROR_NUMBER, ERROR_PROCEDURE, ERROR_SEVERITY e ERROR_STATE

  • Funções do sistema: @@rowcount. As instruções dentro de procedimentos armazenados compilados nativamente atualizam @@rowcount e você pode usar @@rowcount em um procedimento armazenado compilado nativamente para determinar o número de linhas afetadas pela última instrução executada dentro desse procedimento armazenado compilado nativamente. No entanto, @@rowcount é redefinido como 0 no início e no final da execução de um procedimento armazenado compilado nativamente.

  • Funções de segurança: IS_MEMBER({'grupo' | 'função'}), IS_ROLEMEMBER ('função' [, 'entidade_do_banco_de_dados']), IS_SRVROLEMEMBER ('função' [, 'logon']), ORIGINAL_LOGIN(), SESSION_USER, CURRENT_USER, SUSER_ID(['logon']), SUSER_SID(['logon'] [, Param2]), SUSER_SNAME([sid_de_usuário_do_servidor]), SYSTEM_USER, SUSER_NAME, USER, USER_ID(['usuário']), USER_NAME([id]), CONTEXT_INFO().

  • Execuções de módulos nativos podem ser aninhadas.

Auditoria

A auditoria no nível de procedimento tem suporte em procedimentos armazenados compilados nativamente.

Para obter mais informações sobre a auditoria, consulte Create a Server Audit and Database Audit Specification.

Dicas de tabela e de consulta

Há suporte para o seguinte:

Para obter mais informações, veja Dicas de consulta (Transact-SQL).

Limitações na classificação

Você pode classificar mais do que 8.000 linhas em uma consulta que use TOP (Transact-SQL) e uma Cláusula ORDER BY (Transact-SQL). No entanto, sem a Cláusula ORDER BY (Transact-SQL), TOP (Transact-SQL) pode classificar até 8.000 linhas (menos linhas se houver junções).

Se sua consulta usar o operador TOP (Transact-SQL) e uma Cláusula ORDER BY (Transact-SQL), você poderá especificar até 8.192 linhas para o operador TOP. Se você especificar mais de 8.192 linhas, receberá a mensagem de erro: Msg 41398, Nível 16, Estado 1, Procedimento <procedureName>, Linha <lineNumber> O operador TOP pode retornar no máximo 8.192 linhas; foram solicitadas <number>.

Se você não tiver uma cláusula TOP, poderá classificar qualquer número de linhas com ORDER BY.

Se você não usar uma cláusula ORDER BY, poderá usar qualquer valor inteiro com o operador TOP.

Exemplo com 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

Exemplo com TOP N > 8.192: não 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 8193 ShoppingCartId, CreatedDate, TotalPrice FROM dbo.ShoppingCart  
    ORDER BY ShoppingCartId DESC  
  END;  
GO

A limitação de 8192 linhas só se aplica a TOP N onde N é uma constante, como nos exemplos anteriores. Se você precisar de N maior que 8192, poderá atribuir o valor a uma variável e usar essa variável com TOP.

Exemplo que usa uma variável: 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

Limitações nas linhas retornadas: Há dois casos em que isso pode, potencialmente, reduzir o número de linhas a serem retornadas pelo operador TOP:

  • Uso de JOINs na consulta. A influência de JOINs na limitação depende do plano de consulta.

  • Uso de funções de agregação ou de referências a funções de agregação na cláusula ORDER BY.

A fórmula para calcular o pior caso de N com suporte em TOP N é: N = floor ( 65536 / number_of_tables * 8 + total_size+of+aggs ).

Confira também

Procedimentos armazenados compilados nativamente
Problemas de migração para procedimentos armazenados compilados nativamente