Gegevens ophalen uit een database

Voor het ophalen van bestaande gegevens uit een database gebruikt u een SQLStatement -instantie. Wijs de juiste SQL-instructie SELECT toe aan de eigenschap text van de instantie en roep vervolgens de methode execute() aan.

Voor gedetailleerde informatie over de syntaxis van de instructie SELECT gaat u naar SQL-ondersteuning in lokale databases .

Het volgende voorbeeld demonstreert de uitvoering van een SELECT -instructie om gegevens op te halen uit een tabel met de naam 'products' met de asynchrone uitvoeringsmodus:

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>

Het volgende voorbeeld demonstreert de uitvoering van een SELECT -instructie om gegevens op te halen uit een tabel met de naam 'products' met de synchrone uitvoeringsmodus:

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>

Nadat in de asynchrone uitvoeringsmodus de uitvoering van de instructie is voltooid, verzendt de SQLStatement-instantie de gebeurtenis result ( SQLEvent.RESULT ) om aan te geven dat de instructie correct is uitgevoerd. Als een Responder -object echter als argument wordt doorgegeven aan de methode execute() , wordt de resultaathandlerfunctie van het Responder-object aangeroepen. In de synchrone uitvoeringsmodus wordt de uitvoering onderbroken tot de bewerking execute() is voltooid. Daarna gaat de uitvoering verder vanaf de volgende coderegel.

Nadat de uitvoering van de instructie SELECT is voltooid, kunnen de opgehaalde gegevens worden benaderd. Na het uitvoeren van een SELECT -instructie kunt u de resulterende gegevens ophalen door de methode getResult() van het SQLStatement-object aan te roepen:

var result:SQLResult = selectStatement.getResult();

De methode getResult() retourneert een SQLResult -object. De eigenschap data van het SQLResult-object is een array die de resultaten van de instructie SELECT bevat:

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]; 
}

Elke gegevensrij in de resultaatset van SELECT wordt een Object-instantie die is opgenomen in de array data . Het desbetreffende object heeft eigenschappen waarvan de naam overeenkomt met de naam van de kolommen in de resultaatset. De eigenschappen bevatten de waarden uit de kolommen in de resultaatset. De instructie SELECT geeft bijvoorbeeld een resultaatset met drie kolommen op: “itemId”, “itemName” en “price”. Voor elke rij van de resultaatset wordt een Object-instantie gecreëerd met de eigenschapnamen itemId , itemName en price . Deze eigenschappen bevatten de waarden uit de overeenkomstige kolommen.

De volgende code definieert een SQLStatement-instantie waarvan de tekst een SELECT -instructie is. De instructie haalt rijen op die de waarden uit de kolommen firstName lastName bevatten op alle rijen uit de tabel employees . Dit voorbeeld gebruikt de asynchrone uitvoeringsmodus. Nadat de uitvoering is voltooid, wordt de methode selectResult() opgeroepen en worden de resultaatrijen met gegevens benaderd met SQLStatement.getResult() en weergegeven via de methode trace() . Let op: deze code gaat ervan uit dat een SQLConnection-instantie met de naam conn al is gedefinieerd en met de database is verbonden. De code gaat er ook van uit dat de tabel “employees” al is gecreëerd en gegevens bevat.

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>

De volgende code illustreert dezelfde technieken als de vorige code maar in de synchrone uitvoeringsmodus. Het voorbeeld definieert een SQLStatement -instantie waarvan de tekst een SELECT -instructie is. De instructie haalt rijen op met de kolomwaarden firstName en lastName van alle rijen uit de tabel employees . De resultaatrijen met gegevens worden benaderd met SQLStatement.getResult() en weergegeven via de methode trace() . Let op: deze code gaat ervan uit dat een SQLConnection-instantie met de naam conn al is gedefinieerd en met de database is verbonden. De code gaat er ook van uit dat de tabel “employees” al is gecreëerd en gegevens bevat.

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>

Elke rij die het resultaat is van een SELECT -instructie, wordt standaard gegenereerd als een Object-instantie met eigenschappen die zijn benoemd volgens de naam van de kolommen in de resultaatset en met de waarde van elke kolom als de waarde van de overeenkomstige eigenschap. Voordat u echter de SQL-instructie SELECT uitvoert, kunt u de eigenschap itemClass van de SQLStatement -instantie instellen op een klasse. Als u de eigenschap itemClass instelt, wordt elke rij die het resultaat is van de instructie SELECT gegenereerd als een instantie van de opgegeven klasse. De runtime wijst de waarden van resultaatkolommen aan eigenschapwaarden toe door de naam van de kolommen in de resultaatset van SELECT te baseren op de naam van de eigenschappen in de klasse itemClass .

Elke klasse die is toegewezen als een itemClass -eigenschapwaarde, moet een constructor hebben waarvoor geen parameters nodig zijn. Bovendien moet de klasse één eigenschap hebben voor elke kolom die het resultaat is van de instructie SELECT . Als een kolom in de lijst SELECT geen gekoppelde eigenschapnaam in de klasse itemClass heeft, wordt dit als een fout beschouwd.

Bij de uitvoering van een SELECT -instructie worden standaard alle rijen van de resultaatset tegelijk opgehaald. Nadat de instructie is voltooid, verwerkt u doorgaans de opgehaalde gegevens, bijvoorbeeld door objecten te creëren of de gegevens op het scherm weer te geven. Als de instructie een groot aantal rijen genereert, kan het verwerken van alle gegevens tegelijk een grote belasting voor de computer zijn, waardoor de gebruikersinterface niet wordt vernieuwd.

U kunt de zichtbare prestaties van uw toepassing verbeteren door te zorgen dat de runtime slechts een bepaald aantal resultaatrijen tegelijk weergeeft. Hierdoor worden de initiële resultaatgegevens sneller weergegeven. Op deze manier kunt u ook de resultaatrijen in sets verdelen zodat de gebruikersinterface wordt bijgewerkt telkens wanneer een set rijen is verwerkt. Let op: deze techniek is alleen nuttig in asynchrone uitvoeringsmodus.

Als u de resultaten van SELECT in delen wilt ophalen, geeft u een waarde op voor de eerste parameter van de methode SQLStatement.execute() (de parameter prefetch ). De parameter prefetch geeft het aantal rijen aan dat u wilt ophalen de eerste keer dat de instructie wordt uitgevoerd. Wanneer u de methode execute() van een SQLStatement -instantie aanroept, geeft u een prefetch -parameterwaarde op, waarna alleen dat aantal rijen wordt opgehaald:

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 

De instructie verzendt de gebeurtenis result wanneer de eerste set resultaatrijen beschikbaar is. De resulterende eigenschap data van de SQLResult -instantie bevat de gegevensrijen en de eigenschap complete ervan geeft aan of er nog op te halen resultaatrijen resteren. Als u de volgende set resultaatrijen wilt ophalen, roept u de methode next() van de SQLStatement-instantie op. Net als bij de methode execute() wordt de eerste parameter van de methode next() gebruikt om aan te geven hoeveel rijen moeten worden opgehaald de volgende keer dat de gebeurtenis result wordt verzonden.

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); 
        } 
    } 
} 

De SQLStatement verzendt de gebeurtenis result elke keer dat de methode next() een volgende set resultaatrijen weergeeft. Dit betekent dat dezelfde listenerfunctie kan worden gebruikt om verder te gaan met het verwerken van resultaten (op basis van next() -oproepen) tot alle rijen zijn opgehaald.

Zie de beschrijvingen voor de methode SQLStatement.execute() (de prefetch -parameterbeschrijving) en de methode SQLStatement.next() voor meer informatie