SQLConnection  - AS3

Indica se a compactação automática foi ativada quando o banco de dados atual foi originalmente criado (o valor que foi especificado para o parâmetro autoCompact na chamada open() ou openAsync() que criou o banco de dados). Se essa propriedade for true, o espaço não utilizado será removido automaticamente do arquivo do banco de dados após cada operação de gravação, mantendo o arquivo do banco de dados menor. Se a propriedade for false, o espaço previamente ocupado pelos dados removidos será deixado no arquivo do banco de dados e reutilizado quando necessário. Mesmo quando autoCompactfor false, é possível forçar o banco de dados a recuperar o espaço não utilizado chamando o método compact().

Se a propriedade connected for false, essa propriedade será definida como false.

Elementos da API relacionados

Fornece acesso ao tamanho do cache dessa conexão, o qual representa o número máximo de páginas do disco do banco de dados que serão mantidas na memória por vez. Cada página usa cerca de 1,5 KB de memória (dependendo do valor especificado para o parâmetro pageSize da chamada do método open() ou openAsync() que criou o banco de dados). O tamanho do cache padrão é 2.000. Se um aplicativo estiver executando as operações UPDATE ou DELETE que alteram muitas linhas de um banco de dados, aumentar o tamanho do cache poderá melhorar a velocidade ao custo de um maior consumo de memória.

Elementos da API relacionados

Indica como os nomes de colunas são reportados no resultado de uma instrução SELECT.

As constantes definidas na classe SQLColumnNameStyle representam os valores possíveis para essa propriedade:

• SQLColumnNameStyle.LONG indica se o nomes de colunas são retornados no formato [table-name]_[column-name].
• SQLColumnNameStyle.SHORT especifica se os nomes das colunas recebem o formato [column-name]. Se existir várias colunas com o mesmo nome, somente uma propriedade com esse nome é adicionada ao objeto de resultado.
• SQLColumnNameStyle.DEFAULT é valor padrão. Quando esse valor é usado, os nomes de coluna resultantes são formatados de acordo com o número de tabelas na instrução SELECT que tenham nomes de colunas similares. Se a instrução SELECT incluir só uma tabela, o formato de nome curto [column-name] será usado e, se a instrução SELECT incluir várias tabelas reunidas, sempre que houver uma colisão de nomeação pelo fato de dois nomes de colunas serem idênticos, o formato de nome longo [table-name]_[column-name] será usado para as colunas com nomes idênticos.

Elementos da API relacionados

Indica se a ocorrência SQLConnection tem uma conexão aberta com um arquivo do banco de dados.

Elementos da API relacionados

Indica se essa conexão está envolvida em uma transação no momento.

Elementos da API relacionados

Indica se a classe SQLConnection tem suporte na plataforma atual ou não.

O identificador da última linha gerada criado por uma instrução SQL INSERT. Um identificador de linha é usado para identificar exclusivamente uma linha em uma tabela no banco de dados. Geralmente, o valor é gerado pelo banco de dados.

O valor será zero se nenhum banco de dados estiver conectado ou se nenhuma instrução INSERT tiver sido executada.

O identificador de linha para uma única execução de instrução SQL INSERT pode ser obtido pela propriedade lastInsertRowID do objeto SQLResult retornado pelo método getResult() do objeto SQLStatement (quando chamado depois de a SQLStatement enviar o evento result).

Para mais informações sobre chaves primárias e identificadores de linha gerados, consulte as seções "CREATE TABLE" e "Expressões" no apêndice "Suporte SQL em bancos de dados locais."

Elementos da API relacionados

Indica o tamanho da página do banco de dados (em bytes) que foi especificado quando o banco de dados foi originalmente criado (o valor que foi especificado para o parâmetro pageSize na chamada open() ou openAsync() que criou o banco de dados).

Se a propriedade connected for false, o valor dessa propriedade será 0.

O tamanho da página para um banco de dados pode ser alterado (usando os métodos open() ou openAsync()) até que a primeira tabela seja criada no banco de dados.

Elementos da API relacionados

Contém o número total de alterações de dados que foram feitas desde que foi aberta a conexão com o banco de dados. Além de rastrear as alterações feitas pelas instruções INSERT, DELETE e UPDATE, esse valor inclui as alterações provocadas por disparadores.

Quando a conexão do banco de dados é fechada, o valor é redefinido como 0. Quando a ocorrência SQLConnection não está conectada a um arquivo de banco de dados, o valor é 0.

Elementos da API relacionados

Cria uma ocorrência SQLConnection.

Registra um objeto de ouvinte de evento em um objeto EventDispatcher, de forma que o ouvinte receba a notificação de um evento. Você pode registrar ouvintes de eventos em todos os nós da lista de exibição de um tipo específico de evento, fase e prioridade.

Depois de registrar um ouvinte de evento com êxito, não será possível alterar a respectiva prioridade por meio de chamadas adicionais para o addEventListener(). Para alterar a prioridade de um ouvinte, chame primeiramente o removeListener(). Em seguida, você poderá registrar o ouvinte novamente com o novo nível de prioridade.

Tenha em mente que, após o ouvinte ser registrado, chamadas subsequentes para o addEventListener() com um valor type ou useCapture diferente resultarão na criação de um registro de ouvinte separado. Por exemplo, se você primeiro registrar um ouvinte com o useCapture definido como true, ele escutará apenas durante a fase de captura. Se você chamar o addEventListener() novamente, usando o mesmo objeto de ouvinte, mas com o useCapture definido como false, você terá dois ouvintes distintos: um que escuta durante a fase de captura e outro que escuta durante as fases de destino e de bubbling.

Você não pode registrar um ouvinte de evento apenas para a fase de destino ou a fase de bubbling. Essas fases são emparelhadas durante o registro porque o bubbling se aplica apenas aos ancestral do nó-alvo.

Se você não precisar mais de um ouvinte de evento, remova-o, chamando o removeEventListener(); do contrário, poderão ocorrer problemas de memória. Os ouvintes de evento não são retirados automaticamente da memória porque o coletor de lixo não remove o ouvinte enquanto o objeto de despacho existe (a menos que o parâmetro useWeakReference seja definido para true).

Copiar uma ocorrência do EventDispatcher não copia os ouvintes de eventos a ele anexados. (Se o seu recém-criado nó precisar de um ouvinte de evento, anexe o ouvinte após criar o nó). Entretanto, se você mover uma ocorrência do EventDispatcher, os ouvintes de evento anexados se movimentarão com ele.

Se o ouvinte de evento estiver sendo registrado em um nó enquanto um evento estiver sendo processado nesse nó, o ouvinte de evento não será disparado durante a fase atual, mas poderá ser disparado durante uma fase posterior no fluxo de eventos, como a fase de bubbling.

Se um ouvinte de evento for removido de um nó enquanto um evento estiver sendo processado no nó, ele ainda será disparado pelas ações atuais. Depois de removido, o ouvinte de evento nunca mais é chamado novamente (a menos que registrado mais uma vez para processamento futuro).

Parâmetros

function(evt:Event):void

Reúne estatísticas sobre os índices de banco de dados e as armazena no banco de dados. Essas estatísticas podem, então, ser usadas pelo otimizador de consultas (a parcela do mecanismo do banco de dados que determina o modo mais eficiente de executar cada instrução). As estatísticas ajudam o otimizador de consultas a fazer escolhas melhores sobre que índice ou índices usar ao executar uma determinada consulta.

Se um banco de dados tiver índices definidos, mas o método analyze() não tiver sido chamado, ainda assim o tempo de execução usará esses índices para executar instruções. No entanto, sem as informações estatísticas adicionais geradas pelo método analyze(), o tempo de execução poderá não escolher o índice mais eficaz para uma determinada consulta.

Quando os dados de uma tabela são alterados (como resultado das instruções INSERT, UPDATE ou DELETE), os índices associados a essa tabela também mudam. As informações estatísticas geradas pelo analyze() não são automaticamente atualizadas. Consequentemente, após um grande número de alterações de dados, chamar o método analyze() novamente pode ser vantajoso. Entretanto, o benefício obtido ao chamar analyze() novamente depende de vários fatores, incluindo o número de índices definidos em uma tabela, a relação entre o número de linhas alteradas e o número total de linhas na tabela, o grau de variação existente nos dados indexados da tabela e o quanto os dados alterados são diferentes dos dados anteriores à alteração.

O parâmetro resourceName indica se a operação deve ser executada nos índices de todos os bancos de dados anexados, em um banco de dados específico ou em uma tabela específica.

Toda vez que esse método é chamado, quaisquer dados estatísticos previamente criados são expurgados e recriados para o banco de dados ou a tabela especificados no parâmetro resourceName (ou todas as tabelas em todos os bancos de dados conectados se resourceName for null). Esse método pode ser chamado a qualquer momento em que uma conexão com um banco de dados estiver aberta. A operação analyze() e seus dados estatísticos não são incluídos em uma transação; no entanto, é melhor não chamar analyze() quando o banco de dados tiver uma transação concorrente (a propriedade inTransaction for verdadeira). Isso porque quaisquer alterações nos dados, esquemas de tabelas ou índices que foram executadas na transação mas que ainda não foram confirmadas não são levadas em consideração pela chamada analyze(), e os dados analyze() estarão desatualizados assim que a transação estiver confirmada.

Para remover os dados estatísticos criados com o método analyze(), use o método deanalyze().

Parâmetros

Elementos da API relacionados

Adiciona outro banco de dados à ocorrência SQLConnection, dando ao novo banco de dados o nome especificado. Anexar um banco de dados permite que o banco de dados seja usado em instruções SQL executadas contra essa ocorrência SQLConnection.

Se um banco de dados já está anexado usando o nome especificado, chamar attach() resultará em um evento error. No entanto, o mesmo banco de dados pode ser anexado várias vezes usando nomes exclusivos. Só dez bancos de dados podem ser anexados a uma única ocorrência SQLConnection.

Qualquer instrução SQL pode ser executada em um banco de dados conectado usando attach() que pode ser executado no banco de dados principal (o banco de dados conectado usando open() ou openAsync()). Uma instrução SQL pode acessar tabelas em qualquer um dos bancos de dados anexados à ocorrência SQLConnection associada da instrução, incluindo o acesso a tabelas de vários bancos de dados em uma única instrução. Quanto o tempo de execução está solucionando nomes de tabelas em uma instrução, ele pesquisa nos bancos de dados da ocorrência SQLConnection na ordem em que os bancos de dados foram anexados, iniciando pelo banco de dados que foi conectado usando o método open() ou openAsync(). Use o nome do banco de dados (conforme especificado no parâmetro name do método attach()) na instrução para qualificar explicitamente um nome de tabela.

Para remover um banco de dados anexado com a utilização do método attach(), use o método detach(). Quando a instância SQLConnection é fechada (chamando o método close()), todos os bancos de dados anexados são desanexados.

O banco de dados anexado usa o mesmo modo de execução (síncrono ou assíncrono) que o banco de dados principal. A escolha depende do fato de o banco de dados principal ter sido conectado usando o método open() ou o método openAsync().

Parâmetros

Elementos da API relacionados

Inicia uma transação na qual estão agrupadas todas as instruções SQL executadas em relação ao(s) banco(s) de dados da conexão.

Por padrão, cada instrução SQL é executada em sua própria transação, e a transação termina quando a execução da instrução é concluída com êxito ou falha. A criação de uma transação usando o método begin() faz com que uma nova transação manual seja criada. Desse ponto em diante, todas as instruções SQL executadas contra a ocorrência SQLConnection são realizadas na transação, e qualquer ação ou modificação executada pelas instruções pode ser confirmada (tornada permanente) ou revertida (desfeita) como um grupo.

Para finalizar uma transação, chame o método commit() ou rollback(), se as alterações feitas pelas instruções das transações devem ser permanentes ou descartadas.

Chamadas aninhadas para begin() não são ignoradas. Você pode criar savepoints, que são como marcadores dentro de uma transação, chamando o método setSavepoint(). Você então pode confirmar parcialmente ou reverter instruções SQL chamando os métodos releaseSavepoint() ou rollbackToSavepoint(). Contudo, se uma transação é iniciada chamando begin(), as modificações não são cofirmadas permanentemente no banco de dados até que o método commit() seja chamado.

Caso a conexão com o banco de dados seja fechada enquanto uma transação está aberta, o AIR reverte a transação automaticamente. (Observação: no AIR 1.1 e em versões anteriores, uma transação aberta é comprometida automaticamente quando uma conexão é fechada.)

Uma transação não está limitada a execuções de instruções em um único banco de dados; ela pode incluir instruções executadas em diferentes bancos de dados anexados.

Parâmetros

Elementos da API relacionados

package
{
    import flash.data.SQLConnection;
    import flash.data.SQLResult;
    import flash.data.SQLStatement;
    import flash.display.Sprite;
    import flash.events.SQLErrorEvent;
    import flash.events.SQLEvent;
    import flash.filesystem.File;
    
    public class MultiInsertTransactionExample extends Sprite
    {
        private var conn:SQLConnection;
        private var insertEmployee:SQLStatement;
        private var insertPhoneNumber:SQLStatement;
        
        public function MultiInsertTransactionExample():void
        {
            // define where to find the database file
            var appStorage:File = File.applicationStorageDirectory;
            var dbFile:File = appStorage.resolvePath("ExampleDatabase.db");
            
            // open the database connection
            conn = new SQLConnection();
            conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            conn.addEventListener(SQLEvent.OPEN, openHandler);
            conn.openAsync(dbFile);
        }
        
        // Called when the database is connected
        private function openHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.OPEN, openHandler);
            
            // start a transaction
            conn.addEventListener(SQLEvent.BEGIN, beginHandler);
            conn.begin();
        }
        
        // Called when the transaction begins
        private function beginHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.BEGIN, beginHandler);
            
            // create and execute the first SQL statement:
            // insert an employee record
            insertEmployee = new SQLStatement();
            insertEmployee.sqlConnection = conn;
            insertEmployee.text = 
                "INSERT INTO employees (lastName, firstName, email) " + 
                "VALUES (:lastName, :firstName, :email, :birthday)";
            insertEmployee.parameters[":lastName"] = "Smith";
            insertEmployee.parameters[":firstName"] = "Bob";
            insertEmployee.parameters[":email"] = "bsmith@example.com";
            insertEmployee.parameters[":birthday"] = new Date(1971, 8, 12);
            
            insertEmployee.addEventListener(SQLEvent.RESULT, insertEmployeeHandler);
            insertEmployee.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            insertEmployee.execute();
        }
        
        // Called after the employee record is inserted
        private function insertEmployeeHandler(event:SQLEvent):void
        {
            insertEmployee.removeEventListener(SQLEvent.RESULT, insertEmployeeHandler);
            insertEmployee.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // Get the employee id of the newly created employee row
            var result:SQLResult = insertEmployee.getResult();
            var employeeId:Number = result.lastInsertRowID;
            
            // Add a phone number to the related phoneNumbers table
            insertPhoneNumber = new SQLStatement();
            insertPhoneNumber.sqlConnection = conn;
            insertPhoneNumber.text =
                "INSERT INTO phoneNumbers (employeeId, type, number) " +
                "VALUES (:employeeId, :type, :number)";
            insertPhoneNumber.parameters[":employeeId"] = employeeId;
            insertPhoneNumber.parameters[":type"] = "Home";
            insertPhoneNumber.parameters[":number"] = "(555) 555-1234";
            
            insertPhoneNumber.addEventListener(SQLEvent.RESULT, insertPhoneNumberHandler);
            insertPhoneNumber.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            insertPhoneNumber.execute();
        }
        
        // Called after the phone number record is inserted
        private function insertPhoneNumberHandler(event:SQLEvent):void
        {
            insertPhoneNumber.removeEventListener(SQLEvent.RESULT, insertPhoneNumberHandler);
            insertPhoneNumber.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // No errors so far, so commit the transaction
            conn.addEventListener(SQLEvent.COMMIT, commitHandler);
            conn.commit();
        }
        
        // Called after the transaction is committed
        private function commitHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.COMMIT, commitHandler);
            
            trace("Transaction complete");
        }
        
        // Called whenever an error occurs
        private function errorHandler(event:SQLErrorEvent):void
        {
            // If a transaction is happening, roll it back
            if (conn.inTransaction)
            {
                conn.addEventListener(SQLEvent.ROLLBACK, rollbackHandler);
                conn.rollback();
            }
            
            trace(event.error.message);
            trace(event.error.details);
        }
        
        // Called when the transaction is rolled back
        private function rollbackHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.ROLLBACK, rollbackHandler);
            
            // add additional error handling, close the database, etc.
        }
    }
}

package
{
    import flash.data.SQLConnection;
    import flash.data.SQLResult;
    import flash.data.SQLStatement;
    import flash.display.Sprite;
    import flash.events.SQLErrorEvent;
    import flash.events.SQLEvent;
    import flash.filesystem.File;
    
    public class MultiDeleteTransactionExample extends Sprite
    {
        private var conn:SQLConnection;
        private var deleteEmployee:SQLStatement;
        private var deletePhoneNumbers:SQLStatement;
        
        private var employeeIdToDelete:Number = 25;
        
        public function MultiDeleteTransactionExample():void
        {
            // define where to find the database file
            var appStorage:File = File.applicationStorageDirectory;
            var dbFile:File = appStorage.resolvePath("ExampleDatabase.db");
            
            // open the database connection
            conn = new SQLConnection();
            conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            conn.addEventListener(SQLEvent.OPEN, openHandler);
            conn.openAsync(dbFile);
        }
        
        // Called when the database is connected
        private function openHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.OPEN, openHandler);
            
            // start a transaction
            conn.addEventListener(SQLEvent.BEGIN, beginHandler);
            conn.begin();
        }
        
        // Called when the transaction begins
        private function beginHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.BEGIN, beginHandler);
            
            // Create and execute the first SQL statement:
            // Delete an employee's phone number records
            deletePhoneNumbers = new SQLStatement();
            deletePhoneNumbers.sqlConnection = conn;
            deletePhoneNumbers.text =
                "DELETE FROM phoneNumbers " +
                "WHERE employeeId = :employeeId";
            deletePhoneNumbers.parameters[":employeeId"] = employeeIdToDelete;
            
            deletePhoneNumbers.addEventListener(SQLEvent.RESULT, deletePhoneNumbersHandler);
            deletePhoneNumbers.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deletePhoneNumbers.execute();
        }
        
        // Called after the phone number records are deleted
        private function deletePhoneNumbersHandler(event:SQLEvent):void
        {
            deletePhoneNumbers.removeEventListener(SQLEvent.RESULT, deletePhoneNumbersHandler);
            deletePhoneNumbers.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deleteEmployee = new SQLStatement();
            deleteEmployee.sqlConnection = conn;
            deleteEmployee.text = 
                "DELETE FROM employees " + 
                "WHERE employeeId = :employeeId";
            deleteEmployee.parameters[":employeeId"] = employeeIdToDelete;
            
            deleteEmployee.addEventListener(SQLEvent.RESULT, deleteEmployeeHandler);
            deleteEmployee.addEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            deleteEmployee.execute();
        }
        
        // Called after the employee record is deleted
        private function deleteEmployeeHandler(event:SQLEvent):void
        {
            deleteEmployee.removeEventListener(SQLEvent.RESULT, deleteEmployeeHandler);
            deleteEmployee.removeEventListener(SQLErrorEvent.ERROR, errorHandler);
            
            // No errors so far, so commit the transaction
            conn.addEventListener(SQLEvent.COMMIT, commitHandler);
            conn.commit();
        }
        
        // Called after the transaction is committed
        private function commitHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.COMMIT, commitHandler);
            
            trace("Transaction complete");
        }
        
        // Called whenever an error occurs
        private function errorHandler(event:SQLErrorEvent):void
        {
            // If a transaction is happening, roll it back
            if (conn.inTransaction)
            {
                conn.addEventListener(SQLEvent.ROLLBACK, rollbackHandler);
                conn.rollback();
            }
            
            trace(event.error.message);
            trace(event.error.details);
        }
        
        // Called when the transaction is rolled back
        private function rollbackHandler(event:SQLEvent):void
        {
            conn.removeEventListener(SQLEvent.ROLLBACK, rollbackHandler);
            
            // add additional error handling, close the database, etc.
        }
    }
}

Aborta todas as instruções SQL que estão em execução no momento nos bancos de dados conectados à ocorrência SQLConnection. Esse método pode ser usado para parar longas filas em execução ou de operações malsucedidas.

Se houver instruções em execução quando o método cancel() for chamado, esse método abortará as operações das instruções e qualquer atualização ou transação incompleta será revertida. Se não houver instruções em execução no momento, chamar esse método reverte uma transação aberta mas, caso contrário, não terá efeito algum.

Parâmetros

Elementos da API relacionados

Fecha a conexão atual do banco de dados. Qualquer banco de dados anexado também será desanexado.

Se houver uma transação aberta quanto close() for chamado, a transação será desfeita. Quando uma instância SQLConnection for colocada na lixeira, o tempo de execução chamará close() automaticamente, inclusive se um aplicativo AIR for fechado enquanto uma SQLConnection ainda estiver conectada a um banco de dados.

Parâmetros

Confirma uma transação existente fazendo com que qualquer ação executada pelas instruções da transação seja permanentemente aplicada ao banco de dados.

Os savepoints intermediários, que são como marcadores em uma transação, podem ser criados chamando o método setSavepoint(). Utilizando savepoints você pode confirmar porções de uma transação chamando o método releaseSavepoint(), ou reverter porções de uma transação chamando o método rollbackToSavepoint(). Contudo, se uma transação é aberta usando o método begin(), as modificações não são permanentemente salvas no banco de dados até que a transação inteira seja confirmada chamando o método commit().

Para uma transação que usa savepoints, qualquer instrução que foi revertida usando o método rollbackToSavepoint() não é confirmada quando a transação inteira é confirmada. As instruções que foram confirmadas usando releaseSavepoint() ou cujos savepoints não foram soltos ou revertidos são confirmadas no banco de dados.

Parâmetros

Elementos da API relacionados

Requer todo o espaço não utilizado no banco de dados. Quando um objeto (tabela, índice ou disparador) é retirado do banco de dados, é deixado um espaço vazio. Isso torna o arquivo do banco de dados maior do que o necessário, mas pode acelerar as operações INSERT. Com o tempo, as operações INSERT e DELETE podem deixar fragmentada a estrutura do arquivo do banco de dados, o que reduz a velocidade de acesso do disco ao conteúdo do banco de dados. Esse método compacta o arquivo do banco de dados, eliminando páginas vazias, alinhando os dados das tabelas para que fiquem contíguos e, de outra forma, limpando a estrutura do arquivo do banco de dados.

A operação compact() não pode ser executada em um arquivo de banco de dados anexado; só pode ser executado no arquivo do banco de dados principal (original) aberto pela ocorrência SQLConnection. Essa operação falhará se houver uma transação ativa e não terá efeito em um banco de dados na memória.

Parâmetros

Remove todas as informações estatísticas criadas por uma chamada do método analyze().

Uma vez que as estatísticas geradas pelo método analyze() ocupam espaço em um banco de dados, chamar deanalyze() permite que você restitua esse espaço, como depois de eliminar vários índices ou tabelas.

Essa operação não está incluída em uma transação ativa.

Parâmetros

Elementos da API relacionados

Desanexa um banco de dados adicional previamente anexado à ocorrência SQLConnection usando o método attach(). É possível ter o mesmo arquivo de banco de dados anexado várias vezes usando nomes diferentes, e desanexar uma conexão a um arquivo deixará os outros intactos. Um banco de dados não poderá ser desanexado se a conexão tiver uma transação aberta (se a propriedade inTransaction for true).

Parâmetros

Elementos da API relacionados

Fornece acesso ao resultado de uma chamada ao método loadSchema(). O método getSchemaResult() se comporta como uma fila de resultados do tipo o primeiro a entrar é o primeiro a sair. Toda vez que a chamada do método loadSchema() é concluída (toda vez que o evento schema é despachado no modo de execução assíncrono), um novo objeto SQLSchemaResult é adicionado à fila. Toda vez que o método getSchemaResult() é chamado, o resultado mais antigo (aquele que foi adicionado à fila primeiro) é retornado e removido da fila. Quando não há mais objetos restantes na fila, getSchemaResult() retorna null.

Quando a conexão do banco de dados é fechada, o método retorna null.

Elementos da API relacionados

Carrega as informações sobre o esquema do banco de dados conectado ou de qualquer banco de dados anexado. O esquema indica a estrutura das tabelas, colunas, índices e disparadores do banco de dados.

Para acessar o esquema carregado, use o método SQLConnection.getSchemaResult().

No modo de execução assíncrono, um evento schema é despachado se a operação é bem-sucedida, ou um evento error é despachado se a operação falha.

A combinação dos valores dos parâmetros type e name determina o tipo de dados de esquema que são gerados pelo método loadSchema() e, consequentemente, os valores das propriedades da instância SQLSchemaResult que é gerada. A tabela a seguir lista os pares type e name válidos e os dados do esquema que são gerados como resultado:

Se a combinação dos argumentos type e name não corresponder a uma das combinações especificadas, um evento error será despachado no modo de execução assíncrono ou uma exceção será lançada no modo de execução sincrônico. Por exemplo, se o argumento type for SQLViewSchema e o argumento name for o nome de uma tabela (em vez de o nome de uma visualização), um erro será gerado indicando que o banco de dados não contém um objeto do tipo especificado com o nome especificado.

Caso o banco de dados esteja vazio (ele não contém nenhuma tabela, exibição, disparadores ou índices), chamar o método loadSchema() resulta em um erro.

Parâmetros

Elementos da API relacionados

Abre uma conexão sincrônica com o arquivo do banco de dados no local especificado no sistema de arquivos, ou cria e abre um novo arquivo de banco de dados no local, ou cria e abre um banco de dados na memória. As operações de criação e abertura do banco de dados, bem como todas as outras operações que são executadas usando essa ocorrência SQLConnection (incluindo a execução da instrução e outras operações executadas por uma ocorrência SQLStatement associada a essa ocorrência SQLConnection), são executadas sincronicamente quando o banco de dados é aberto usando esse método. Para executar operações assincronicamente, abra a conexão do banco de dados usando o método openAsync().

Uma vez que um banco de dados está conectado, use uma instância SQLStatement para executar comandos de SQL. As operações de nível do banco de dados, tais como começar ou concluir transações, carregar informações de esquema e outras operações são executadas usando a instância SQLConnection.

Um banco de dados que é conectado usando o método open() recebe automaticamente o nome do banco de dados "principal"; esse nome pode ser usado para qualificar explicitamente nomes de tabelas nas instruções SQL que usam o formato [database-name].[table-name].

Parâmetros

Elementos da API relacionados

Abre uma conexão assíncrona com o arquivo do banco de dados no local especificado no sistema de arquivos, ou cria e abre um novo arquivo de banco de dados no local, ou cria e abre um banco de dados na memória. As operações de criação e abertura do banco de dados, bem como todas as outras operações que são executadas usando essa ocorrência SQLConnection (incluindo a execução da instrução e outras operações executadas por uma ocorrência SQLStatement associada a essa ocorrência SQLConnection), são executadas assincronicamente quando o banco de dados é aberto usando esse método. Para executar operações sincronicamente, abra a conexão do banco de dados usando o método open().

Uma vez que um banco de dados está conectado, use uma instância SQLStatement para executar comandos de SQL. As operações de nível do banco de dados, tais como começar ou concluir transações, carregar informações de esquema e outras operações são executadas usando a instância SQLConnection.

Um banco de dados que é conectado usando o método openAsync() recebe automaticamente o nome do banco de dados "principal"; esse nome pode ser usado para qualificar explicitamente nomes de tabelas nas instruções SQL que usam o formato [database-name].[table-name].

Parâmetros

Elementos da API relacionados

Altera a chave de criptografia de um banco de dados criptografado. Esse método só afeta a chave de criptografia do banco de dados principal (o banco de dados conectado usando o método open() ou openAsync()). Você só pode chamar reencrypt() em um banco de dados criptografado quando criado. Depois que um banco de dados é criado como um banco de dados criptografado, ele não pode ser descriptografado. Da mesma forma, um banco de dados criado sem criptografia não pode ser criptografado posteriormente.

A operação de nova criptografia é executada na própria transação. Caso o processo de nova criptografia seja interrompido, o banco de dados reverte a transação e a chave de criptografia não é alterada.

Parâmetros

Elementos da API relacionados

Este método confirma as operações SQL feitas desde o savepoint mais recente ou o savepoint denominado se um nome for especificado.

Observe que até que a transação inteira seja confirmada, qualquer modificação não será salva permanentemente no banco de dados. Se a transação é iniciada usando o métodobegin(), você deve chamar o método commit() para confirmar a transação inteira. Se a transação é iniciada chamando setSavepoint() enquanto inTransaction é false, você pode concluir a transação inteira chamando o método commit() ou chamando releaseSavepoint() ou rollbackToSavepoint() para o primeiro savepoint da transação.

Se o código chama o método rollback(), ele descarta permanentemente todas as modificações na transação, mesmo que releaseSavepoint() seja chamado antes que a transação seja revertida.

Se este método é chamado sem parâmetros (ou com null para o parâmetroname), ele confirma todas as modificações de banco de dados desde o savepoint não denominado mais recente (o savepoint mais recente criado chamando setSavepoint() sem parâmetro name). Por exemplo, se o método setSavepoint() foi invocado três vezes, três savepoints serão estabelecidos. Chamar releaseSavepoint() nesse ponto confirma as operações SQL executadas desde o terceiro (mais novo) savepoint.

Se um valor é fornecido para o parâmetro name, este método confirma todas as operações SQL realizadas desde o savepoint com o nome especificado. Se outros savepoints forem criados mais recentemente do que o savepoint especificado, as operações executadas depois destes savepoints serão confirmados também.

Uma vez que um savepoint é liberado ou revertido, esse savepoint e qualquer savepoint mais recente serão removidos. Se o código realiza operações SQL adicionais depois que uma chamada releaseSavepoint() ou rollbackToSavepoint() remove um savepoint, essas operações pertencem ao savepoint restante mais recente. (Em outras palavras, eles pertencem ao savepoint criado mais recentemente antes do savepoint removido.) Se nenhum savepoint permanecer, as operações pertencem à transação principal.

Parâmetros

Elementos da API relacionados

Remove um ouvinte do objeto EventDispatcher. Se não existir um ouvinte correspondente registrado com o objeto EventDispatcher, uma chamada para esse método não terá efeito.

Parâmetros

Reverte uma transação existente criada com o uso do método begin(), significando que todas as alterações feitas por qualquer instrução SQL na transação são descartadas.

Savepoints intermediáris podem ser marcados dentro de uma transação chamando o método setSavepoint(). Usando savepoints você pode confirmar porções de uma transação chamando o método releaseSavepoint(), ou reverter porções de uma transação chamando rollbackToSavepoint(). Contudo, chamar o método rollback() descarta permanentemente todas as modificações feitas em uma transação, mesmo que savepoints individuais tenham sido liberados (confirmados) antes que a transação seja revertida.

Parâmetros

Elementos da API relacionados

Reverte qualquer operação SQL desde o savepoint mais recente ou o savepoint denominado se um nome for especificado.

Observe que se a transação inteira for confirmada chamando o método commit(), qualquer modificação na transação que ainda não foi revertida usando o método rollbackToSavepoint() será salva permanentemente no banco de dados. Além disso, chamar o método rollback() descarta permanentemente todas as modificações, mesmo que savepoints individuais tenham sido liberados (confirmados) ou revertidos antes que a transação seja revertida.

Se este método é chamado sem parâmetros (ou com null para o parâmetro name), ele reverte todas as modificações no banco de dados desde o savepoint não denominado mais recente (a chamada mais recente para setSavepoint() sem valor de parâmetro name).

Se um valor é fornecido para o parâmetro name este método reverte todas as operações SQL executadas desde o savepoint com o nome especificado. Se outros savepoints tiverem sido criados mais recentemente do que o savepoint especificado, as operações executadas desde aqueles savepoints serão revertidos também.

Uma vez que um savepoint é liberado ou revertido, esse savepoint e qualquer savepoint mais recente serão removidos. Se o código realiza operações SQL adicionais depois que uma chamada releaseSavepoint() ou rollbackToSavepoint() remove um savepoint, essas operações pertencem ao savepoint restante mais recente. (Em outras palavras, eles pertencem ao savepoint criado mais recentemente antes do savepoint removido.) Se nenhum savepoint permanecer, as operações pertencem à transação principal.

Parâmetros

Elementos da API relacionados

Cria um savepoint, que é como um marcador dentro de uma transação de banco de dados. Um savepoint representa um ponto dentro de uma transação. O conjunto de operações SQL executadas entre savepoints pode ser confirmado ou revertido separadamente de outras operações usando os métodos releaseSavepoint() e rollbackToSavepoint(). Deste modo, usar um savepoint permite-lhe tratar um conjunto de operações de SQL como uma transação aninhada.

Quando o método setSavepoint() é invocado, se uma transação já não tiver sido aberta (chamando o método begin()), chamar este método começa a transação e cria um savepoint no início da transação. Se uma transação já estiver aberta, chamar setSavepoint() cria um savepoint dentro da transação.

Observe que até que a transação inteira seja confirmada, qualquer modificação não será salva permanentemente no banco de dados. Se a transação é iniciada usando o métodobegin(), você deve chamar o método commit() para confirmar a transação inteira. Se a transação é iniciada chamando setSavepoint() enquanto inTransaction for false, você pode terminar a transação inteira chamando o método commit(). A transação também termina automaticamente quando você chama releaseSavepoint() ou rollbackToSavepoint() para o savepoint que iniciou a transação.

Você pode especificar um nome de um savepoint fornecendo um valor para o parâmetro name. Isto permite que você reverta ou confirme todas as modificações feitas desde esse savepoint específico. Se nenhum nome for especificado (o padrão) então um savepoint não denominado é criado.

Uma vez que um savepoint é liberado ou revertido, esse savepoint e qualquer savepoint mais recente serão removidos. Se o código realiza operações SQL adicionais depois que uma chamada releaseSavepoint() ou rollbackToSavepoint() remove um savepoint, essas operações pertencem ao savepoint restante mais recente. (Em outras palavras, eles pertencem ao savepoint criado mais recentemente antes do savepoint removido.) Se nenhum savepoint permanecer, as operações pertencem à transação principal.

Parâmetros

Elementos da API relacionados

Despachado quando uma operação analyze() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método attach() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método begin() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método cancel() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método close() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método commit() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método compact() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método deanalyze() é concluída com êxito.

Elementos da API relacionados

Despachado quando os dados em qualquer tabela, em qualquer banco de dados conectado, são alterados como resultado de um comando SQL DELETE. A alteração dos dados pode ser um resultado direto de uma instrução DELETE executada por meio de uma ocorrência SQLStatement, ou um resultado indireto causado por um disparador acionado em resposta à execução de uma instrução.

Elementos da API relacionados

Despachado quando uma operação de chamada do método detach() é concluída com êxito.

Elementos da API relacionados

Despachado quando qualquer operação assíncrona do objeto SQLConnection resulta em um erro. A ocorrência SQLErrorEvent que é despachada como o objeto do evento tem uma propriedade error que contém informações sobre a operação que foi tentada e a causa da falha.

Despachado quando os dados em qualquer tabela, em qualquer banco de dados conectado, são alterados como resultado de um comando SQL INSERT. A alteração dos dados pode ser um resultado direto de uma instrução INSERT executada por meio de uma instância SQLStatement, ou um resultado indireto causado por um disparador acionado em resposta à execução de uma instrução.

Elementos da API relacionados

Despachado quando uma operação de chamada do método openAsync() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método reencrypt() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método releaseSavepoint() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método rollback() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método rollbackToSavepoint() é concluída com êxito.

Elementos da API relacionados

Despachado quando uma operação de chamada do método loadSchema() é concluída com êxito e os resultados do esquema estão prontos.

Elementos da API relacionados

Despachado quando uma operação de chamada do método setSavepoint() é concluída com êxito.

Elementos da API relacionados

Despachado quando os dados em qualquer tabela, em qualquer banco de dados conectado, são alterados como resultado de um comando SQL UPDATE. A alteração dos dados pode ser um resultado direto de uma instrução UPDATE executada por meio de uma ocorrência SQLStatement, ou um resultado indireto causado por um disparador acionado em resposta à execução de uma instrução.

O evento update tem as seguintes propriedades:

Elementos da API relacionados