Récupération de données dans une base de données

Pour extraire des données existantes d’une base de données, utilisez une occurrence de SQLStatement . Affectez l’instruction SQL SELECT appropriée à la propriété text de l’occurrence, puis appelez sa méthode execute() .

Pour plus d’informations sur la syntaxe de l’instruction SELECT , voir Prise en charge de SQL dans les bases de données locales .

L’exemple suivant décrit l’exécution d’une instruction SELECT pour récupérer des données dans une table nommée « products », en mode d’exécution asynchrone :

var selectStmt:SQLStatement = new SQLStatement(); 
     
// A SQLConnection named "conn" has been created previously 
selectStmt.sqlConnection = conn; 
     
selectStmt.text = "SELECT itemId, itemName, price FROM products"; 
     
selectStmt.addEventListener(SQLEvent.RESULT, resultHandler); 
selectStmt.addEventListener(SQLErrorEvent.ERROR, errorHandler); 
     
selectStmt.execute(); 
     
function resultHandler(event:SQLEvent):void 
{ 
    var result:SQLResult = selectStmt.getResult(); 
     
    var numResults:int = result.data.length; 
    for (var i:int = 0; i < numResults; i++) 
    { 
        var row:Object = result.data[i]; 
        var output:String = "itemId: " + row.itemId; 
        output += "; itemName: " + row.itemName; 
        output += "; price: " + row.price; 
        trace(output); 
    } 
} 
     
function errorHandler(event:SQLErrorEvent):void 
{ 
    // Information about the error is available in the 
    // event.error property, which is an instance of  
    // the SQLError class. 
}

<?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="init()"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.data.SQLConnection; 
            import flash.data.SQLResult; 
            import flash.data.SQLStatement; 
            import flash.errors.SQLError; 
            import flash.events.SQLErrorEvent; 
            import flash.events.SQLEvent; 
             
            private function init():void 
            { 
                var selectStmt:SQLStatement = new SQLStatement(); 
                 
                // A SQLConnection named "conn" has been created previously 
                selectStmt.sqlConnection = conn; 
                 
                selectStmt.text = "SELECT itemId, itemName, price FROM products"; 
                 
                selectStmt.addEventListener(SQLEvent.RESULT, resultHandler); 
                selectStmt.addEventListener(SQLErrorEvent.ERROR, errorHandler); 
                 
                selectStmt.execute(); 
            } 
             
            private function resultHandler(event:SQLEvent):void 
            { 
                var result:SQLResult = selectStmt.getResult(); 
                 
                var numResults:int = result.data.length; 
                for (var i:int = 0; i < numResults; i++) 
                { 
                    var row:Object = result.data[i]; 
                    var output:String = "itemId: " + row.itemId; 
                    output += "; itemName: " + row.itemName; 
                    output += "; price: " + row.price; 
                    trace(output); 
                } 
            } 
             
            private function errorHandler(event:SQLErrorEvent):void 
            { 
                // Information about the error is available in the 
                // event.error property, which is an instance of  
                // the SQLError class. 
            } 
        ]]> 
    </mx:Script> 
</mx:WindowedApplication>

L’exemple suivant décrit l’exécution d’une instruction SELECT pour récupérer des données dans une table nommée « products », en mode d’exécution synchrone :

var selectStmt:SQLStatement = new SQLStatement(); 
     
// A SQLConnection named "conn" has been created previously 
selectStmt.sqlConnection = conn; 
     
selectStmt.text = "SELECT itemId, itemName, price FROM products"; 
     
try 
{ 
    selectStmt.execute(); 
     
    var result:SQLResult = selectStmt.getResult(); 
     
    var numResults:int = result.data.length; 
    for (var i:int = 0; i < numResults; i++) 
    { 
        var row:Object = result.data[i]; 
        var output:String = "itemId: " + row.itemId; 
        output += "; itemName: " + row.itemName; 
        output += "; price: " + row.price; 
        trace(output); 
    } 
} 
catch (error:SQLError) 
{ 
    // Information about the error is available in the 
    // error variable, which is an instance of  
    // the SQLError class. 
}

<?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="init()"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.data.SQLConnection; 
            import flash.data.SQLResult; 
            import flash.data.SQLStatement; 
            import flash.errors.SQLError; 
            import flash.events.SQLErrorEvent; 
            import flash.events.SQLEvent; 
             
            private function init():void 
            { 
                var selectStmt:SQLStatement = new SQLStatement(); 
                 
                // A SQLConnection named "conn" has been created previously 
                selectStmt.sqlConnection = conn; 
                 
                selectStmt.text = "SELECT itemId, itemName, price FROM products"; 
                 
                try 
                { 
                    selectStmt.execute(); 
                     
                    var result:SQLResult = selectStmt.getResult(); 
                     
                    var numResults:int = result.data.length; 
                    for (var i:int = 0; i < numResults; i++) 
                    { 
                        var row:Object = result.data[i]; 
                        var output:String = "itemId: " + row.itemId; 
                        output += "; itemName: " + row.itemName; 
                        output += "; price: " + row.price; 
                        trace(output); 
                    } 
                } 
                catch (error:SQLError) 
                { 
                    // Information about the error is available in the 
                    // error variable, which is an instance of  
                    // the SQLError class. 
                } 
            } 
        ]]> 
    </mx:Script> 
</mx:WindowedApplication>

En mode d’exécution asynchrone, lorsque l’instruction se termine, l’occurrence de SQLStatement déclenche un événement result ( SQLEvent.RESULT ) indiquant que l’instruction s’est exécutée avec succès. Sinon, lorsqu’un objet Responder est transmis en tant qu’argument à la méthode execute() , la fonction du gestionnaire de résultats de l’objet Responder est appelée. En mode d’exécution synchrone, l’exécution s’interrompt jusqu’à la fin de l’opération execute() , puis passe à la ligne de code suivante.

Lorsque l’exécution de l’instruction SELECT est terminée, l’étape suivante consiste à accéder aux données récupérées. Pour récupérer les données du résultat de l’instruction SELECT exécutée, appelez la méthode getResult() de l’objet SQLStatement :

var result:SQLResult = selectStatement.getResult();

La méthode getResult() renvoie un objet SQLResult . La propriété data de l’objet SQLResult est un tableau qui contient les résultats de l’instruction SELECT :

var numResults:int = result.data.length; 
for (var i:int = 0; i < numResults; i++) 
{ 
    // row is an Object representing one row of result data 
    var row:Object = result.data[i]; 
}

Chaque ligne de données du jeu de résultats de l’instruction SELECT devient une occurrence de l’objet dans le tableau data . Cet objet a les propriétés dont les noms correspondent aux noms des colonnes du jeu de résultats. Les propriétés contiennent les valeurs provenant des colonnes du jeu de résultats. Par exemple, supposons qu’une instruction SELECT spécifie un jeu de résultats avec trois colonnes nommées « itemId », « itemName » et « price ». Pour chaque ligne du jeu de résultats, une occurrence d’Object est créée avec les propriétés nommées itemId , itemName et price . Ces propriétés contiennent les valeurs de leurs colonnes respectives.

Le code suivant définit une occurrence de SQLStatement dont le texte est une instruction SELECT . L’instruction récupère les lignes contenant les valeurs des colonnes firstName et lastName de toutes les lignes d’une table nommée employees . Cet exemple utilise le mode d’exécution asynchrone. Lorsque l’exécution est terminée, la méthode selectResult() est appelée, et vous accédez aux lignes de données résultantes à l’aide de la méthode SQLStatement.getResult() et vous les affichez à l’aide de la méthode trace() . Notez que ce code présuppose l’existence d’une occurrence de SQLConnection nommée conn , déjà instanciée et connectée à la base de données. Il suppose également que la table « employees » a déjà été créée et contient des données.

import flash.data.SQLConnection; 
import flash.data.SQLResult; 
import flash.data.SQLStatement; 
import flash.events.SQLErrorEvent; 
import flash.events.SQLEvent; 
     
// ... create and open the SQLConnection instance named conn ... 
     
// create the SQL statement 
var selectStmt:SQLStatement = new SQLStatement(); 
selectStmt.sqlConnection = conn; 
     
// define the SQL text 
var sql:String =  
    "SELECT firstName, lastName " +  
    "FROM employees"; 
selectStmt.text = sql; 
     
// register listeners for the result and error events 
selectStmt.addEventListener(SQLEvent.RESULT, selectResult); 
selectStmt.addEventListener(SQLErrorEvent.ERROR, selectError); 
     
// execute the statement 
selectStmt.execute(); 
     
function selectResult(event:SQLEvent):void 
{ 
    // access the result data 
    var result:SQLResult = selectStmt.getResult(); 
     
    var numRows:int = result.data.length; 
    for (var i:int = 0; i < numRows; i++) 
    { 
        var output:String = ""; 
        for (var columnName:String in result.data[i]) 
        { 
            output += columnName + ": " + result.data[i][columnName] + "; "; 
        } 
        trace("row[" + i.toString() + "]\t", output); 
    } 
} 
     
function selectError(event:SQLErrorEvent):void 
{ 
    trace("Error message:", event.error.message); 
    trace("Details:", event.error.details); 
} 

<?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="init()"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.data.SQLConnection; 
            import flash.data.SQLResult; 
            import flash.data.SQLStatement; 
            import flash.events.SQLErrorEvent; 
            import flash.events.SQLEvent; 
             
            private function init():void 
            { 
                // ... create and open the SQLConnection instance named conn ... 
                 
                // create the SQL statement 
                var selectStmt:SQLStatement = new SQLStatement(); 
                selectStmt.sqlConnection = conn; 
                 
                // define the SQL text 
                var sql:String =  
                    "SELECT firstName, lastName " +  
                    "FROM employees"; 
                selectStmt.text = sql; 
                 
                // register listeners for the result and error events 
                selectStmt.addEventListener(SQLEvent.RESULT, selectResult); 
                selectStmt.addEventListener(SQLErrorEvent.ERROR, selectError); 
                 
                // execute the statement 
                selectStmt.execute(); 
            } 
             
            private function selectResult(event:SQLEvent):void 
            { 
                // access the result data 
                var result:SQLResult = selectStmt.getResult(); 
                 
                var numRows:int = result.data.length; 
                for (var i:int = 0; i < numRows; i++) 
                { 
                    var output:String = ""; 
                    for (var columnName:String in result.data[i]) 
                    { 
                        output += columnName + ": " + result.data[i][columnName] + "; "; 
                    } 
                    trace("row[" + i.toString() + "]\t", output); 
                } 
            } 
             
            private function selectError(event:SQLErrorEvent):void 
            { 
                trace("Error message:", event.error.message); 
                trace("Details:", event.error.details); 
            } 
        ]]> 
    </mx:Script> 
</mx:WindowedApplication>

Le code suivant décrit les mêmes techniques que le précédent, mais avec le mode d’exécution synchrone. L’exemple définit une occurrence de SQLStatement dont le texte est une instruction SELECT . L’instruction récupère les lignes contenant les valeurs des colonnes firstName et lastName de toutes les lignes d’une table nommée employees . Vous accédez aux lignes de données résultantes à l’aide de la méthode SQLStatement.getResult() et vous les affichez à l’aide de la méthode trace() . Notez que ce code présuppose l’existence d’une occurrence de SQLConnection nommée conn , déjà instanciée et connectée à la base de données. Il suppose également que la table « employees » a déjà été créée et contient des données.

import flash.data.SQLConnection; 
import flash.data.SQLResult; 
import flash.data.SQLStatement; 
import flash.errors.SQLError; 
     
// ... create and open the SQLConnection instance named conn ... 
     
// create the SQL statement 
var selectStmt:SQLStatement = new SQLStatement(); 
selectStmt.sqlConnection = conn; 
     
// define the SQL text 
var sql:String =  
    "SELECT firstName, lastName " +  
    "FROM employees"; 
selectStmt.text = sql; 
     
try 
{ 
    // execute the statement 
    selectStmt.execute(); 
     
    // access the result data 
    var result:SQLResult = selectStmt.getResult(); 
     
    var numRows:int = result.data.length; 
    for (var i:int = 0; i < numRows; i++) 
    { 
        var output:String = ""; 
        for (var columnName:String in result.data[i]) 
        { 
            output += columnName + ": " + result.data[i][columnName] + "; "; 
        } 
        trace("row[" + i.toString() + "]\t", output); 
    } 
} 
catch (error:SQLError) 
{ 
    trace("Error message:", error.message); 
    trace("Details:", error.details); 
} 

<?xml version="1.0" encoding="utf-8"?> 
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" creationComplete="init()"> 
    <mx:Script> 
        <![CDATA[ 
            import flash.data.SQLConnection; 
            import flash.data.SQLResult; 
            import flash.data.SQLStatement; 
            import flash.errors.SQLError; 
             
            private function init():void 
            { 
                // ... create and open the SQLConnection instance named conn ... 
                 
                // create the SQL statement 
                var selectStmt:SQLStatement = new SQLStatement(); 
                selectStmt.sqlConnection = conn; 
                 
                // define the SQL text 
                var sql:String =  
                    "SELECT firstName, lastName " +  
                    "FROM employees"; 
                selectStmt.text = sql; 
                 
                try 
                { 
                    // execute the statement 
                    selectStmt.execute(); 
                     
                    // access the result data 
                    var result:SQLResult = selectStmt.getResult(); 
                     
                    var numRows:int = result.data.length; 
                    for (var i:int = 0; i < numRows; i++) 
                    { 
                        var output:String = ""; 
                        for (var columnName:String in result.data[i]) 
                        { 
                            output += columnName + ": "; 
                            output += result.data[i][columnName] + "; "; 
                        } 
                        trace("row[" + i.toString() + "]\t", output); 
                    } 
                } 
                catch (error:SQLError) 
                { 
                    trace("Error message:", error.message); 
                    trace("Details:", error.details); 
                } 
            } 
        ]]> 
    </mx:Script> 
</mx:WindowedApplication>

Par défaut, chaque ligne renvoyée par une instruction SELECT est créée en tant qu’occurrence d’objet dont les noms de propriétés correspondent aux noms de colonnes du jeu de résultats et la valeur de chaque colonne à la valeur de la propriété associée. Toutefois, avant d’exécuter une instruction SQL SELECT , vous pouvez définir la propriété itemClass de l’occurrence de SQLStatement sur une classe. En définissant la propriété itemClass , chaque ligne renvoyée par l’instruction SELECT est créée sous la forme d’une occurrence de la classe désignée. Le moteur d’exécution affecte les valeurs des propriétés aux valeurs des colonnes de résultats en mettant en correspondance les noms de colonnes du jeu de résultats SELECT et les noms des propriétés de la classe itemClass .

Toute classe affectée en tant que propriété itemClass doit avoir un constructeur qui ne requiert aucun paramètre. En outre, la classe doit avoir une seule propriété pour chaque colonne renvoyée par l’instruction SELECT . Le fait qu’une colonne de la liste SELECT ne présente pas de nom de propriété correspondant dans la classe itemClass est considéré comme une erreur.

Par défaut, l’exécution d’une instruction SELECT récupère simultanément toutes les lignes du jeu de résultats. Une fois l’instruction terminée, vous traitez généralement les données récupérées d’une manière ou d’une autre, par exemple en créant des objets ou en affichant les données à l’écran. Si l’instruction renvoie un très grand nombre de lignes, le traitement simultané de toutes les données peut se révéler très exigeant pour l’ordinateur, qui à son tour peut ne pas redessiner l’interface pour l’utilisateur.

Pour améliorer les performances de votre application, vous pouvez demander au moteur d’exécution de ne renvoyer simultanément qu’un nombre spécifique de lignes de résultats. Les données de résultats initiales sont ainsi renvoyées plus rapidement. Vous pouvez également diviser les lignes du résultat en jeux, de sorte que l’interface utilisateur soit mise à jour après le traitement de chaque jeu de lignes. Notez que cette technique n’est pratique qu’en mode d’exécution asynchrone.

Pour récupérer les résultats partiels de SELECT , donnez une valeur au premier paramètre de la méthode SQLStatement.execute() (paramètre prefetch ). Le paramètre prefetch indique le nombre de lignes à récupérer à la première exécution de l’instruction. Lorsque vous appelez la méthode execute() d’une occurrence de SQLStatement , spécifiez la valeur du paramètre prefetch afin que seul ce nombre de lignes soit récupéré :

var stmt:SQLStatement = new SQLStatement(); 
stmt.sqlConnection = conn; 
     
stmt.text = "SELECT ..."; 
     
stmt.addEventListener(SQLEvent.RESULT, selectResult); 
     
stmt.execute(20); // only the first 20 rows (or fewer) are returned 

L’instruction déclenche l’événement result , qui indique que le premier jeu de lignes de résultat est disponible. La propriété data de l’occurrence de SQLResult résultante contient les lignes de données, et sa propriété complete indique s’il reste d’autres lignes de résultat à récupérer. Pour récupérer ces autres lignes, appelez la méthode next() de l’occurrence de SQLStatement. Comme la méthode execute() , le premier paramètre de la méthode next() sert à indiquer le nombre de lignes à récupérer lors du prochain déclenchement de l’événement de résultat.

function selectResult(event:SQLEvent):void 
{ 
    var result:SQLResult = stmt.getResult(); 
    if (result.data != null) 
    { 
        // ... loop through the rows or perform other processing ... 
         
        if (!result.complete) 
        { 
            stmt.next(20); // retrieve the next 20 rows 
        } 
        else 
        { 
            stmt.removeEventListener(SQLEvent.RESULT, selectResult); 
        } 
    } 
} 

L’occurrence de SQLStatement déclenche un événement result chaque fois que la méthode next() renvoie un jeu suivant de lignes de résultat. Par conséquent, la même fonction d’écouteur peut être utilisée pour continuer à traiter les résultats (par des appels à next() ) jusqu’à ce que toutes les lignes aient été récupérées.

Pour plus d’informations, voir les descriptions des méthodes SQLStatement.execute() (description du paramètre prefetch ) et SQLStatement.next() .