Compartilhar via

Executar uma instrução

Há quatro maneiras de executar uma instrução, dependendo de quando elas são compiladas (preparadas) pelo mecanismo de banco de dados e quem as define:

  • Execução direta O aplicativo define a instrução SQL. Ele é preparado e executado em tempo de execução em uma única etapa.

  • Execução preparada O aplicativo define a instrução SQL. Ele é preparado e executado durante a execução em etapas separadas. A instrução pode ser preparada uma vez e executada várias vezes.

  • Procedimentos O aplicativo pode definir e compilar uma ou mais instruções SQL no momento do desenvolvimento e armazenar essas instruções na fonte de dados como um procedimento. O procedimento é executado uma ou mais vezes em tempo de execução. O aplicativo pode enumerar procedimentos armazenados disponíveis usando funções de catálogo.

  • Funções de catálogo O gravador de driver cria uma função que retorna um conjunto de resultados predefinido. Normalmente, essa função envia uma instrução SQL predefinida ou chama um procedimento criado para essa finalidade. A função é executada uma ou mais vezes em tempo de execução.

Uma instrução específica (conforme identificado por seu identificador de instrução) pode ser executada várias vezes. A instrução pode ser executada com uma variedade de instruções SQL diferentes ou pode ser executada repetidamente com a mesma instrução SQL. Por exemplo, o código a seguir usa o mesmo identificador de instrução (hstmt1) para recuperar e exibir as tabelas no banco de dados Sales. Em seguida, reutiliza esse identificador para recuperar as colunas em uma tabela selecionada pelo usuário.

SQLHSTMT    hstmt1;  
SQLCHAR *   Table;  
  
// Create a result set of all tables in the Sales database.  
SQLTables(hstmt1, "Sales", SQL_NTS, "sysadmin", SQL_NTS, NULL, 0, NULL, 0);  
  
// Fetch and display the table names; then close the cursor.  
// Code not shown.  
  
// Have the user select a particular table.  
SelectTable(Table);  
  
// Reuse hstmt1 to create a result set of all columns in Table.  
SQLColumns(hstmt1, "Sales", SQL_NTS, "sysadmin", SQL_NTS, Table, SQL_NTS, NULL, 0);  
  
// Fetch and display the column names in Table; then close the cursor.  
// Code not shown.

E o código a seguir mostra como um único identificador é usado para executar repetidamente a mesma instrução para excluir linhas de uma tabela.

SQLHSTMT      hstmt1;  
SQLUINTEGER   OrderID;  
SQLINTEGER    OrderIDInd = 0;  
  
// Prepare a statement to delete orders from the Orders table.  
SQLPrepare(hstmt1, "DELETE FROM Orders WHERE OrderID = ?", SQL_NTS);  
  
// Bind OrderID to the parameter for the OrderID column.  
SQLBindParameter(hstmt1, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0,  
                  &OrderID, 0, &OrderIDInd);  
  
// Repeatedly execute hstmt1 with different values of OrderID.  
while ((OrderID = GetOrderID()) != 0) {  
   SQLExecute(hstmt1);  
}

Para muitos drivers, alocar instruções é uma tarefa cara; portanto, reutilizar a mesma instrução dessa maneira geralmente é mais eficiente do que liberar as instruções existentes e alocar novas. Os aplicativos que criam conjuntos de resultados em uma instrução devem ter cuidado para fechar o cursor sobre o conjunto de resultados antes de reexecutar a instrução; para obter mais informações, consulte Fechando o cursor.

A reutilização de instruções também força o aplicativo a evitar uma limitação em alguns drivers quanto ao número de instruções que podem ficar ativas ao mesmo tempo. A definição exata de "ativo" é específica do driver, mas geralmente se refere a qualquer instrução que tenha sido preparada ou executada e ainda tenha resultados disponíveis. Por exemplo, depois que uma instrução INSERT é preparada, ela geralmente é considerada ativa; depois que uma instrução SELECT tiver sido executada e o cursor ainda estiver aberto, ele geralmente será considerado ativo; depois que uma instrução CREATE TABLE tiver sido executada, ela geralmente não será considerada ativa.

Um aplicativo determina quantas instruções podem estar ativas em uma única conexão ao mesmo tempo chamando SQLGetInfo com a opção SQL_MAX_CONCURRENT_ACTIVITIES. Um aplicativo pode usar instruções mais ativas do que esse limite abrindo várias conexões com a fonte de dados; porque as conexões podem ser caras, no entanto, o efeito sobre o desempenho deve ser considerado.

Os aplicativos podem limitar o tempo alocado para uma instrução a ser executada com o atributo de instrução SQL_ATTR_QUERY_TIMEOUT. Se o período de tempo limite expirar antes que a fonte de dados retorne o conjunto de resultados, a função que executa a instrução SQL retornará SQLSTATE HYT00 (o tempo limite expirou). Por padrão, não há tempo limite.

Esta seção contém os seguintes tópicos.

  • Last updated on