Uma preocupação comum sobre o uso do modo de execução assíncrona é a suposição de que não é possível começar a executar uma instância de
SQLStatement
se outra instância de SQLStatement está em execução na mesma conexão de banco de dados. Na verdade, essa suposição não está correta. Durante a execução de uma ocorrência de SQLStatement, não é possível alterar a propriedade
text
da instrução. Contudo, se você usar uma ocorrência de SQLStatement à parte para cada instrução SQL que deseja executar, poderá chamar o método
execute()
de um SQLStatement enquanto outra ocorrência de SQLStatement ainda estiver sendo executada, sem causar erro.
Internamente, quando você executa operações de banco de dados utilizando o modo de execução assíncrona, cada conexão de banco de dados (cada instância de
SQLConnection
) tem sua própria fila ou lista de operações que está instruída a executar. O tempo de execução realiza cada operação em sequência, na ordem em que são adicionadas à fila. Quando você cria uma ocorrência de SQLStatement e chama o método
execute()
relacionado, a operação de execução dessa instrução é adicionada à fila da conexão. Se nenhuma operação estiver sendo executada nessa ocorrência de SQLConnection, a instrução começará a ser executada em segundo plano. Suponha que, dentro do mesmo bloco de código, você crie outra ocorrência de SQLStatement e também chame o método
execute()
daquele método. A operação que executa essa segunda instrução é adicionada à fila depois da primeira instrução. Assim que é concluída a execução da primeira instrução, o tempo de execução passa para a próxima operação da fila. O processamento das operações subsequentes na fila acontece em segundo plano, mesmo quando o evento
result
da primeira operação está sendo despachado no código do aplicativo principal. O código abaixo demonstra esta técnica:
// Using asynchronous execution mode
var stmt1:SQLStatement = new SQLStatement();
stmt1.sqlConnection = conn;
// ... Set statement text and parameters, and register event listeners ...
stmt1.execute();
// At this point stmt1's execute() operation is added to conn's execution queue.
var stmt2:SQLStatement = new SQLStatement();
stmt2.sqlConnection = conn;
// ... Set statement text and parameters, and register event listeners ...
stmt2.execute();
// At this point stmt2's execute() operation is added to conn's execution queue.
// When stmt1 finishes executing, stmt2 will immediately begin executing
// in the background.
Ocorre um importante efeito colateral pelo fato de o banco de dados executar as próximas instruções em fila de maneira automática. Se uma instrução depende do resultado de outra operação, não é possível adicioná-la à fila (em outras palavras, você não pode chamar o método
execute()
relacionado) até a primeira operação ser concluída. Isso acontece porque, depois que você chamou o método
execute()
da segunda instrução, não é possível alterar as propriedades
text
ou
parameters
dela. Nesse caso, você deve aguardar o evento indicando que a primeira operação foi concluída antes de iniciar a próxima operação. Por exemplo, se você quiser executar uma instrução no contexto de uma transação, a execução da instrução dependerá da operação de abrir a transação. Após chamar o método
SQLConnection.begin()
para abrir a transação, você terá de aguardar que a ocorrência de SQLConnection despache seu evento
begin
. Só então você poderá chamar o método
execute()
da ocorrência de SQLStatement. Neste exemplo, o modo mais simples de organizar o aplicativo para assegurar que as operações sejam executadas corretamente é criar um método que seja registrado como ouvinte do evento
begin
. O código para chamar o método
SQLStatement.execute()
é colocado dentro do método desse ouvinte.
