Características admitidas en los módulos T-SQL compilados de forma nativaSupported Features for Natively Compiled T-SQL Modules

SE APLICA A: síSQL Server síAzure SQL Database noAzure SQL Data Warehouse noAlmacenamiento de datos paralelos APPLIES TO: yesSQL Server yesAzure SQL Database noAzure SQL Data Warehouse noParallel Data Warehouse

En este tema se incluye una lista de áreas expuestas y características admitidas de T-SQL en el cuerpo de los módulos T-SQL compilados de forma nativa, como procedimientos almacenados (CREATE PROCEDURE (Transact-SQL)), funciones escalares definidas por el usuario, funciones con valores de tabla insertadas y desencadenadores.This topic contains a list of T-SQL surface area and supported features in the body of natively compiled T-SQL modules, such as stored procedures (CREATE PROCEDURE (Transact-SQL)), scalar user-defined functions, inline table-valued functions, and triggers.

Si quiere conocer las características admitidas en torno a la definición de los módulos nativos, vea Construcciones DDL admitidas para módulos T-SQL compilados de forma nativa.For supported features around the definition of native modules, see Supported DDL for Natively Compiled T-SQL modules.

Para tener información completa sobre las construcciones no admitidas y sobre cómo evitar algunas de las características no admitidas en los módulos compilados de forma nativa, consulte Migration Issues for Natively Compiled Stored Procedures.For complete information about unsupported constructs, and for information about how to work around some of the unsupported features in natively compiled modules, see Migration Issues for Natively Compiled Stored Procedures. Para obtener más información sobre las características no compatibles, vea Construcciones Transact-SQL no admitidas por OLTP en memoria.For more information about unsupported features, see Transact-SQL Constructs Not Supported by In-Memory OLTP.

Área expuesta de consulta en los módulos nativosQuery Surface Area in Native Modules

Se admiten las siguientes construcciones de consulta:The following query constructs are supported:

Expresión CASE: CASE se puede utilizar en cualquier instrucción o cláusula que permite una expresión válida.CASE expression: CASE can be used in any statement or clause that allows a valid expression.

  • Se aplica a: SQL Server 2017 (14.x)SQL Server 2017 (14.x).Applies to: SQL Server 2017 (14.x)SQL Server 2017 (14.x).
    A partir de SQL Server 2017 (14.x)SQL Server 2017 (14.x), ahora se admiten las instrucciones CASE para módulos T-SQL compilados de forma nativa.Beginning with SQL Server 2017 (14.x)SQL Server 2017 (14.x), CASE statements are now supported for natively compiled T-SQL modules.

Cláusula SELECT:SELECT clause:

  • Alias de columnas y nombre (con sintaxis AS o =).Columns and name aliases (using either AS or = syntax).

  • Subconsultas escalaresScalar subqueries

    • Se aplica a: SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x). A partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x), ahora se admiten las subconsultas escalares en módulos compilados de forma nativa.Beginning with SQL Server 2016 (13.x)SQL Server 2016 (13.x), scalar subqueries are now supported in natively compiled modules.
  • TOP*TOP*

  • SELECT DISTINCTSELECT DISTINCT

    • Se aplica a: SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x). A partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x), el operador DISTINCT se admite en módulos compilados de forma nativa.Beginning with SQL Server 2016 (13.x)SQL Server 2016 (13.x), the DISTINCT operator is supported in natively compiled modules.

          DISTINCT aggregates are not supported.  
      
  • UNION y UNION ALLUNION and UNION ALL

    • Se aplica a: SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x). A partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x), los operadores UNION y UNION ALL se admiten en módulos compilados de forma nativa.Beginning with SQL Server 2016 (13.x)SQL Server 2016 (13.x), UNION and UNION ALL operators are now supported in natively compiled modules.
  • Asignaciones de variablesVariable assignments

Cláusula FROM:FROM clause:

  • FROM <tabla con optimización para memoria o variable de tabla>FROM <memory optimized table or table variable>

  • FROM <TVF insertada compilada de forma nativa>FROM <natively compiled inline TVF>

  • LEFT OUTER JOIN, RIGHT OUTER JOIN, CROSS JOIN y INNER JOIN.LEFT OUTER JOIN, RIGHT OUTER JOIN, CROSS JOIN and INNER JOIN.

    • Se aplica a: SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x). A partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x), ahora se admiten las operaciones JOIN en módulos compilados de forma nativa.Beginning with SQL Server 2016 (13.x)SQL Server 2016 (13.x), JOINS are now supported in natively compiled modules.
  • Subconsultas [AS] table_alias.Subqueries [AS] table_alias. Para obtener más información, vea FROM (Transact-SQL).For more information, see FROM (Transact-SQL).

    • Se aplica a: SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x). A partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x), ahora se admiten las subconsultas en módulos compilados de forma nativa.Beginning with SQL Server 2016 (13.x)SQL Server 2016 (13.x), Subqueries are now supported in natively compiled modules.

Cláusula WHERE:WHERE clause:

  • Predicado de filtro IS [NOT] NULLFilter predicate IS [NOT] NULL

  • AND, BETWEENAND, BETWEEN

  • OR, NOT, IN, EXISTSOR, NOT, IN, EXISTS

    • Se aplica a: SQL Server 2016 (13.x)SQL Server 2016 (13.x).Applies to: SQL Server 2016 (13.x)SQL Server 2016 (13.x). A partir de SQL Server 2016 (13.x)SQL Server 2016 (13.x), ahora se admiten los operadores ON, NOT, IN y EXISTS en módulos compilados de forma nativa.Beginning with SQL Server 2016 (13.x)SQL Server 2016 (13.x), OR/NOT/IN/EXISTS operators are now supported in natively compiled modules.

CláusulaGROUP BY :GROUP BY clause:

  • Funciones de agregado AVG, COUNT, COUNT_BIG, MIN, MAX y SUM.Aggregate functions AVG, COUNT, COUNT_BIG, MIN, MAX, and SUM.

  • MIN o MAX no se admiten para los tipos nvarchar, char, varchar, varchar, varbinary y binary.MIN and MAX are not supported for types nvarchar, char, varchar, varchar, varbinary, and binary.

CláusulaORDER BY :ORDER BY clause:

  • No hay compatibilidad con DISTINCT en la cláusula ORDER BY .There is no support for DISTINCT in the ORDER BY clause.

  • Se admite con GROUP BY (Transact-SQL) si una expresión de la lista ORDER BY aparece literalmente en la lista GROUP BY.Is supported with GROUP BY (Transact-SQL) if an expression in the ORDER BY list appears verbatim in the GROUP BY list.

    • Por ejemplo, se admite GROUP BY a + b ORDER BY a + b pero no GROUP BY a, b ORDER BY a + b.For example, GROUP BY a + b ORDER BY a + b is supported, but GROUP BY a, b ORDER BY a + b is not.

Cláusula HAVING:HAVING clause:

  • Está sujeta a las mismas limitaciones de expresión que la cláusula WHERE.Is subject to the same expression limitations as the WHERE clause.

Se admiten ORDER BY y TOP en módulos compilados de forma nativa, con algunas restricciones.ORDER BY and TOP are supported in natively compiled modules, with some restrictions

  • No hay compatibilidad con WITH TIES ni PERCENT en la cláusula TOP .There is no support for WITH TIES or PERCENT in the TOP clause.

  • No hay compatibilidad con DISTINCT en la cláusula ORDER BY .There is no support for DISTINCT in the ORDER BY clause.

  • TOP combinada con ORDER BY no admite más de 8.192 elementos cuando se utiliza una constante en la cláusula TOP .TOP combined with ORDER BY does not support more than 8,192 when using a constant in the TOP clause.

    • Este límite puede reducirse en caso de que la consulta contenga combinaciones o funciones de agregado.This limit may be lowered in case the query contains joins or aggregate functions. (Por ejemplo, con una combinación (dos tablas), el límite es de 4.096 filas.(For example, with one join (two tables), the limit is 4,096 rows. Con dos combinaciones (tres tablas), el límite es de 2.730 filas).With two joins (three tables), the limit is 2,730 rows.)
    • Puede obtener más de 8.192 resultados si almacena el número de filas en una variable:You can obtain results greater than 8,192 by storing the number of rows in a variable:
DECLARE @v INT = 9000;
SELECT TOP (@v) ... FROM ... ORDER BY ...

Sin embargo, una constante en la cláusula TOP produce un rendimiento mejor en comparación con el uso de una variable.However, a constant in the TOP clause results in better performance compared to using a variable.

Estas restricciones en Transact-SQLTransact-SQL compilado de forma nativa no se aplican al acceso mediante Transact-SQLTransact-SQL interpretado a las tablas optimizadas para memoria.These restrictions on natively compiled Transact-SQLTransact-SQL do not apply to interpreted Transact-SQLTransact-SQL access on memory-optimized tables.

Modificación de datosData Modification

Se admiten las siguientes instrucciones DML.The following DML statements are supported.

  • INSERT VALUES (una fila por instrucción) e INSERT SELECT... SELECTINSERT VALUES (one row per statement) and INSERT ... SELECT

  • UPDATEUPDATE

  • DeleteDELETE

  • Se admite WHERE con instrucciones UPDATE y DELETE.WHERE is supported with UPDATE and DELETE statements.

Idioma de control de flujoControl-of-flow language

Se admiten las siguientes construcciones de lenguaje de control de flujo.The following control-of-flow language constructs are supported.

Operadores admitidosSupported Operators

Se admiten los siguientes operadores.The following operators are supported.

  • Operadores de comparación (Transact-SQL) (por ejemplo, >, <, >= y <=)Comparison Operators (Transact-SQL) (for example, >, <, >=, and <=)

  • Operadores unarios (+, -).Unary operators (+, -).

  • Operadores binarios ((*, /, +, -, % (módulo)).Binary operators (*, /, +, -, % (modulo)).

           The plus operator (+) is supported on both numbers and strings.  
    
  • Operadores lógicos (AND, OR, NOT).Logical operators (AND, OR, NOT).

  • Operadores ~, &, | y ^ bit a bitBitwise operators ~, &, |, and ^

  • APPLY, operadorAPPLY operator

    • Se aplica a: SQL Server 2017 (14.x)SQL Server 2017 (14.x).Applies to: SQL Server 2017 (14.x)SQL Server 2017 (14.x).
      A partir de SQL Server 2017 (14.x)SQL Server 2017 (14.x), el operador APPLY se admite en los módulos compilados de forma nativa.Beginning with SQL Server 2017 (14.x)SQL Server 2017 (14.x), the APPLY operator is supported in natively compiled modules.

Funciones integradas en módulos compilados de forma nativaBuilt-in Functions in Natively Compiled Modules

Las funciones siguientes se admiten en restricciones de tablas optimizadas para memoria y en módulos T-SQL compilados de forma nativa.The following functions are supported in constraints on memory-optimized tables and in natively compiled T-SQL modules.

  • Todas las funciones matemáticas (Transact-SQL)All Mathematical Functions (Transact-SQL)

  • Funciones de fecha: CURRENT_TIMESTAMP, DATEADD, DATEDIFF, DATEFROMPARTS, DATEPART, DATETIME2FROMPARTS, DATETIMEFROMPARTS, DAY, EOMONTH, GETDATE, GETUTCDATE, MONTH, SMALLDATETIMEFROMPARTS, SYSDATETIME, SYSUTCDATETIME y YEAR.Date functions: CURRENT_TIMESTAMP, DATEADD, DATEDIFF, DATEFROMPARTS, DATEPART, DATETIME2FROMPARTS, DATETIMEFROMPARTS, DAY, EOMONTH, GETDATE, GETUTCDATE, MONTH, SMALLDATETIMEFROMPARTS, SYSDATETIME, SYSUTCDATETIME, and YEAR.

  • Funciones de cadena: LEN, LTRIM, RTRIM y SUBSTRING.String functions: LEN, LTRIM, RTRIM, and SUBSTRING.

    • Se aplica a: SQL Server 2017 (14.x)SQL Server 2017 (14.x).Applies to: SQL Server 2017 (14.x)SQL Server 2017 (14.x).
      A partir de SQL Server 2017 (14.x)SQL Server 2017 (14.x), también se admiten las siguientes funciones integradas: TRIM, TRANSLATE y CONCAT_WS.Beginning with SQL Server 2017 (14.x)SQL Server 2017 (14.x), the following built-in functions are also supported: TRIM, TRANSLATE, and CONCAT_WS.
  • Funciones de identidad: SCOPE_IDENTITYIdentity functions: SCOPE_IDENTITY

  • Funciones NULL: ISNULLNULL functions: ISNULL

  • Funciones uniqueidentifier: NEWID y NEWSEQUENTIALIDUniqueidentifier functions: NEWID and NEWSEQUENTIALID

  • Funciones JSONJSON functions

    • Se aplica a: SQL Server 2017 (14.x)SQL Server 2017 (14.x).Applies to: SQL Server 2017 (14.x)SQL Server 2017 (14.x).
      A partir de SQL Server 2017 (14.x)SQL Server 2017 (14.x), las funciones JSON se admiten en los módulos compilados de forma nativa.Beginning with SQL Server 2017 (14.x)SQL Server 2017 (14.x), the JSON functions are supported in natively compiled modules.
  • Funciones de error: ERROR_LINE, ERROR_MESSAGE, ERROR_NUMBER, ERROR_PROCEDURE, ERROR_SEVERITY y ERROR_STATEError functions: ERROR_LINE, ERROR_MESSAGE, ERROR_NUMBER, ERROR_PROCEDURE, ERROR_SEVERITY, and ERROR_STATE

  • Funciones del sistema: @@rowcount.System Functions: @@rowcount. Las instrucciones de los procedimientos almacenados compilados de forma nativa actualizan @@rowcount y puede usar @@rowcount en un procedimiento almacenado compilado de forma nativa para determinar el número de filas afectadas por la última instrucción ejecutada dentro de ese procedimiento almacenado compilado de forma nativa.Statements inside natively compiled stored procedures update @@rowcount and you can use @@rowcount in a natively compiled stored procedure to determine the number of rows affected by the last statement executed within that natively compiled stored procedure. Pero @@rowcount se restablece en 0 al principio y al final de la ejecución de un procedimiento almacenado compilado de forma nativa.However, @@rowcount is reset to 0 at the start and at the end of the execution of a natively compiled stored procedure.

  • Funciones de seguridad: 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().Security functions: 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().

  • Se pueden anidar las ejecuciones de módulos nativos.Executions of native modules can be nested.

AuditoríaAuditing

Se admite la auditoría a nivel de procedimiento en los procedimientos almacenados compilados de forma nativa.Procedure level auditing is supported in natively compiled stored procedures.

Para obtener más información sobre la auditoría, vea Crear una especificación de auditoría de servidor y de auditoría de base de datosFor more information about auditing, see Create a Server Audit and Database Audit Specification.

Sugerencias de consulta y tablaTable and Query Hints

Se admite lo siguiente:The following are supported:

Para obtener más información, vea Sugerencias de consulta (Transact-SQL).For more information, see Query Hints (Transact-SQL).

Limitaciones de ordenaciónLimitations on Sorting

Puede ordenar más de 8000 filas en una consulta que use TOP (Transact-SQL) y una cláusula ORDER BY (Transact-SQL).You can sort greater than 8,000 rows in a query that uses TOP (Transact-SQL) and an ORDER BY Clause (Transact-SQL). Pero sin la cláusula ORDER BY (Transact-SQL), TOP (Transact-SQL) puede ordenar hasta 8000 filas (si hay combinaciones, menos filas).However, without ORDER BY Clause (Transact-SQL), TOP (Transact-SQL) can sort up to 8,000 rows (fewer rows if there are joins).

Si la consulta usa el operador TOP (Transact-SQL) y una cláusula ORDER BY (Transact-SQL), puede especificar hasta 8192 filas para el operador TOP.If your query uses both the TOP (Transact-SQL) operator and an ORDER BY Clause (Transact-SQL), you can specify up to 8192 rows for the TOP operator. Si especifica más de 8192 filas, obtiene el mensaje de error: Mensaje 41398, nivel 16, estado 1, procedimiento <<nombre_procedimiento> , línea <número_línea> El operador TOP puede devolver un máximo de 8192 filas; el número solicitado es <número> .If you specify more than 8192 rows you get the error message: Msg 41398, Level 16, State 1, Procedure <procedureName>, Line <lineNumber> The TOP operator can return a maximum of 8192 rows; <number> was requested.

Si no tiene una cláusula TOP, puede ordenar cualquier número de filas con ORDER BY.If you do not have a TOP clause, you can sort any number of rows with ORDER BY.

Si no utiliza una cláusula ORDER BY, puede utilizar un valor entero con el operador TOP.If you do not use an ORDER BY clause, you can use any integer value with the TOP operator.

Ejemplo con TOP N = 8192: se compila.Example with TOP N = 8192: Compiles

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  

Ejemplo con TOP N > 8192: no se compila.Example with TOP N > 8192: Fails to compile.

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  

La limitación de 8192 filas solo se aplica a TOP N donde N es una constante, como en los ejemplos anteriores.The 8192 row limitation only applies to TOP N where N is a constant, as in the preceding examples. Si necesita un número N mayor que 8192 puede asignar el valor a una variable y utilizar esa variable con TOP.If you need N greater than 8192 you can assign the value to a variable and use that variable with TOP.

Ejemplo con una variable: se compila.Example using a variable: Compiles

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  

Limitaciones para las filas devueltas: hay dos casos en los que se puede reducir el número de filas que puede devolver el operador TOP:Limitations on rows returned: There are two cases where that can potentially reduce the number of rows that can be returned by the TOP operator:

  • Usar JOIN en la consulta.Using JOINs in the query. El efecto de JOIN en la limitación depende del plan de consulta.The influence of JOINs on the limitation depends on the query plan.

  • Usar funciones de agregado o referencias a funciones de agregado en la cláusula ORDER BY.Using aggregate functions or references to aggregate functions in the ORDER BY clause.

La fórmula para calcular un N máximo de peor caso admitido en TOP N es: N = floor ( 65536 / number_of_tables * 8 + total_size+of+aggs ).The formula to calculate a worst case maximum supported N in TOP N is: N = floor ( 65536 / number_of_tables * 8 + total_size+of+aggs ).

Consulte tambiénSee Also

Procedimientos almacenados compilados de forma nativa Natively Compiled Stored Procedures
Problemas de migración para los procedimientos almacenados compilados de forma nativaMigration Issues for Natively Compiled Stored Procedures