Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
O SQL Server 2005 introduziu suporte para vários MARS (conjuntos de resultados ativos) em aplicativos que acessam o Mecanismo de Banco de Dados. Em versões anteriores do SQL Server, os aplicativos de banco de dados não podiam manter várias instruções ativas em uma conexão. Ao usar conjuntos de resultados padrão do SQL Server, o aplicativo teve que processar ou cancelar todos os conjuntos de resultados de um lote antes de poder executar qualquer outro lote nessa conexão. O SQL Server 2005 introduziu um novo atributo de conexão que permite que os aplicativos tenham mais de uma solicitação pendente por conexão e, em particular, tenham mais de um conjunto de resultados padrão ativo por conexão.
O MARS simplifica o design do aplicativo com os seguintes novos recursos:
Os aplicativos podem ter vários conjuntos de resultados padrão abertos e podem intercalar a leitura deles.
Os aplicativos podem executar outras instruções (por exemplo, INSERT, UPDATE, DELETE e chamadas de procedimento armazenado) enquanto os conjuntos de resultados padrão estão abertos.
Os aplicativos que usam o MARS acharão as seguintes diretrizes benéficas:
Os conjuntos de resultados padrão devem ser usados para conjuntos de resultados curtos ou de curta duração gerados por instruções SQL simples (SELECT, DML com OUTPUT, RECEIVE, READ TEXT e assim por diante).
Os cursores de servidor devem ser usados para conjuntos de resultados maiores ou mais longos gerados por instruções SQL simples.
Sempre leia até o final dos resultados para solicitações processuais, independentemente de retornarem resultados ou não, e para lotes que retornam vários resultados.
Sempre que possível, use chamadas de API para alterar as propriedades de conexão e gerenciar transações em preferência para Transact-SQL instruções.
No MARS, a representação no escopo da sessão é proibida enquanto lotes simultâneos estão em execução.
Observação
Por padrão, a funcionalidade MARS não está habilitada. Para usar o MARS ao se conectar ao SQL Server com o SQL Server Native Client, você deve habilitá-lo especificamente dentro de uma cadeia de conexão. Para obter mais informações, consulte o provedor OLE DB do SQL Server Native Client e as seções de driver ODBC do SQL Server Native Client, mais adiante neste tópico.
O SQL Server Native Client não limita o número de instruções ativas em uma conexão.
Aplicativos típicos que não precisam ter mais do que um único lote multiestado ou um procedimento armazenado em execução ao mesmo tempo se beneficiarão do MARS sem precisar entender como o MARS é implementado. No entanto, aplicativos com requisitos mais complexos precisam levar em conta isso.
O MARS permite a execução intercalada de várias solicitações em uma única conexão. Ou seja, permite que um lote seja executado e, dentro de sua execução, ele permite que outras solicitações sejam executadas. Observe, no entanto, que MARS é definido em termos de intercalação, não em termos de execução paralela.
A infraestrutura mars permite que vários lotes sejam executados de forma intercalada, embora a execução só possa ser alternada em pontos bem definidos. Além disso, a maioria das instruções deve ser executada atomicamente em um lote. Instruções que retornam linhas para o cliente, que às vezes são conhecidas como pontos de rendimento, têm permissão para intercalar a execução antes da conclusão enquanto as linhas estão sendo enviadas ao cliente, por exemplo:
SELECIONAR
BUSCAR
RECEBER
Quaisquer outras instruções executadas como parte de um procedimento armazenado ou lote devem ser executadas até a conclusão antes que a execução possa ser alternada para outras solicitações MARS.
A maneira exata em que a execução entre lotes é influenciada por vários fatores e é difícil prever a sequência exata na qual os comandos de vários lotes que contêm pontos de rendimento serão executados. Tenha cuidado para evitar efeitos colaterais indesejados devido à execução intercalada desses lotes complexos.
Evite problemas usando chamadas de API em vez de instruções Transact-SQL para gerenciar o estado da conexão (SET, USE) e transações (BEGIN TRAN, COMMIT, ROLLBACK) não incluindo essas instruções em lotes de várias instruções que também contêm pontos de rendimento e serializando a execução desses lotes consumindo ou cancelando todos os resultados.
Observação
Um procedimento armazenado ou em lote que inicia uma transação manual ou implícita quando o MARS está habilitado deve concluir a transação antes que o lote seja encerrado. Caso contrário, o SQL Server reverterá todas as alterações feitas pela transação quando o lote for concluído. Essa transação é gerenciada pelo SQL Server como uma transação com escopo em lote. Esse é um novo tipo de transação introduzido no SQL Server 2005 para permitir que os procedimentos armazenados bem comportados existentes sejam usados quando o MARS estiver habilitado. Para obter mais informações sobre transações com escopo em lote, consulte Instruções de Transação (Transact-SQL).
Para obter um exemplo de como usar o MARS do ADO, consulte Como usar o ADO com o SQL Server Native Client.
Provedor OLE DB do SQL Server Native Client
O provedor OLE DB do SQL Server Native Client dá suporte ao MARS por meio da adição da propriedade de inicialização da fonte de dados SSPROP_INIT_MARSCONNECTION, que é implementada no conjunto de propriedades DBPROPSET_SQLSERVERDBINIT. Além disso, uma nova palavra-chave de cadeia de conexão, MarsConnconforme foi adicionado. Ele aceita true ou false valores; false é o padrão.
A propriedade da fonte de dados DBPROP_MULTIPLECONNECTIONS padrão para VARIANT_TRUE. Isso significa que o provedor gerará várias conexões para dar suporte a vários objetos de comando e conjunto de linhas simultâneos. Quando o MARS está habilitado, o SQL Server Native Client pode dar suporte a vários objetos de comando e conjunto de linhas em uma única conexão, portanto, MULTIPLE_CONNECTIONS é definido como VARIANT_FALSE por padrão.
Para obter mais informações sobre aprimoramentos feitos no conjunto de propriedades DBPROPSET_SQLSERVERDBINIT, consulte Propriedades de Inicialização e Autorização.
Exemplo do provedor OLE DB de cliente nativo do SQL Server
Neste exemplo, um objeto de fonte de dados é criado usando o provedor OLE DB nativo do SQL Server e o MARS é habilitado usando a propriedade DBPROPSET_SQLSERVERDBINIT definida antes da criação do objeto de sessão.
#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);
Driver ODBC do SQL Server Native Client
O driver ODBC do SQL Server Native Client dá suporte a MARS por meio de adições às funções SQLSetConnectAttr e SQLGetConnectAttr . SQL_COPT_SS_MARS_ENABLED foi adicionado para aceitar SQL_MARS_ENABLED_YES ou SQL_MARS_ENABLED_NO, sendo SQL_MARS_ENABLED_NO o padrão. Além disso, uma nova palavra-chave de cadeia de conexão, Mars_Connectionconforme foi adicionado. Ele aceita valores "sim" ou "não"; "não" é o padrão.
Exemplo de driver ODBC de cliente nativo do SQL Server
Neste exemplo, a função SQLSetConnectAttr é usada para habilitar o MARS antes de chamar a função SQLDriverConnect para conectar o banco de dados. Depois que a conexão é feita, duas funções SQLExecDirect são chamadas para criar dois conjuntos de resultados separados na mesma conexão.
#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);
Consulte Também
Recursos do SQL Server Native Client
Usando conjuntos de resultados padrão do SQL Server