Utilizar conjuntos de resultados activos múltiples (MARS)Using Multiple Active Result Sets (MARS)

SE APLICA A: síSQL Server síAzure SQL Database síAzure SQL Data Warehouse síAlmacenamiento de datos paralelos APPLIES TO: yesSQL Server yesAzure SQL Database yesAzure SQL Data Warehouse yesParallel Data Warehouse

En SQL Server 2005 (9.x)SQL Server 2005 (9.x), se ha introducido la compatibilidad con los conjuntos de resultados activos múltiples (MARS) para las aplicaciones que acceden a Motor de base de datosDatabase Engine.SQL Server 2005 (9.x)SQL Server 2005 (9.x) introduced support for multiple active result sets (MARS) in applications accessing the Motor de base de datosDatabase Engine. En versiones anteriores de SQL ServerSQL Server, las aplicaciones de base de datos no podían mantener varias instrucciones activas en una conexión.In earlier versions of SQL ServerSQL Server, database applications could not maintain multiple active statements on a connection. La aplicación, cuando utilizaba conjuntos de resultados predeterminados de SQL ServerSQL Server, tenía que procesar o cancelar todos los conjuntos de resultados de un lote para poder ejecutar cualquier otro lote en esa conexión.When using SQL ServerSQL Server default result sets, the application had to process or cancel all result sets from one batch before it could execute any other batch on that connection. En SQL Server 2005 (9.x)SQL Server 2005 (9.x) se introdujo un nuevo atributo de conexión que permite a las aplicaciones tener más de una solicitud pendiente por conexión y, en particular, tener más de un conjunto de resultados predeterminado activo por conexión.SQL Server 2005 (9.x)SQL Server 2005 (9.x) introduced a new connection attribute that allows applications to have more than one pending request per connection, and in particular, to have more than one active default result set per connection.

MARS simplifica el diseño de aplicaciones con una serie de capacidades nuevas que se indican a continuación:MARS simplifies application design with the following new capabilities:

  • Las aplicaciones pueden tener varios conjuntos de resultados predeterminados abiertos e intercalar la lectura de los mismos.Applications can have multiple default result sets open and can interleave reading from them.

  • Las aplicaciones pueden ejecutar otras instrucciones (por ejemplo, INSERT, UPDATE, DELETE y llamadas a procedimientos almacenados) mientras los conjuntos de resultados predeterminados están abiertos.Applications can execute other statements (for example, INSERT, UPDATE, DELETE, and stored procedure calls) while default result sets are open.

Las aplicaciones que usan MARS encontrarán útiles las siguientes directrices:Applications using MARS will find the following guidelines beneficial:

  • Los conjuntos de resultados predeterminados deben usarse para conjuntos de resultados cortos o de corta duración generados por instrucciones SQL únicas (SELECT, DML con OUTPUT, RECEIVE, READ TEXT, etc.).Default results sets should be used for short lived or short result sets generated by single SQL statements (SELECT, DML with OUTPUT, RECEIVE, READ TEXT, and so on).

  • Los cursores de servidor deben usarse para conjuntos de resultados mayores o de mayor duración generados por instrucciones SQL únicas.Server cursors should be used for longer lived or large result sets generated by single SQL statements.

  • Lea siempre los resultados hasta el final para las solicitudes de procedimientos, independientemente de que devuelvan o no resultados, y para los lotes que devuelven varios resultados.Always read to the end of results for procedural requests regardless of whether they return results or not, and for batches that return multiple results.

  • Siempre que sea posible, use llamadas a la API para cambiar las propiedades de conexión y administrar las transacciones con prioridad con respecto a las instrucciones Transact-SQLTransact-SQL.Wherever possible, use API calls to change connection properties and manage transactions in preference to Transact-SQLTransact-SQL statements.

  • En MARS, está prohibida la suplantación de ámbito de sesión mientras se ejecutan lotes simultáneos.In MARS, session-scoped impersonation is prohibited while concurrent batches are running.

Nota

De forma predeterminada, no está habilitada la funcionalidad de MARS.By default, MARS functionality is not enabled. Para usar MARS al conectarse a SQL ServerSQL Server con SQL ServerSQL Server Native Client, debe habilitarlo específicamente dentro de una cadena de conexión.To use MARS when connecting to SQL ServerSQL Server with SQL ServerSQL Server Native Client, you must specifically enable it within a connection string. Para obtener más información, vea las secciones sobre el proveedor OLE DB de SQL ServerSQL Server Native Client y el controlador ODBC de SQL ServerSQL Server Native Client, más adelante en este tema.For more information, see the SQL ServerSQL Server Native Client OLE DB provider and SQL ServerSQL Server Native Client ODBC driver sections, later in this topic.

SQL ServerSQL Server Native Client no limita el número de instrucciones activas en una conexión.Native Client does not limit the number of active statements on a connection.

Las aplicaciones típicas que no necesitan tener más de un único lote de varias instrucciones o un único procedimiento almacenado que se ejecute al mismo tiempo podrán beneficiarse de MARS sin necesidad de entender cómo se implementa MARS.Typical applications which do not need to have more than a single multistatement batch or stored procedure executing at the same time will benefit from MARS without having to understand how MARS is implemented. No obstante, las aplicaciones con requisitos más complejos necesitan tener estas consideraciones en cuenta.However, applications with more complex requirements do need to take account of this.

MARS habilita la ejecución intercalada de varias solicitudes dentro de una única conexión.MARS enables the interleaved execution of multiple requests within a single connection. Es decir, permite la ejecución de un lote y, dentro de su ejecución, permite que se ejecuten otras solicitudes.That is, it allows a batch to run, and within its execution, it allows other requests to execute. Tenga en cuenta, no obstante, que MARS se define en términos de intercalación, no de ejecución en paralelo.Note, however, that MARS is defined in terms of interleaving, not in terms of parallel execution.

La infraestructura de MARS permite la ejecución de varios lotes en modo intercalado, aunque la ejecución solo puede intercambiarse en puntos bien definidos.The MARS infrastructure allows multiple batches to execute in an interleaved fashion, though execution can only be switched at well defined points. Además, la mayoría de las instrucciones deben ejecutarse de forma atómica dentro de un lote.In addition, most statements must run atomically within a batch. Las instrucciones que devuelven las filas al cliente, que a veces se conocen como puntos de rendimiento, se pueden intercalar la ejecución antes de completarse mientras se envían filas al cliente, por ejemplo:Statements which return rows to the client, which are sometimes referred to as yield points, are allowed to interleave execution before completion while rows are being sent to the client, for example:

  • SELECTSELECT

  • FETCHFETCH

  • RECEIVERECEIVE

Cualquier otra instrucción que se ejecute como parte de un procedimiento almacenado o de un lote deberá ejecutarse hasta completarse para poder cambiar la ejecución a otras solicitudes MARS.Any other statements that are executed as part of a stored procedure or batch must run to completion before execution can be switched to other MARS requests.

La manera exacta en la que los lotes intercalan la ejecución se ve afectada por diversos factores, y es difícil predecir la secuencia exacta en la que se ejecutarán los comandos procedentes de varios lotes que contengan puntos de rendimiento.The exact manner in which batches interleave execution is influenced by a number of factors, and it is difficult to predict the exact sequence in which commands from multiple batches that contain yield points will be executed. Tenga cuidado para evitar efectos secundarios no deseados debidos a la ejecución intercalada de esos lotes complejos.Be careful to avoid unwanted side effects due to interleaved execution of such complex batches.

Evite problemas utilizando llamadas a la API en lugar de instrucciones Transact-SQLTransact-SQL para administrar el estado de conexión (SET, USE) y las transacciones (BEGIN TRAN, COMMIT, ROLLBACK) no incluyendo estas instrucciones en lotes de varias instrucciones que también contengan puntos de rendimiento y serializando la ejecución de dichos lotes mediante el consumo o la cancelación de todos los resultados.Avoid problems by using API calls rather than Transact-SQLTransact-SQL statements to manage connection state (SET, USE) and transactions (BEGIN TRAN, COMMIT, ROLLBACK) by not including these statements in multi-statement batches that also contain yield points, and by serializing execution of such batches by consuming or canceling all results.

Nota

Un lote o un procedimiento almacenado que inicie una transacción manual o implícita cuando MARS esté habilitado debe completar la transacción antes de salir del lote.A batch or stored procedure which starts a manual or implicit transaction when MARS is enabled must complete the transaction before the batch exits. Si no lo hace, SQL ServerSQL Server revierte todos los cambios realizados por la transacción cuando finaliza el lote.If it does not, SQL ServerSQL Server rolls back all changes made by the transaction when the batch finishes. SQL ServerSQL Server administra este tipo de transacción como una transacción de ámbito de lote.Such a transaction is managed by SQL ServerSQL Server as a batch-scoped transaction. Se trata de un nuevo tipo de transacción que se introdujo en SQL Server 2005 (9.x)SQL Server 2005 (9.x) para permitir el uso de procedimientos almacenados con comportamiento correcto cuando MARS está habilitado.This is a new type of transaction introduced in SQL Server 2005 (9.x)SQL Server 2005 (9.x) to enable existing well-behaved stored procedures to be used when MARS is enabled. Para obtener más información acerca de las transacciones de lote, vea instrucciones Transaction (Transact-SQL).For more information about batch-scoped transactions, see Transaction Statements (Transact-SQL).

Para obtener un ejemplo del uso de MARS desde ADO, vea utilizar ADO con SQL Server Native Client.For an example of using MARS from ADO, see Using ADO with SQL Server Native Client.

OLTP en memoriaIn-Memory OLTP

OLTP en memoria admite MARS mediante consultas y procedimientos almacenados compilados de forma nativa.In-memory OLTP supports MARS using queries and natively compiled stored procedures. MARS permite solicitantes datos de varias consultas sin necesidad de recuperar completamente cada conjunto antes de enviar una solicitud para capturar las filas de un nuevo conjunto de resultados de resultados.MARS enables requesting data from multiple queries without the need to completely retrieve each result set before sending a request to fetch rows from a new result set. Para leer correctamente de resultados abiertos varios conjuntos debe usar un MARS habilitado conexión.To successfully read from multiple open result sets you must use a MARS enabled connection.

MARS está deshabilitada de forma predeterminada, por lo que debe habilitar explícitamente mediante la adición de MultipleActiveResultSets=True en una cadena de conexión.MARS is disabled by default so you must explicitly enable it by adding MultipleActiveResultSets=True to a connection string. El ejemplo siguiente muestra cómo conectarse a una instancia de SQL Server y especificar que MARS está habilitado:The following example demonstrates how to connect to an instance of SQL Server and specify that MARS is enabled:

Data Source=MSSQL; Initial Catalog=AdventureWorks; Integrated Security=SSPI; MultipleActiveResultSets=True  

MARS con OLTP en memoria es básicamente el mismo que MARS en el resto del motor de SQL.MARS with In-Memory OLTP is essentially the same as MARS in the rest of the SQL engine. A continuación enumeran las diferencias al utilizar MARS en las tablas optimizadas para memoria y de forma nativa procedimientos almacenados compilados.The following lists the differences when using MARS in memory-optimized tables and natively compiled stored procedures.

Las tablas optimizadas para memoria y MARSMARS and memory-optimized tables

Estas son las diferencias entre las tablas basadas en disco y optimizadas para memoria cuando el uso de un MARS habilitado conexión:The following are the differences between disk-based and memory-optimized tables when using a MARS enabled connection:

  • Dos instrucciones pueden modificar los datos en el mismo objeto de destino, pero si intentan modificar el mismo registro un conflicto de escritura contra escritura hará que la operación de nuevo un error.Two statements can modify data in the same target object but if they both attempt to modify the same record a write-write conflict will cause the new operation to fail. Sin embargo, si ambas operaciones modifican distintos registros, las operaciones se realizará correctamente.However, if both operations modify different records, the operations will succeed.

  • Cada instrucción se ejecuta con aislamiento de instantánea para que nuevas operaciones no pueden ver los cambios realizados por las instrucciones existentes.Each statement runs under SNAPSHOT isolation so new operations cannot see changes made by the existing statements. Incluso si se ejecutan las instrucciones simultáneas en la misma transacción el motor SQL crea transacciones de lote para cada instrucción que están aisladas entre sí.Even if the concurrent statements are executed under the same transaction the SQL engine creates batch-scoped transactions for each statement that are isolated from each other. Sin embargo, las transacciones de lote todavía se enlazan juntos para la reversión de una transacción de lote afecta a otros registros en el mismo lote.However, batch-scoped transactions are still bound together so rollback of one batch-scoped transaction affects other ones in the same batch.

  • No se permiten operaciones de DDL en las transacciones de usuario inmediatamente generará un error.DDL operations are not allowed in user transactions so they will immediately fail.

MARS y procedimientos almacenados compilados de forma nativaMARS and natively compiled stored procedures

Procedimientos almacenados compilados de forma nativa se pueden ejecutar en las conexiones de MARS habilitado y pueden ceda la ejecución a otra instrucción solo cuando se encuentra un punto de rendimiento.Natively compiled stored procedures can run in MARS enabled connections and can yield execution to another statement only when a yield point is encountered. Un punto de rendimiento requiere una instrucción SELECT, que es la única instrucción en un procedimiento almacenado compilado de forma nativa que puede ofrecer la ejecución a otra instrucción.A yield point requires a SELECT statement, which is the only statement within a natively compiled stored procedure that can yield execution to another statement. Si una instrucción SELECT no está presente en el procedimiento no dará como resultado, se ejecutará hasta su finalización antes de comenzar otras instrucciones.If a SELECT statement is not present in the procedure it will not yield, it will run to completion before other statements begin.

Transacciones de MARS y OLTP en memoriaMARS and In-memory OLTP transactions

Los cambios realizados por instrucciones y bloques atomic que se intercalan están aislados entre sí.Changes made by statements and atomic blocks that are interleaved are isolated from each other. Por ejemplo, si una instrucción o bloque atomic realiza algunos cambios y, a continuación, proporciona una ejecución a otra instrucción, la nueva instrucción no verán los cambios realizados por la primera instrucción.For example, if one statement or atomic block makes some changes, and then yields execution to another statement, the new statement will not see changes made by the first statement. Además, cuando la primera instrucción reanuda la ejecución, no verán los cambios realizados por cualquier otra instrucción.In addition, when first statement resumes execution, it will not see any changes made by any other statements. Las instrucciones solo verá los cambios que se finaliza y confirma antes de que se inicia la instrucción.Statements will only see changes that are finished and committed before the statement starts.

Se puede iniciar una nueva transacción de usuario dentro de la transacción de usuario actual mediante la instrucción BEGIN TRANSACTION: Esto se admite solo en modo de interoperabilidad, por lo que solo se puede llamar a BEGIN TRANSACTION de una instrucción de Transact-SQL y no desde dentro de compilado de forma nativa almacenan procedimiento. Puede crear una operación de guardar punto en una transacción utilizando SAVE TRANSACTION o una llamada de API a la transacción. Save(save_point_name) para revertir al punto de retorno.A new user transaction can be started within the current user transaction using the BEGIN TRANSACTION statement - this is supported only in interop mode so the BEGIN TRANSACTION can only be called from a T-SQL statement, and not from within a natively compiled stored procedure.You can create a save point in a transaction using SAVE TRANSACTION or an API call to transaction.Save(save_point_name) to rollback to the savepoint. Esta característica también se habilita solo desde las instrucciones de T-SQL y no desde dentro de forma nativa procedimientos almacenados compilados.This feature is also enabled only from T-SQL statements, and not from within natively compiled stored procedures.

MARS y los índices de almacén de columnasMARS and columnstore indexes

SQL Server (a partir de 2016) es compatible con MARS con índices de almacén de columnas.SQL Server (starting with 2016) supports MARS with columnstore indexes. SQL Server 2014 usa MARS para las conexiones de solo lectura a las tablas con un índice de almacén de columnas.SQL Server 2014 uses MARS for read-only connections to tables with a columnstore index. Pero SQL Server 2014 no es compatible con MARS para operaciones simultáneas de lenguaje de manipulación de datos (DML) en una tabla con un índice de almacén de columnas.However, SQL Server 2014 does not support MARS for concurrent data manipulation language (DML) operations on a table with a columnstore index. Cuando ocurre esto, SQL Server termina las conexiones y anula las transacciones.When this occurs, SQL Server will terminate the connections and abort the transactions. SQL Server 2012 tiene índices de almacén de columnas de sólo lectura y MARS no se aplica a ellos.SQL Server 2012 has read-only columnstore indexes and MARS does not apply to them.

Proveedor OLE DB de SQL Server Native ClientSQL Server Native Client OLE DB Provider

El SQL ServerSQL Server proveedor OLE DB de Native Client admite MARS mediante la adición de la propiedad de inicialización de SSPROP_INIT_MARSCONNECTION data source, que se implementa en el conjunto de propiedades DBPROPSET_SQLSERVERDBINIT.The SQL ServerSQL Server Native Client OLE DB provider supports MARS through the addition of the SSPROP_INIT_MARSCONNECTION data source initialization property, which is implemented in the DBPROPSET_SQLSERVERDBINIT property set. Además, se ha agregado una nueva palabra clave de cadena de conexión, MarsConn.In addition, a new connection string keyword, MarsConn, as been added. Acepta true o false valores; false es el valor predeterminado.It accepts true or false values; false is the default.

El valor predeterminado de la propiedad de origen de datos DBPROP_MULTIPLECONNECTIONS es VARIANT_TRUE.The data source property DBPROP_MULTIPLECONNECTIONS defaults to VARIANT_TRUE. Esto significa que el proveedor generará varias conexiones para admitir varios comandos y objetos de conjunto de filas simultáneos.This means the provider will spawn multiple connections in order to support multiple concurrent command and rowset objects. Cuando MARS está habilitado, SQL ServerSQL Server Native Client puede admitir varios objetos de comando y conjunto de filas en una sola conexión, por lo que MULTIPLE_CONNECTIONS se establece de forma predeterminada en VARIANT_FALSE.When MARS is enabled, SQL ServerSQL Server Native Client can support multiple command and rowset objects on a single connection, so MULTIPLE_CONNECTIONS is set to VARIANT_FALSE by default.

Para obtener más información acerca de las mejoras realizadas en el conjunto de propiedades DBPROPSET_SQLSERVERDBINIT, vea propiedades de inicialización y autorización.For more information about enhancements made to the DBPROPSET_SQLSERVERDBINIT property set, see Initialization and Authorization Properties.

Ejemplo del proveedor OLE DB de SQL Server Native ClientSQL Server Native Client OLE DB Provider Example

En este ejemplo, se crea un objeto de origen de datos mediante el SQL ServerSQL Server proveedor OLE DB nativo y MARS está habilitado el uso de propiedades DBPROPSET_SQLSERVERDBINIT antes de crea el objeto de sesión.In this example, a data source object is created using the SQL ServerSQL Server Native OLE DB provider, and MARS is enabled using the DBPROPSET_SQLSERVERDBINIT property set before the session object is created.

#include <sqlncli.h>  
  
IDBInitialize *pIDBInitialize = NULL;  
IDBCreateSession *pIDBCreateSession = NULL;  
IDBProperties *pIDBProperties = NULL;  
  
// Create the data source object.  
hr = CoCreateInstance(CLSID_SQLNCLI10, NULL,  
   CLSCTX_INPROC_SERVER,  
   IID_IDBInitialize,   
    (void**)&pIDBInitialize);  
  
hr = pIDBInitialize->QueryInterface(IID_IDBProperties, (void**)&pIDBProperties);  
  
// Set the MARS property.  
DBPROP rgPropMARS;  
  
// The following is necessary since MARS is off by default.  
rgPropMARS.dwPropertyID = SSPROP_INIT_MARSCONNECTION;  
rgPropMARS.dwOptions = DBPROPOPTIONS_REQUIRED;  
rgPropMARS.dwStatus = DBPROPSTATUS_OK;  
rgPropMARS.colid = DB_NULLID;  
V_VT(&(rgPropMARS.vValue)) = VT_BOOL;  
V_BOOL(&(rgPropMARS.vValue)) = VARIANT_TRUE;  
  
// Create the structure containing the properties.  
DBPROPSET PropSet;  
PropSet.rgProperties = &rgPropMARS;  
PropSet.cProperties = 1;  
PropSet.guidPropertySet = DBPROPSET_SQLSERVERDBINIT;  
  
// Get an IDBProperties pointer and set the initialization properties.  
pIDBProperties->SetProperties(1, &PropSet);  
pIDBProperties->Release();  
  
// Initialize the data source object.  
hr = pIDBInitialize->Initialize();  
  
//Create a session object from a data source object.  
IOpenRowset * pIOpenRowset = NULL;  
hr = IDBInitialize->QueryInterface(IID_IDBCreateSession, (void**)&pIDBCreateSession));  
hr = pIDBCreateSession->CreateSession(  
   NULL,             // pUnkOuter  
   IID_IOpenRowset,  // riid  
  &pIOpenRowset ));  // ppSession  
  
// Create a rowset with a firehose mode cursor.  
IRowset *pIRowset = NULL;  
DBPROP rgRowsetProperties[2];  
  
// To get a firehose mode cursor request a   
// forward only read only rowset.  
rgRowsetProperties[0].dwPropertyID = DBPROP_IRowsetLocate;  
rgRowsetProperties[0].dwOptions = DBPROPOPTIONS_REQUIRED;  
rgRowsetProperties[0].dwStatus = DBPROPSTATUS_OK;  
rgRowsetProperties[0].colid = DB_NULLID;  
VariantInit(&(rgRowsetProperties[0].vValue));  
rgRowsetProperties[0].vValue.vt = VARIANT_BOOL;  
rgRowsetProperties[0].vValue.boolVal = VARIANT_FALSE;  
  
rgRowsetProperties[1].dwPropertyID = DBPROP_IRowsetChange;  
rgRowsetProperties[1].dwOptions = DBPROPOPTIONS_REQUIRED;  
rgRowsetProperties[1].dwStatus = DBPROPSTATUS_OK;  
rgRowsetProperties[1].colid = DB_NULLID;  
VariantInit(&(rgRowsetProperties[1].vValue));  
rgRowsetProperties[1].vValue.vt = VARIANT_BOOL;  
rgRowsetProperties[1].vValue.boolVal = VARIANT_FALSE;  
  
DBPROPSET rgRowsetPropSet[1];  
rgRowsetPropSet[0].rgProperties = rgRowsetProperties  
rgRowsetPropSet[0].cProperties = 2  
rgRowsetPropSet[0].guidPropertySet = DBPROPSET_ROWSET;  
  
hr = pIOpenRowset->OpenRowset (NULL,  
   &TableID,  
   NULL,  
   IID_IRowset,  
   1,  
   rgRowsetPropSet  
   (IUnknown**)&pIRowset);  

Controlador ODBC de SQL Server Native ClientSQL Server Native Client ODBC Driver

El SQL ServerSQL Server controlador ODBC de Native Client admite MARS mediante adiciones a la SQLSetConnectAttr y SQLGetConnectAttr funciones.The SQL ServerSQL Server Native Client ODBC driver supports MARS through additions to the SQLSetConnectAttr and SQLGetConnectAttr functions. SQL_COPT_SS_MARS_ENABLED se ha agregado para aceptar SQL_MARS_ENABLED_YES o SQL_MARS_ENABLED_NO, siendo SQL_MARS_ENABLED_NO el valor predeterminado.SQL_COPT_SS_MARS_ENABLED has been added to accept either SQL_MARS_ENABLED_YES or SQL_MARS_ENABLED_NO, with SQL_MARS_ENABLED_NO being the default. Además, una nueva cadena de conexión de palabra clave, Mars_Connection, tal y como se ha agregado.In addition, a new connection string keyword, Mars_Connection, as been added. Acepta valores "yes" o "no"; "no" es el valor predeterminado.It accepts "yes" or "no" values; "no" is the default.

Ejemplo del controlador ODBC de SQL Server Native ClientSQL Server Native Client ODBC Driver Example

En este ejemplo, el SQLSetConnectAttr función se utiliza para habilitar MARS antes de llamar a la SQLDriverConnect función para conectarse a la base de datos.In this example, the SQLSetConnectAttr function is used to enable MARS before calling the SQLDriverConnect function to connect the database. Una vez realizada la conexión, dos SQLExecDirect se llama a funciones para crear dos conjuntos de resultados independientes en la misma conexión.Once the connection is made, two SQLExecDirect functions are called to create two separate result sets on the same connection.

#include <sqlncli.h>  
  
SQLSetConnectAttr(hdbc, SQL_COPT_SS_MARS_ENABLED, SQL_MARS_ENABLED_YES, SQL_IS_UINTEGER);  
SQLDriverConnect(hdbc, hwnd,   
   "DRIVER=SQL Server Native Client 10.0;  
   SERVER=(local);trusted_connection=yes;", SQL_NTS, szOutConn,   
   MAX_CONN_OUT, &cbOutConn, SQL_DRIVER_COMPLETE);  
  
SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt1);  
SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt2);  
  
// The 2nd execute would have failed with connection busy error if  
// MARS were not enabled.  
SQLExecDirect(hstmt1, L"SELECT * FROM Authors", SQL_NTS);  
SQLExecDirect(hstmt2, L"SELECT * FROM Titles", SQL_NTS);  
  
// Result set processing can interleave.  
SQLFetch(hstmt1);  
SQLFetch(hstmt2);  

Vea tambiénSee Also

Características de SQL Server Native Client SQL Server Native Client Features
Usar conjuntos de resultados predeterminados de SQL ServerUsing SQL Server Default Result Sets