Recuperação de dados de um banco de dados

Para recuperar dados existentes de um banco de dados, use uma instância de SQLStatement . Atribua a instrução SQL SELECT adequada à propriedade text da ocorrência e, depois, chame o método execute() correspondente.

Para obter mais detalhes sobre a sintaxe da instrução SELECT , consulte Suporte SQL em bancos de dados locais .

O exemplo abaixo mostra como executar uma instrução SELECT para recuperar dados de uma tabela chamada “products” usando o modo de execução assíncrona:

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>

O exemplo a seguir demonstra a execução de uma instrução SELECT para recuperar dados de uma tabela chamada “produtos”, usando o modo de execução síncrona:

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>

No modo de execução assíncrona, quando a execução da instrução é concluída, a ocorrência de SQLStatement despacha um evento result ( SQLEvent.RESULT ) que indica que a instrução foi executada com sucesso. Como alternativa, se um objeto Responder for passado como argumento no método de execute() , a função do manipulador resultante do objeto Responder será chamada. No modo de execução síncrona, a execução pausa até que a operação execute() seja concluída e, em seguida, prossegue com a próxima linha de código.

Uma vez concluída a execução da instrução SELECT , a próxima etapa é acessar os dados que foram recuperados. Acesse os dados de resultados com a execução de uma instrução SELECT , chamando o método getResult() do objeto SQLStatement:

var result:SQLResult = selectStatement.getResult();

O método getResult() gera um objeto SQLResult . A propriedade data do objeto SQLResult é um Array que contém os resultados da instrução 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 linha de dados no conjunto de resultados de SELECT se transforma em uma instância do Objeto contida no Array data . Esse objeto tem propriedades cujos nomes correspondem aos nomes de coluna do conjunto de resultados. As propriedades contêm os valores das colunas do conjunto de resultados. Por exemplo, suponha que uma instrução SELECT especifique um conjunto de resultados com três colunas chamadas “itemId”, “itemName” e “price”. Para cada linha do conjunto de resultados, é criada uma ocorrência de Object com propriedades chamadas itemId , itemName e price . Essas propriedades contêm os valores das respectivas colunas.

A listagem de código a seguir define uma ocorrência de SQLStatement cujo texto é uma instrução SELECT . A instrução recupera linhas que contêm os valores de coluna firstName e lastName de todas as linhas de uma tabela denominada employees . Este exemplo utiliza o modo de execução assíncrona. Quando a execução é concluída, o método selectResult() é chamado, e as linhas de dados resultantes são acessadas usando SQLStatement.getResult() e exibidas usando o método trace() . Observe que esta listagem presume que existe uma ocorrência de SQLConnection denominada conn que já foi instanciada e já está conectada ao banco de dados. Ela também presume que a tabela “employees” já foi criada e preenchida com dados.

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>

A listagem de código a seguir demonstra as mesmas técnicas que a anterior, mas usa o modo de execução síncrona. O exemplo define uma instância de SQLStatement cujo texto é uma instrução SELECT . A instrução recupera linhas que contêm os valores de coluna firstName e lastName de todas as linhas de uma tabela denominada employees . As linhas de dados resultantes são acessadas usando SQLStatement.getResult() e exibidas usando o método trace() . Observe que esta listagem presume que existe uma ocorrência de SQLConnection denominada conn que já foi instanciada e já está conectada ao banco de dados. Ela também presume que a tabela “employees” já foi criada e preenchida com dados.

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>

Por padrão, cada linha retornada por uma instrução SELECT é criada como uma ocorrência de Object com propriedades nomeadas para os nomes de coluna do conjunto de resultados e com o valor de cada coluna como o valor da propriedade associada. Porém, antes de executar uma instrução SQL SELECT , você pode definir a propriedade itemClass da ocorrência de SQLStatement para uma classe. Quando é definida a propriedade itemClass , cada linha retornada pela instrução SELECT é criada como ocorrência da classe designada. O tempo de execução atribui valores de coluna resultantes a valores de propriedade comparando os nomes de coluna do conjunto de resultados de SELECT com os nomes das propriedades da classe itemClass .

Qualquer classe designada como um valor da propriedade itemClass deve ter um construtor que não exija parâmetros. Além disso, a classe deve ter uma única propriedade para cada coluna retornada pela instrução SELECT . Será considerado um erro se uma coluna da lista SELECT não tiver um nome de propriedade correspondente na classe itemClass .

Por padrão, a execução de uma instrução SELECT recupera todas as linhas do conjunto de resultados de uma só vez. Uma vez concluída a instrução, geralmente você processa os dados recuperados de alguma forma; por exemplo, criando objetos ou exibindo os dados na tela. Se a instrução retornar muitas linhas, processar todos os dados de uma só vez pode exigir bastante do computador, o que, por sua vez, faz com que a interface do usuário não se redesenhe.

É possível melhorar o desempenho percebido do aplicativo instruindo o tempo de execução a retornar um determinado número de linhas de resultado por vez. Isso faz com que os dados resultantes iniciais sejam retornados mais rapidamente. Isso também permite dividir as linhas de resultados em conjuntos, para que a interface de usuário seja atualizada depois do processamento de cada conjunto de linhas. Só é prático usar esta técnica no modo de execução assíncrona.

Para recuperar os resultados de SELECT em partes, especifique um valor para o primeiro parâmetro do método SQLStatement.execute() (o parâmetro prefetch ). O parâmetro prefetch indica o número de linhas a serem recuperadas na primeira vez que a instrução é executada. Quando chamar o método execute() de uma instância de SQLStatement , especifique um valor de parâmetro prefetch e somente essas linhas serão recuperadas:

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 

A instrução despacha o evento result , indicando que o primeiro conjunto de linhas de resultado está disponível. A propriedade data da instância de SQLResult resultante contém as linhas de dados, e sua propriedade complete indica se existem mais linhas de resultado a serem recuperadas. Para recuperar linhas de resultados adicionais, chame o método next() da ocorrência de SQLStatement. Assim como o método execute() , o primeiro parâmetro do método next() é usado para indicar quantas linhas deverão ser recuperadas na próxima vez que o evento result for despachado.

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

SQLStatement despacha um evento result sempre que o método next() retorna um conjunto subsequente de linhas de resultado. Consequentemente, a mesma função de ouvinte pode ser usada para continuar processando os resultados (de chamadas de next() ) até que todas as linhas sejam recuperadas.

Para obter mais informações, consulte as descrições do método SQLStatement.execute() (a descrição do parâmetro prefetch ) e o método SQLStatement.next() .