Recuperación de datos de una base de datos

Para recuperar datos existentes de una base de datos, se utiliza una instancia de SQLStatement . Asigne la declaración SELECT a la propiedad text de la instancia y llame al método execute .

Para conocer la sintaxis de la declaración SELECT , consulte Compatibilidad de SQL en bases de datos locales .

En el siguiente ejemplo se muestra la ejecución de una declaración SELECT para recuperar datos de la tabla denominada "products", utilizando el modo de ejecución asíncrono:

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>

En el siguiente ejemplo se muestra la ejecución de una declaración SELECT para recuperar datos de la tabla denominada "products", utilizando el modo de ejecución sincrónica:

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 el modo de ejecución asíncrono, cuando se termina de ejecutar la declaración, la instancia SQLStatement distribuye un evento result ( SQLEvent.RESULT ) que indica que la declaración se ejecutó correctamente. Como alternativa, si se transmite un objeto Responder como argumento al método execute() , se llama a la función de control de resultados del objeto Responder. En el modo de ejecución sincrónico, la ejecución hace una pausa hasta que la operación execute() termina, y continúa en la siguiente línea de código.

Una vez que la declaración SELECT se ha terminado de ejecutar, el siguiente paso es acceder a los datos que se recuperaron. Los datos de resultados se recuperan de la ejecución de una declaración SELECT llamando al método getResult() del objeto SQLStatement:

var result:SQLResult = selectStatement.getResult();

El método getResult() devuelve un objeto SQLResult . La propiedad data del objeto SQLResult es un conjunto que contiene los resultados de la declaración 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]; 
}

Cada fila de datos del resultado SELECT se convierte en una instancia de Object incluida en el conjunto data . Dicho objeto tiene propiedades cuyos nombres coinciden con los nombres de columna del conjunto de resultados. Las propiedades contienen los valores de las columnas del conjunto de resultados. Por ejemplo, supongamos que una declaración SELECT especifica un conjunto de resultados con tres columnas llamadas “itemId,” “itemName” y “price.” Para cada fila en el conjunto de resultados, se crea una instancia Object con propiedades denominadas itemId , itemName y price . Esas propiedades contienen los valores de sus respectivas columnas.

El siguiente ejemplo de código define una instancia SQLStatement cuyo texto es una instrucción SELECT . La declaración recupera las filas que contiene los valores de la columna firstName y lastName de todas las filas de una tabla denominada employees . Este ejemplo utiliza el modo de ejecución asíncrono. Cuando se termina la ejecución, se llama al método selectResult() , y se accede a las filas de datos resultantes usando SQLStatement.getResult() y se muestran usando el método trace() . Observe que este código supone que existe una instancia de SQLConnection denominada conn que ya ha sido creada y ya está conectada a una base de datos. Asimismo, supone que la tabla “employees” ya ha sido creada y llenada con datos.

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>

El siguiente ejemplo de código demuestra las mismas técnicas como la anterior pero utiliza el modo de ejecución sincrónico. El ejemplo define una instancia de SQLStatement cuyo texto es una instancia SELECT . La declaración recupera las filas que contiene los valores de la columna firstName y lastName de todas las filas de una tabla denominada employees . Se accede a las filas de datos resultantes utilizando SQLStatement.getResult() y se muestran usando el método trace() . Observe que este código supone que existe una instancia de SQLConnection denominada conn que ya ha sido creada y ya está conectada a una base de datos. Asimismo, supone que la tabla “employees” ya ha sido creada y llenada con datos.

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>

De forma predeterminada, cada fila devuelta por una declaración SELECT se crea como una instancia Object con propiedades denominadas para los nombres de columna del conjunto de resultados y con el valor de cada columna como el valor de la propiedad asociada. Sin embargo, antes de ejecutar una declaración SELECT SQL puede definir la propiedad itemClass de la instancia SQLStatement a una clase. http://help.adobe.com/es_ES/Flash/CS5/AS3LR/flash/data/SQLStatement.html Al configurar la propiedad itemClass , cada fila devuelta por la declaración SELECT se crea como una instancia de la clase designada. El motor de ejecución asigna valores de columna de resultados a los valores de la propiedad haciendo coincidir los nombres de columnas en el conjunto de resultados SELECT con los nombres de las propiedades en la clase itemClass .

Cualquier clase asignada como un valor de propiedad itemClass debe tener un constructor que no requiere ningún parámetro. Además, la clase debe tener una sola propiedad para cada columna devuelta por la declaración SELECT . Se considera un error si una columna en la lista SELECT no tiene un nombre de propiedad coincidente en la clase itemClass .

De forma predeterminada, una ejecución de la declaración SELECT recupera las filas del conjunto de resultados de una sola vez. Una vez completada la declaración, generalmente se procesan los datos recuperados de alguna manera, como la creación de objetos o mostrando los datos en pantalla. Si la declaración devuelve un gran número de filas, el procesamiento de todos los datos a la vez puede ser exigente para el equipo, que a su vez hará que la interfaz de usuario no se vuelva a dibujar.

Puede mejorar el rendimiento aparente de la aplicación indicando al motor de ejecución que devuelva un número específico de filas de resultados a la vez. Al proceder de esta manera permite que los datos del resultado inicial se devuelvan con más rapidez. También permite dividir las filas de resultados en conjuntos, para que la interfaz de usuario se actualice después que se procese cada conjunto de filas. Observe que solo es práctico utilizar esta técnica en el modo de ejecución asíncrono.

Para recuperar los resultados SELECT en partes, especifique un valor para el primer parámetro (el parámetro prefetch ) del método SQLStatement.execute() . El parámetro prefetch indica el número de filas que se deben recuperar la primera vez que se ejecuta la declaración. Cuando llame al método execute() de la instancia de SQLStatement , especifique un valor de parámetro prefetch y solo se recupera dicho número de filas:

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 

La declaración distribuye el evento result , indicando que está disponible el primer conjunto de filas de resultados. La propiedad data de la instancia de SQLResult resultante contiene las filas de datos y la propiedad complete indica si hay filas de resultados adicionales para recuperar. Para recuperar filas de resultados adicionales, llame al método next() de la instancia SQLStatement. Al igual que el método execute() , se usa el primer parámetro del método next() para indicar la cantidad de filas que se recuperan la próxima vez que se distribuye el evento result.

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

El SQLStatement distribuye un evento result cada vez que el método next() devuelve un conjunto posterior de filas de resultados. En consecuencia, la misma función del detector se puede usar para continuar procesando los resultados (de las llamadas a next() ) hasta que se hayan recuperado todas las filas.

Para obtener más información, consulte las descripciones en la referencia de para el método SQLStatement.execute() (la descripción del parámetro prefetch ) y el método SQLStatement.next() .