SQLConnection  - AS3

Indique si l’auto-compactage était activé lors de la création de la base de données en cours (valeur spécifiée pour le paramètre autoCompact dans l’appel à open() ou openAsync() qui a créé la base de données). Si cette propriété est true, l’espace non utilisé est automatiquement supprimé du fichier de base de données après chaque opération d’écriture, ce qui réduit la taille du fichier. Si la propriété est false, l’espace précédemment occupé par les données supprimées est conservé dans le fichier de base de données et réutilisé lorsque nécessaire. Même lorsque autoCompact est false, vous pouvez forcer la base de données à récupérer l’espace non utilisé en appelant la méthode compact().

Si la propriété connected est false, cette propriété est définie sur false.

Eléments de l’API associés

Permet d’accéder à la taille du cache de cette connexion, représentant le nombre maximal de pages de disque de base de données pouvant être conservé en mémoire simultanément. Chaque page utilise environ 1,5 Ko de mémoire (selon la valeur spécifiée pour le paramètre pageSize de l’appel de la méthode open() ou openAsync() qui a créé la base de données). La taille par défaut est 2 000. Si une application exécute des opérations UPDATE ou DELETE qui modifient un grand nombre de lignes d’une base de données, l’augmentation de la taille du cache peut améliorer la vitesse, mais accroît la consommation de mémoire.

Eléments de l’API associés

Indique comment les noms de colonne sont reportés dans le résultat d’une instruction SELECT.

Les constantes définies dans la classe SQLColumnNameStyle représentent les valeurs possibles pour cette propriété :

• SQLColumnNameStyle.LONG indique que les noms de colonne sont renvoyés au format [nom-table]_[nom-colonne].
• SQLColumnNameStyle.SHORT spécifie que les noms de colonne sont donnés au format [nom-colonne]. Si plusieurs colonnes portent le même nom, une seule propriété portant ce nom est ajoutée à l’objet de résultats.
• SQLColumnNameStyle.DEFAULT est la valeur par défaut. Lorsque cette valeur est utilisée, les noms de colonne du résultat sont mis en forme en fonction du nombre de tables portant des noms de colonnes similaires dans l’instruction SELECT. Si l’instruction SELECT ne comprend qu’une table, le format de nom court [nom-colonne] est utilisé, et si l’instruction SELECT contient plusieurs tables réunies, le format de nom long [nom-table]_[nom-colonne] est utilisé chaque fois que le nom de deux colonnes est identique.

Eléments de l’API associés

Indique si l’occurrence SQLConnection a une connexion établie avec un fichier de base de données.

Eléments de l’API associés

Indique si cette connexion est actuellement impliquée dans une transaction.

Eléments de l’API associés

Indique si classe SQLConnection est prise en charge sur la plate-forme actuelle.

Dernier identifiant généré par une instruction SQL INSERT. Un identifiant de ligne est utilisé pour identifier une ligne de façon unique dans un tableau au sein d’une base de données. La valeur est générée fréquemment par la base de données.

La valeur est zéro si aucune base de données n’est connectée ou si aucune instruction INSERT n’a été exécutée.

L’identifiant de ligne pour une seule exécution de l’instruction SQL INSERT peut être obtenu via la propriété lastInsertRowID de l’objet SQLResult renvoyé par la méthode getResult() de l’objet SQLStatement (lorsqu’il est appelé une fois que SQLStatement distribue son événement result).

Pour plus d’informations sur les clés primaires et les identifiants de ligne générés, voir les sections « CREATE TABLE » et « Expressions » dans l’annexe « Prise en charge de SQL dans les bases de données locales ».

Eléments de l’API associés

Indique la taille de la page de base de données (en octets) spécifiée lors de la création de la base de données en cours (valeur spécifiée pour le paramètre pageSize dans l’appel à open() ou openAsync() qui a créé la base de données).

Si la propriété connected est false, la valeur de cette propriété est 0.

La taille de la page d’une base de données peut être modifiée (à l’aide des méthodes open() ou openAsync()) jusqu’à la création de la première table dans la base de données.

Eléments de l’API associés

Contient le nombre total de modifications de données effectuées depuis l’ouverture de la connexion à la base de données. En plus du suivi des modifications effectuées par les instructions INSERT, DELETE et UPDATE, cette valeur comprend les modifications dues aux déclencheurs.

Lorsque la connexion à la base de données est fermée, la valeur est réinitialisée sur 0. Lorsque l’occurrence de SQLConnection n’est pas connectée à une base de données, la valeur est 0.

Eléments de l’API associés

Crée une occurrence SQLConnection.

Enregistre un objet écouteur d’événement auprès d’un objet EventDispatcher afin que l’écouteur soit averti d’un événement. Vous pouvez enregistrer les écouteurs d’événement dans tous les nœuds de la liste d’affichage pour un type spécifique d’événement, de phase et de priorité.

Après l’enregistrement d’un écouteur d’événement, vous ne pouvez plus modifier sa priorité par d’autres appels de addEventListener(). Pour modifier la priorité d’un écouteur, vous devez d’abord appeler removeListener(). Vous pouvez ensuite réenregistrer l’écouteur avec le nouveau niveau de priorité.

N’oubliez pas qu’une fois l’écouteur enregistré, tous les prochains appels de addEventListener() avec une valeur type ou useCapture différente entraîneront la création d’un autre enregistrement d’écouteur. Si, par exemple, vous enregistrez un écouteur dans lequel la propriété useCapture est définie sur true, il écoute uniquement pendant la phase de capture. Si vous appelez addEventListener() à l’aide du même objet écouteur, mais en définissant useCapture sur false, vous obtenez deux écouteurs distincts : l’un qui écoute pendant la phase de capture et l’autre qui écoute pendant les phases cible et de propagation vers le haut (bubbling).

Il est impossible d’enregistrer un écouteur d’événement uniquement pour la phase cible ou la phase de propagation vers le haut. Ces deux phases sont associées pendant l’enregistrement car la propagation vers le haut s’applique uniquement aux ancêtres du nœud cible.

Si vous n’avez plus besoin d’un écouteur d’événements, supprimez-le en appelant removeEventListener(), afin d’éviter tout problème de mémoire. Les écouteurs d’événement ne sont pas automatiquement supprimés de la mémoire, car le nettoyeur de mémoire ne supprime pas l’écouteur tant que l’objet de distribution existe (à moins que le paramètre useWeakReference ne soit défini sur true).

Lors de la copie d’une occurrence d’EventDispatcher, les écouteurs d’événement qui lui sont associés ne sont pas pris en compte (si le nouveau nœud nécessite un écouteur d’événement, vous devez associer celui-ci après la création du nœud). Toutefois, si vous déplacez une occurrence d’EventDispatcher, les écouteurs d’événement qui lui sont associés la suivent.

Si un écouteur d’événement est enregistré sur un nœud alors qu’un événement est en cours de traitement sur ce nœud, l’écouteur n’est pas déclenché pendant la phase actuelle, mais il peut l’être pendant une phase ultérieure du flux d’événements, telle que la phase de propagation vers le haut (bubbling).

Si un écouteur d’événement est supprimé d’un nœud sur lequel un événement est en cours de traitement, il est cependant déclenché par les actions en cours. Une fois supprimé, l’écouteur d’événement n’est plus jamais appelé (à moins d’être réenregistré à des fins de traitement ultérieur).

Paramètres

function(evt:Event):void

Collecte des statistiques sur les index de base de données et les stocke dans la base de données. Ces statistiques peuvent alors être utilisées par l’optimiseur de requêtes (la partie du moteur de base de données qui détermine le moyen le plus efficace pour exécuter chaque instruction). Les statistiques permettent à l’optimiseur de requêtes d’améliorer ses choix quant aux index ou index à utiliser pour exécuter une requête particulière.

Si des indices ont été définis pour une base de données mais que la méthode analyze() n’a pas été appelée, l’exécution continue à utiliser ces indices pour exécuter les instructions. Toutefois, sans les informations statistiques supplémentaires générées par la méthode analyze(), il est possible que le moteur d’exécution ne choisisse pas l’index le plus efficace pour une requête particulière.

Lorsque les données d’une table changent (après des instructions INSERT, UPDATE ou DELETE), les indices associés à cette table changent également. Les informations statistiques générées par la méthode analyze() ne sont pas mises à jour automatiquement. Par conséquent, après un grand nombre de changements de données, un appel à la méthode analyze() peut être bénéfique. L’avantage apporté par un appel à la méthode analyze() dépend toutefois de plusieurs facteurs : le nombre d’indices définis sur une table, le rapport entre le nombre de lignes modifiées et le nombre total de lignes de la table, la quantité de variations existant dans les données indexées de la table et l’importance de la différence entre les données modifiées et les données d’origine.

Le paramètre resourceName indique si l’opération est exécutée sur les indices de toutes les bases de données attachées, d’une base de données spécifique ou d’une table spécifique.

A chaque appel de cette méthode, toutes les données statistiques précédemment créées sont purgées et recréées pour la base de données ou la table spécifiée dans le paramètre resourceName (ou toutes les tables de toutes les bases de données connectées si resourceName est null). Cette méthode peut être appelée à tout moment lorsque que la connexion à la base de données est établie. L’opération analyze() et ses données statistiques ne sont pas incluses dans une transaction. Toutefois, il est préférable de ne pas appeler analyze() lorsqu’une transaction est en cours dans la base de données (la propriété inTransaction est true). Cela est dû au fait que toutes les modifications de données, de schéma de table ou d’index exécutées dans la transaction mais non encore validées ne seront pas pris en compte par l’appel analyze() et les données d’analyze() seront obsolètes dès la validation de la transaction.

Pour supprimer les données statistiques créées avec la méthode analyze(), utilisez la méthode deanalyze().

Paramètres

Eléments de l’API associés

Ajoute une autre base de données à l’occurrence SQLConnection, en lui attribuant le nom spécifié. L’association d’une base de données permet d’utiliser cette dernière dans les instructions SQL exécutées sur l’occurrence SQLConnection.

Si une base de données est déjà associée à l’aide du nom spécifié, un appel à attach() entraîne une erreur. Toutefois, la même base de données peut être associée plusieurs fois à l’aide de noms uniques. Au maximum, dix bases de données peuvent être associées à une même occurrence SQLConnection.

Toute instruction SQL peut être exécutée sur une base de données connectée par la méthode attach() qui peut être exécutée sur la base de données principale (celle qui est connectée avec open() ou openAsync()). Une instruction SQL peut accéder aux tables de toute base de données associée à l’occurrence SQLConnection conjointe de l’instruction, y compris en accédant aux tables de plusieurs bases de données dans une même instruction. Lorsque le moteur d’exécution résout les noms de table en instruction, elle lance une recherche dans les bases de données de l’occurrence SQLConnection dans l’ordre dans lequel celles-ci ont été associées, en commençant par la base de données connectée à l’aide de la méthode open() ou openAsync(). Pour qualifier un nom de table de façon explicite, utilisez le nom de sa base de données (tel que spécifié dans le paramètre name de la méthode attach()) dans l’instruction.

Pour supprimer une base de données associée à l’aide de la méthode attach(), utilisez la méthode detach(). A la fermeture de l’occurrence SQLConnection (par un appel à la méthode close()), toutes les bases de données associées sont dissociées.

La base de données associée utilise le même mode d’exécution (synchrone ou asynchrone) que la base de données principale, selon que cette dernière a été connectée à l’aide de la méthode open() ou openAsync().

Paramètres

Plus d’exemples

Eléments de l’API associés

Commence une transaction, dans laquelle toutes les instructions SQL exécutées sur la ou les bases de données de la connexion sont regroupées.

Par défaut, chaque instruction SQL est exécutée dans sa propre transaction et celle-ci se termine lorsque l’exécution de l’instruction réussit ou échoue. La création d’une transaction à l’aide de la méthode begin() entraîne la création d’une nouvelle transaction manuelle. A partir de ce point, toutes les instructions SQL exécutées sur l’occurrence SQLConnection le sont dans la transaction, et toutes les actions ou modifications exécutées par les instructions peuvent être validées (rendues permanentes) ou annulées en un seul lot.

Pour terminer une transaction, appelez la méthode commit() ou rollback(), selon que les modifications apportées par les instructions de la transaction doivent devenir permanentes ou être annulées.

Les appels imbriqués à begin() sont ignorés. Vous pouvez créer des points de sauvegarde (semblables aux signets dans une transaction) en appelant la méthode setSavepoint(). Vous pouvez ensuite partiellement valider ou restaurer les instructions SQL en appelant la méthode releaseSavepoint() ou rollbackToSavepoint(). Toutefois, si une transaction est lancée en appelant la méthode begin(), les modifications ne sont pas définitivement validées dans la base de données tant que la méthode commit() n’est pas appelée.

Si la connexion à la base de données se ferme lorsqu’une transaction est en cours, AIR restaure automatiquement la transaction (remarque : pour AIR 1.1 et versions antérieures, une transaction en cours est automatiquement validée lorsqu’une connexion se ferme).

Une transaction n’est pas limitée aux exécutions d’instructions dans une seule base de données, mais peut comprendre des instructions exécutées sur d’autres bases de données associées.

Paramètres

Eléments de l’API associés

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.
        }
    }
}

Annule toutes les instructions SQL en cours d’exécution sur les bases de données connectées à l’occurrence SQLConnection. Cette méthode peut être utilisée pour interrompre des requêtes d’exécution longue ou des requêtes qui s’emballent.

Si des instructions s’exécutent lors de l’appel à cancel(), cette méthode annule les opérations des instructions et toutes les mises à jour ou transactions incomplètes sont annulées. Lorsque aucune instruction n’est en cours d’exécution, l’appel à cette méthode annule la transaction ouverte, sinon elle est sans effet.

Paramètres

Eléments de l’API associés

Ferme la connexion à la base de données en cours. Toutes les bases de données associées sont également dissociées.

Si une transaction est ouverte lors de l’appel de la méthode close(), la transaction est validée. Lorsqu’une occurrence SQLConnection est nettoyée, le moteur d’exécution appelle automatiquement close(), y compris si une application AIR est fermée alors qu’une occurrence SQLConnection est toujours connectée à une base de données.

Paramètres

Valide une transaction existante, en rendant permanentes toutes les actions effectuées par ses instructions dans la base de données.

Il est possible de créer des points de sauvegarde intermédiaires, semblables aux signets dans une transaction, en appelant la méthode setSavepoint(). Les points de sauvegarde permettent de valider (via l’appel de la méthode releaseSavepoint()) ou de restaurer (via l’appel à la méthode rollbackToSavepoint()) certaines parties d’une transaction. Toutefois, si une transaction est ouverte à l’aide de la méthode begin(), les modifications ne sont pas définitivement enregistrées dans la base de données tant que l’ensemble de la transaction n’est pas validée via l’appel de la méthode commit().

Si une transaction utilise des points de sauvegarde, les instructions qui ont été restaurées à l’aide de la méthode rollbackToSavepoint() ne sont pas validées lorsque l’intégralité de la transaction est validée. Les instructions qui ont été validées à l’aide de la méthode releaseSavepoint(), ou dont les points de sauvegarde n’ont pas été publiés ou restaurés, sont validées dans la base de données.

Paramètres

Eléments de l’API associés

Récupère tout l’espace non utilisé dans la base de données. Lorsqu’un objet (table, index ou déclencheur) est abandonné dans la base de données, il laisse un espace vide. Le fichier de bases de données est alors plus volumineux que nécessaire, mais cela peut accélérer les opérations INSERT. Avec le temps, les opérations INSERT et DELETE peuvent fragmenter la structure du fichier de la base de données, ce qui ralentit les accès disque au contenu de la base de données. Cette méthode compacte le fichier de base de données en éliminant les pages libres, en alignant les données de la table de façon contiguë et en nettoyant la structure du fichier de base de données.

L’opération compact() ne peut pas être exécutée sur un fichier d’une base de données associée, mais uniquement sur le fichier de la base de données principale (originale) ouvert par l’occurrence SQLConnection. Cette opération échoue si une transaction est active et n’a pas d’effet sur une base de données en mémoire.

Paramètres

Supprime toutes les informations statistiques créées par un appel de la méthode analyze().

Les statistiques générées par la méthode analyze() occupant de l’espace dans une base de données, un appel à deanalyze() vous permet de récupérer cet espace, par exemple après l’abandon de plusieurs indices ou tables.

Cette opération n’est pas incluse dans une transaction active.

Paramètres

Eléments de l’API associés

Dissocie une base de données supplémentaire précédemment associée à l’occurrence SQLConnection à l’aide de la méthode attach(). Il est possible d’associer le même fichier de base de données plusieurs fois à l’aide de noms différents et de dissocier une connexion à un fichier sans toucher aux autres connexions. Il est impossible de dissocier une base de données si la connexion contient une transaction ouverte (c’est-à-dire si la propriété inTransaction est définie sur true).

Paramètres

Plus d’exemples

Eléments de l’API associés

Permet d’accéder au résultat d’un appel à la méthode loadSchema(). La méthode getSchemaResult() se comporte comme une file d’attente de résultats premier entré-premier sorti. Chaque fois qu’un appel à la méthode loadSchema() se termine (chaque fois que l’événement schema est déclenché en mode d’exécution asynchrone), un nouvel objet SQLSchemaResult est ajouté à la file d’attente. Chaque fois que la méthode getSchemaResult() est appelée, le premier résultat (celui qui a été ajouté en premier à la file d’attente) est renvoyé et retiré de la file. Lorsqu’il ne reste plus aucun objet dans la file d’attente, getSchemaResult() renvoie null.

Lorsque la connexion à la base de données est fermée, la méthode renvoie null.

Eléments de l’API associés

Charge les informations de schéma depuis la base de données connectées ou depuis l’une des bases de données associées. Le schéma indique la structure des tables, des colonnes, des index et des déclencheurs de la base de données.

Pour accéder au schéma chargé, utilisez la méthode SQLConnection.getSchemaResult().

En mode d’exécution asynchrone, un événement schema est déclenché si l’opération réussit, ou un événement error est déclenché si elle échoue.

La combinaison des valeurs des paramètres type et name détermine le type de données du schéma généré par la méthode loadSchema(), et par conséquent les valeurs des propriétés de l’occurrence SQLSchemaResult générées. Le tableau suivant présente la liste des paires type et name valides et les données de schéma générées en résultat :

Si la combinaison d’arguments type et name ne correspond pas à l’une des combinaisons spécifiées, un événement error est déclenché en mode d’exécution asynchrone ou une exception est renvoyée en mode d’exécution synchrone. Par exemple si l’argument type est SQLViewSchema et que l’argument name est le nom d’une table (au lieu de celui d’une vue), une erreur est renvoyée pour indiquer que la base de données ne contient pas d’objet présentant le type spécifié avec le nom spécifié.

Si la base de données est vide (elle ne contient pas de table, ni de vue, ni de déclencheur, ni d’indice), l’appel de la méthode loadSchema() déclenche une erreur.

Paramètres

Eléments de l’API associés

Ouvre une connexion synchrone au fichier de base de données à l’emplacement spécifié dans le système de fichiers, crée et ouvre un nouveau fichier de base de données à cet emplacement, ou crée et ouvre une base de données en mémoire. Les opérations de création et d’ouverture de base de données, comme toutes les autres opérations exécutées avec cette occurrence SQLConnection (y compris l’exécution d’instructions et d’autres opérations exécutées par une occurrence SQLStatement associée à cette occurrence SQLConnection) sont exécutées de façon synchrone lorsque la base de données est ouverte avec cette méthode. Pour exécuter des opérations de façon asynchrone, ouvrez la connexion de la base de données à l’aide de la méthode openAsync().

Après la connexion d’une base de données, utilisez une occurrence de SQLStatement pour exécuter les commandes SQL. Les opérations au niveau de la base de données, notamment le lancement ou la finalisation de transactions, ainsi que le chargement d’informations de schéma sont exécutées à l’aide de l’occurrence de SQLConnection.

Une base de données connectée avec la méthode open() se voit automatiquement attribuer le nom de base de données « main ». Ce nom peut être utilisé pour qualifier explicitement les noms de table dans les instructions SQL qui utilisent le format [nom-base de données].[nom-table].

Paramètres

Plus d’exemples

Eléments de l’API associés

Ouvre une connexion asynchrone au fichier de base de données à l’emplacement spécifié dans le système de fichiers, crée et ouvre un nouveau fichier de base de données à cet emplacement, ou crée et ouvre une base de données en mémoire. Les opérations de création et d’ouverture de base de données, comme toutes les autres opérations exécutées avec cette occurrence SQLConnection (y compris l’exécution d’instructions et d’autres opérations exécutées par une occurrence SQLStatement associée à cette occurrence SQLConnection) sont exécutées de façon asynchrone lorsque la base de données est ouverte avec cette méthode. Pour exécuter des opérations de façon synchrone, ouvrez la connexion de la base de données à l’aide de la méthode open().

Après la connexion d’une base de données, utilisez une occurrence de SQLStatement pour exécuter les commandes SQL. Les opérations au niveau de la base de données, notamment le lancement ou la finalisation de transactions, ainsi que le chargement d’informations de schéma sont exécutées à l’aide de l’occurrence de SQLConnection.

Une base de données connectée avec la méthode openAsync() se voit automatiquement attribuer le nom de base de données « main ». Ce nom peut être utilisé pour qualifier explicitement les noms de table dans les instructions SQL utilisant le format [nom-base de données].[nom-table].

Paramètres

Plus d’exemples

Eléments de l’API associés

Modifie la clé de chiffrement d’une base de donnée chiffrée. Cette méthode affecte uniquement la clé de chiffrement de la base de données principale (c’est-à-dire la base de données connectée à l’aide de la méthode open() ou openAsync()). Vous pouvez appeler reencrypt() uniquement sur une base de données ayant été chiffrée lors de sa création. Après avoir créé une base de données chiffrée, il est impossible de la déchiffrer. De la même manière, si une base de données non chiffrée est créée, celle-ci ne peut pas être chiffrée ultérieurement.

La nouvelle tentative de chiffrement est exécutée dans sa propre transaction. Si la nouvelle tentative de chiffrement est interrompue, la base de données restaure la transaction et la clé de chiffrement reste inchangée.

Paramètres

Plus d’exemples

Eléments de l’API associés

Cette méthode valide les opérations SQL effectuées depuis le point de sauvegarde le plus récent ou le point de sauvegarde désigné si un nom est spécifié.

Notez que jusqu’à ce que l’ensemble de la transaction soit validée, les modifications ne sont pas définitivement enregistrées dans la base de données. Si la transaction est lancée à l’aide de la méthode begin(), vous devez appeler la méthode commit() pour valider l’ensemble de la transaction. Si la transaction est lancée via un appel de la méthode setSavepoint() alors que la propriété inTransaction est définie sur false, vous pouvez finaliser l’ensemble de la transaction soit en appelant la méthode commit() soit en appelant la méthode releaseSavepoint() ou rollbackToSavepoint() pour le premier point de sauvegarde de la transaction.

Si le code appelle la méthode rollback(), il supprime définitivement toutes les modifications effectuées dans la transaction, même si la méthode releaseSavepoint() est appelée avant la restauration de la transaction.

Si cette méthode est appelée sans paramètre (ou si le paramètre name est défini sur null), elle valide toutes les modifications dans la base de données depuis le point de sauvegarde non désigné le plus récent (point de sauvegarde le plus récent créé via un appel de méthode setSavepoint() dont le paramètre name n’a pas été défini). Par exemple, si la méthode setSavepoint() a été appelée trois fois, trois points de sauvegarde sont définis. L’appel de la méthode releaseSavepoint() au niveau de ce point valide les opérations SQL exécutées depuis le troisième point de sauvegarde (le plus récent).

Si le paramètre name est défini sur une valeur, cette méthode valide toutes les opérations SQL exécutées depuis le point de sauvegarde portant le nom spécifié. Si d’autres points de sauvegarde ont été créés plus récemment que le point de sauvegarde spécifié, les opérations exécutées après ces points de sauvegarde sont également validées.

Après la publication ou la restauration d’un point de sauvegarde, ce dernier, ainsi que les points de sauvegarde plus récents, sont supprimés. Si le code exécute d’autres opérations SQL après qu’un appel à releaseSavepoint() ou rollbackToSavepoint() supprime un point de sauvegarde, ces opérations appartiennent au point de sauvegarde restant le plus récent. (En d’autres termes, elles appartiennent au point de sauvegarde créé le plus récemment avant le point de sauvegarde supprimé.) S’il ne reste aucun point de sauvegarde, les opérations appartiennent à la transaction principale.

Paramètres

Eléments de l’API associés

Supprime un écouteur de l’objet EventDispatcher. Si aucun écouteur correspondant n’est enregistré auprès de l’objet EventDispatcher, l’appel de cette méthode n’a aucun effet.

Paramètres

Annule une transaction existante créée avec la méthode begin(), ce qui signifie que toutes les modifications apportées à la transaction par les instructions SQL sont annulées.

Les points de sauvegarde intermédiaires peuvent être marqués au sein d’une transaction via un appel de la méthode setSavepoint(). Les points de sauvegarde permettent de valider (via l’appel de la méthode releaseSavepoint()) ou de restaurer (via l’appel à la méthode rollbackToSavepoint()) certaines parties d’une transaction. Toutefois, l’appel de la méthode rollback() supprime définitivement toutes les modifications effectuées dans une transaction, même si des points de sauvegarde individuels ont été publiés (validés) avant la restauration de la transaction.

Paramètres

Eléments de l’API associés

Restaure toutes les opérations SQL depuis le point de sauvegarde le plus récent ou le point de sauvegarde désigné si un nom est spécifié.

Notez que si l’ensemble de la transaction est validée via l’appel de la méthode commit(), les modifications apportées à la transaction qui ne sont pas déjà restaurées à l’aide de la méthode rollbackToSavepoint() sont définitivement enregistrées dans la base de données. En outre, l’appel de la méthode rollback() supprime définitivement toutes les modifications, même si des points de sauvegarde individuels ont été publiés (validés) ou restaurés avant la restauration de la transaction.

Si cette méthode est appelée sans paramètre (ou si le paramètre name est défini sur null), elle restaure toutes les modifications effectuées dans la base de données depuis le point de sauvegarde non désigné le plus récent (l’appel le plus récent de la méthode setSavepoint() dont le paramètre name n’a pas été défini).

Si le paramètre name est défini sur une valeur, cette méthode restaure toutes les opérations SQL exécutées depuis le point de sauvegarde portant le nom spécifié. Si d’autres points de sauvegarde ont été créés plus récemment que le point de sauvegarde spécifié, les opérations exécutées depuis ces points de sauvegarde sont également restaurées.

Après la publication ou la restauration d’un point de sauvegarde, ce dernier, ainsi que les points de sauvegarde plus récents, sont supprimés. Si le code exécute d’autres opérations SQL après qu’un appel à releaseSavepoint() ou rollbackToSavepoint() supprime un point de sauvegarde, ces opérations appartiennent au point de sauvegarde restant le plus récent. (En d’autres termes, elles appartiennent au point de sauvegarde créé le plus récemment avant le point de sauvegarde supprimé.) S’il ne reste aucun point de sauvegarde, les opérations appartiennent à la transaction principale.

Paramètres

Eléments de l’API associés

Crée un point de sauvegarde, similaire à un signet dans une transaction de bases de données. Un point de sauvegarde représente un point au sein d’une transaction. La série d’opérations SQL exécutées entre des points de sauvegarde peut être validée ou restaurées séparément des autres opérations à l’aide des méthodes releaseSavepoint() et rollbackToSavepoint(). L’utilisation d’un point de sauvegarde permet ainsi de traiter une série d’opérations SQL en tant que transaction imbriquée.

Lors de l’appel de la méthode setSavepoint(), si une transaction n’a pas encore été ouverte (via l’appel de la méthode begin()), l’appel de cette méthode lance la transaction et crée un point de sauvegarde au début de la transaction. Si une transaction est déjà ouverte, l’appel de la méthode setSavepoint() crée un point de sauvegarde dans la transaction.

Notez que jusqu’à ce que l’ensemble de la transaction soit validée, les modifications ne sont pas définitivement enregistrées dans la base de données. Si la transaction est lancée à l’aide de la méthode begin(), vous devez appeler la méthode commit() pour valider l’ensemble de la transaction. Si la transaction est lancée via un appel de la méthode setSavepoint() alors que la propriété inTransaction est définie sur false, vous pouvez finaliser l’ensemble de la transaction en appelant la méthode commit(). En outre, la transaction se termine automatiquement lorsque vous appelez la méthode releaseSavepoint() ou rollbackToSavepoint() pour le point de sauvegarde ayant déclenché la transaction.

Vous pouvez attribuer un nom à un point de sauvegarde en affectant une valeur au paramètre name. Vous pouvez ainsi restaurer ou valider toutes les modifications effectuées depuis ce point de sauvegarde spécifique. Si aucun nom n’est spécifié (valeur par défaut), un point de sauvegarde non désigné est créé.

Après la publication ou la restauration d’un point de sauvegarde, ce dernier, ainsi que les points de sauvegarde plus récents, sont supprimés. Si le code exécute d’autres opérations SQL après qu’un appel à releaseSavepoint() ou rollbackToSavepoint() supprime un point de sauvegarde, ces opérations appartiennent au point de sauvegarde restant le plus récent. (En d’autres termes, elles appartiennent au point de sauvegarde créé le plus récemment avant le point de sauvegarde supprimé.) S’il ne reste aucun point de sauvegarde, les opérations appartiennent à la transaction principale.

Paramètres

Eléments de l’API associés

Distribué lorsqu’une opération analyze() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode attach() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode begin() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode cancel() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode close() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode commit() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode compact() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode deanalyze() se termine avec succès.

Eléments de l’API associés

Distribué lorsque les données d’une table de l’une des bases de données connectées changent après une commande SQL DELETE. La modification des données peut résulter directement de l’exécution d’une instruction DELETE par une occurrence SQLStatement, ou résulter indirectement du déclenchement d’un déclencheur en réponse à l’exécution d’une instruction.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode detach() se termine avec succès.

Eléments de l’API associés

Distribué lorsque l’une des opérations asynchrones de l’objet SQLConnection provoque une erreur. L’occurrence SQLErrorEvent déclenchée en tant qu’objet d’événement a une propriété error qui contient des informations sur l’opération tentée et sur la cause de l’échec.

Distribué lorsque les données d’une table de l’une des bases de données connectées changent après une commande SQL INSERT. La modification des données peut résulter directement de l’exécution d’une instruction INSERT par l’intermédiaire d’une occurrence SQLStatement, ou résulter indirectement du déclenchement d’un déclencheur en réponse à l’exécution d’une instruction.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode openAsync() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode reencrypt() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’un appel de la méthode releaseSavepoint() aboutit.

Eléments de l’API associés

Distribué lorsqu’une opération d’appel de la méthode rollback() se termine avec succès.

Eléments de l’API associés

Distribué lorsqu’un appel de la méthode rollbackToSavepoint() aboutit.

Eléments de l’API associés

Distribué lorsque l’opération d’un appel de la méthode loadSchema() se termine avec succès et que les résultats du schéma sont prêts.

Eléments de l’API associés

Distribué lorsqu’un appel de la méthode setSavepoint() aboutit.

Eléments de l’API associés

Distribué lorsque les données d’une table de l’une des bases de données connectées changent après une commande SQL UPDATE. La modification des données peut résulter directement d’une instruction UPDATE exécutée par une occurrence SQLStatement, ou résulter indirectement du déclenchement d’un déclencheur en réponse à une exécution d’instruction.

L’événement update a les propriétés suivantes :

Eléments de l’API associés