Abrufen von Daten aus einer Datenbank

Zum Abrufen vorhandener Daten aus einer Datenbank verwenden Sie eine SQLStatement -Instanz. Weisen Sie der text -Eigenschaft der Instanz die entsprechende SQL- SELECT -Anweisung zu und rufen Sie dann ihre execute() -Methode auf.

Einzelheiten zur Syntax der SELECT -Anweisung finden Sie unter SQL-Unterstützung in lokalen Datenbanken .

Im folgenden Beispiel wird eine SELECT -Anweisung ausgeführt, um Daten aus der Tabelle „products“ abzurufen, wobei der asynchrone Ausführungsmodus verwendet wird:

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>

Im folgenden Beispiel wird eine SELECT -Anweisung ausgeführt, um Daten aus der Tabelle „products“ abzurufen, wobei der synchrone Ausführungsmodus verwendet wird:

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>

Im asynchronen Modus löst die SQLStatement-Instanz nach dem Ausführen der Anweisung ein result -Ereignis aus ( SQLEvent.RESULT ) und zeigt damit an, dass die Anweisung erfolgreich ausgeführt wurde. Alternativ dazu, falls ein Responder -Objekt als Argument an die execute() -Methode übergeben wird, wird die Ergebnisprozedurfunktion des Responder-Objekts aufgerufen. Im synchronen Ausführungsmodus wird die Ausführung angehalten, bis die execute() -Operation abgeschlossen ist, erst danach wird die nächste Codezeile ausgeführt.

Nachdem die Ausführung der SELECT -Anweisung beendet wurde, wird im nächsten Schritt auf die abgerufenen Daten zugegriffen. Sie rufen die Ergebnisdaten nach dem Ausführen einer SELECT -Anweisung ab, indem Sie die getResult() -Methode des SQLStatement-Objekts aufrufen:

var result:SQLResult = selectStatement.getResult();

Die getResult() -Methode gibt ein SQLResult -Objekt zurück. Die data -Eigenschaft des SQLResult-Objekts ist ein Array, das die Ergebnisse der SELECT -Anweisung enthält:

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

Jede Datenzeile im SELECT -Ergebnissatz wird eine Object-Instanz im data -Array. Dieses Objekt verfügt über Eigenschaften, deren Namen mit den Spaltennamen des Ergebnissatzes übereinstimmen. Die Eigenschaften enthalten die Werte aus den Spalten des Ergebnissatzes. Angenommen, eine SELECT -Anweisung ergibt einen Ergebnissatz mit drei Spalten namens „itemId“ (Artikel-ID), „itemName“ (Artikelname) und „price“ (Preis). Für jede Zeile im Ergebnissatz wird eine Object-Instanz erstellt, die über die Eigenschaften itemId , itemName und price verfügt. Diese Eigenschaften enthalten die Werte aus den entsprechenden Spalten.

Im folgenden Codebeispiel wird eine SQLStatement-Instanz definiert, deren Text eine SELECT -Anweisung ist. Die Anweisung ruft Zeilen mit den Werten der Spalten firstName und lastName aus allen Zeilen einer Tabelle mit dem Namen employees ab. In diesem Beispiel wird der asynchrone Ausführungsmodus verwendet. Wenn die Ausführung abgeschlossen ist, wird die selectResult() -Methode aufgerufen und der Zugriff auf die resultierenden Datenzeilen erfolgt über SQLStatement.getResult() . Mit der trace() -Methode werden die Daten angezeigt. Beachten Sie, dass in diesem Beispiel davon ausgegangen wird, dass eine SQLConnection-Instanz mit dem Namen conn bereits instanziiert wurde und eine Verbindung mit der Datenbank besteht. Des Weiteren wird vorausgesetzt, dass die Tabelle „employees“ bereits erstellt und mit Daten gefüllt wurde.

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>

Im folgenden Beispiel wird dieselbe Vorgehensweise wie im vorstehenden Beispiel veranschaulicht, allerdings wird hier der synchrone Ausführungsmodus verwendet. Im Beispiel wird eine SQLStatement -Instanz definiert, deren Text eine SELECT -Anweisung ist. Die Anweisung ruft Zeilen mit den Werten der Spalten firstName und lastName aus allen Zeilen einer Tabelle mit dem Namen employees ab. Auf die resultierenden Datenzeilen wird mit SQLStatement.getResult() zugegriffen; die Anzeige erfolgt über die trace() -Methode. Beachten Sie, dass in diesem Beispiel davon ausgegangen wird, dass eine SQLConnection-Instanz mit dem Namen conn bereits instanziiert wurde und eine Verbindung mit der Datenbank besteht. Des Weiteren wird vorausgesetzt, dass die Tabelle „employees“ bereits erstellt und mit Daten gefüllt wurde.

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>

Standardmäßig wird jede Zeile, die von einer SELECT -Anweisung zurückgegeben wird, als eine Objektinstanz mit Eigenschaften, die nach den Spalten des Ergebnissatzes benannt sind, und mit dem Wert der einzelnen Spalten als Wert der jeweiligen Eigenschaft erstellt. Bevor Sie eine SQL- SELECT -Anweisung ausführen, können Sie jedoch die itemClass -Eigenschaft der SQLStatement -Instanz auf eine Klasse setzen. Indem Sie die itemClass -Eigenschaft festlegen, wird jede von der SELECT -Anweisung zurückgegebene Zeile als eine Instanz der jeweiligen Klasse erstellt. Die Laufzeitumgebung weist den Eigenschaften die Werte der Ergebnisspalten zu, indem die Spaltennamen im SELECT -Ergebnis auf die Namen der Eigenschaften in der itemClass -Klasse gesetzt werden.

Jede Klasse, die als ein itemClass -Eigenschaftenwert zugewiesen wird, muss über einen Konstruktor verfügen, der keine Parameter benötigt. Außerdem muss die Klasse je eine Eigenschaft für jede von der SELECT -Anweisung zurückgegebene Spalte aufweisen. Es gilt als Fehler, wenn es für eine Spalte der Liste SELECT keinen entsprechenden Eigenschaftsnamen in der Klasse itemClass gibt.

Standardmäßig ruft eine SELECT -Anweisung alle Zeilen des Ergebnissatzes gleichzeitig ab. Nachdem die Anweisung abgeschlossen ist, verarbeiten Sie die Daten normalerweise auf die eine oder andere Art; Sie erstellen zum Beispiel Objekte oder zeigen die Daten auf dem Bildschirm an. Wenn die Anweisung eine große Anzahl von Zeilen zurückgibt, kann die gleichzeitige Verarbeitung aller Daten sehr rechenintensiv sein, sodass die Benutzeroberfläche unter Umständen nicht aktualisiert wird.

Sie können die wahrgenommene Leistung Ihrer Anwendung verbessern, indem Sie die Laufzeitumgebung anweisen, jeweils nur eine bestimmte Anzahl von Ergebniszeilen zurückzugeben. Auf diese Weise werden die ersten Ergebnisdaten schneller zurückgegeben. Außerdem können Sie die Ergebniszeilen in Gruppen unterteilen, sodass die Benutzeroberfläche aktualisiert wird, nachdem die einzelnen Gruppen von Zeilen verarbeitet wurden. Beachten Sie, dass sich dieses Verfahren nur für den asynchronen Ausführungsmodus eignet.

Um SELECT -Ergebnisse in Teilen abzurufen, geben Sie einen Wert für den ersten Parameter (den prefetch -Parameter) der SQLStatement.execute() -Methode an. Der prefetch -Parameter gibt die Anzahl der Zeilen an, die beim ersten Ausführen der Anweisung abgerufen werden sollen. Wenn Sie für eine SQLStatement -Instanz die execute() -Methode aufrufen, geben Sie einen Wert für den prefetch -Parameter an, um nur diese Menge an Zeilen abzurufen:

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 

Die Anweisung löst das result -Ereignis aus und zeigt damit an, dass die erste Gruppe von Ergebniszeilen verfügbar ist. Die resultierende SQLResult -Instanz hat die data -Eigenschaft, die die Datenzeilen enthält. Die complete -Eigenschaft gibt an, ob noch weitere abzurufende Ergebniszeilen vorhanden sind. Um weitere Ergebniszeilen abzurufen, rufen Sie die next() -Methode der SQLStatement-Instanz auf. Wie die execute() -Methode wird der erste Parameter der next() -Methode verwendet, um anzuzeigen, wie viele Zeilen beim nächsten Auslösen des result-Ereignisses abgerufen werden sollen.

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

Die SQLStatement-Instanz löst ein result -Ereignis aus, wenn die next() -Methode eine folgende Gruppe von Ergebniszeilen zurückgibt. Deswegen kann dieselbe Listener-Funktion verwendet werden, um die Verarbeitung von Ergebnissen (aus next() -Aufrufen) fortzusetzen, bis alle Zeilen abgerufen wurden.

Weitere Informationen finden Sie in den Beschreibungen der SQLStatement.execute() -Methode (Beschreibung des prefetch -Parameters) und der SQLStatement.next() -Methode.