Faz algum tempo, resolvi desenvolver pequenas aplicações AIR com SQLite. Por quê?

• É Software Livre/domínio público e Multiplataforma;
• É um mecanismo de armazenamento seguro com transações ACID;
• Não necessita de instalação, configuração ou administração;
• Implementa a maioria do SQL92;
• Permite guardar o banco de dados em um único arquivo;
• Suporta bases de dados acima de 2 terabytes;
• Sem dependências externas;

Para saber mais acesse: http://pt.wikipedia.org/wiki/SQLite.

Mas, o motivo principal, é que o AIR  possui acesso nativo ao SQLite, ou seja, não é necessário utilizar nenhum componente externo, apenas classes próprias do FLEX. Esse é o objetivo deste artigo, apresentar essas classes, e suas respectivas funções dentro do processo de conexão. Para um próximo artigo, que já estou escrevendo em paralelo, pretendo mostrar como customizar seu uso utilizando OOP.
   
Dentro de uma aplicação FLEX AIR, vamos instanciar as classes responsáveis pelas operações SQLite:

//---------------------------------------------------------------
//
// Variáveis
//
//---------------------------------------------------------------
/**
 * Armazena/cria o arquivo SQLite. 
 */
private var file:File;

/**
 * Instância da classe responsável pela conexão.
 */
private var conn:SQLConnection = new SQLConnection();

/**
* Instância da classe responsável por executar as instruções
* SQL.
 */
private var sqlStatment:SQLStatement = new SQLStatement();

Acima estão as 3 classes necessárias criação, conexão e instruções SQL:

File:  Essa classe representa um caminho para um determinado arquivo ou diretório, caso não exista, ela pode criá-lo. 

SQLConnection: É a classe responsável por abrir/estabelecer uma conexão com o arquivo SQLite.

SQLStatement: Executa instruções SQL (INSERT, DELETE, UPDATE etc…).

Vamos incluir duas funções que serão responsáveis por criar a base de dados, uma simples tabela e incluir alguns dados:

/**
 * Função exemplo para criação de uma base de dados SQLite.
 */
private function initSQLite():void {

// Cria o arquivo SQLite.
	file =File.documentsDirectory.resolvePath("exemplo.sqlite");

	// Cria a conexão.
	sqlStatment.sqlConnection = conn;

	// Abre a conexão.
	conn.open(file);
}

/**
 * Função exemplo para criação e inclusão de dados em uma tabela SQLite.
 */
private function createTable():void {

	// Chama a função responsável pela inicialização do SQLite.
	initSQLite();

	// Estrutura da nossa uma tabela (cadastro), para a base de 
	// dados 'exemplo.sqlite'.
	sqlStatment.text =  "CREATE TABLE IF NOT EXISTS cadastro ( " +
				  "	idCadastro  INTEGER  PRIMARY KEY  AUTOINCREMENT, "+
				  "	nome		VARCHAR(200)    NOT NULL, " + 
				  "	idade		INTEGER	    NOT NULL )";

	// Cria a tabela 'cadastro'.
	sqlStatment.execute();

	// Query para inclusão de dados na tabela 'cadastro'.
	sqlStatment.text =  "INSERT INTO cadastro ( " + 
				  "	nome, " + 
				  "	idade " + 
				  ") VALUES ( " + 
				  "	'João Silva', " +
				  "	'39') ";

	// Executa a inclusão dos dados.
	sqlStatment.execute();
}

Vamos explanar os códigos acima.

Na linha “file = File.documentsDirectory.resolvePath(“exemplo.sqlite”)” localizamos/criamos o arquivo da base de dados SQLite.  Na linha “sqlStatment.sqlConnection = conn” é criado o vínculo de conexão para a classe responsável por executar as instruções SQL. Na linha “conn.open(file)”, abre-se a conexão com o arquivo SQLite selecionado/criado na  linha “file = File.documentsDirectory.resolvePath(“exemplo.sqlite”)”.

No segundo método (createTable()) iniciamos as instruções SQL para criação de uma tabela exemplo e, depois de criada, incluímos alguns dados.  Isso é possível graças a propriedade “text()”  que armazena uma instrução SQL para ser executada pelo método “execute()”, ou seja, para cada instrução SQL passada a propriedade “text()” é necessário executar o método “execute()”.

Mas como eu recupero os dados de uma tabela SQLite?   

Bem, é tão simples quanto incluí-los.

Vamos criar outro método, de exemplo, onde recuperaremos os dados que incluímos na tabela “cadastro”:

/**
 * Função exemplo para recuperar um cadastro contido na tabela exemplo 'cadastro'.
 * @param int idCadastro Código do cadastro.
 */
private function getData(idCadastro:int):Array {

// Chama o método responsável pela conexão.
	initSQLite();

	// Query para a seleção de um determinado cadastro.
	sqlStatment.text = "SELECT * FROM cadastro WHERE idCadastro = :idCadastro";

	// Substiui o código do cadastro.			
	sqlStatment.parameters[':idCadastro'] = idCadastro;

	// Executa a seleção.			
	sqlStatment.execute();

	// Retorna o resultado da consulta.			
	return sqlStatment.getResult().data;

}

E na função acima temos:

‘initSQLite();’: Chama a função responsável pela conexão à base de dados SQLite.

‘sqlStatment.text = “SELECT * FROM cadastro WHERE idCadastro = :idCadastro”;’: Como já comentado anteriormente, a propriedade ‘text()’ armazena a instrução SQLite. A diferença é a variável ‘:idCadastro’ que será substituída na linha seguinte.

‘sqlStatment.parameters[‘:idCadastro’] = idCadastro;’: O ‘parameters’ é uma propriedade com array associativas que “varre” uma determinada instrução ‘SQLStatement.text’ substituindo as variáveis pelos valores indicados. Essas variáveis podem ser indicadas através dos símbolos “:” e “@”.

‘sqlStatment.execute();’: Como já vimos anteriormente, executa uma instrução SQL contida na propriedade ‘text()’.

‘return sqlStatment.getResult().data;’: O ‘getResult()’ contém todos os resultados da execução do método ‘execute()’. Sendo assim, se estiver executando um ‘SELECT’ na array associativa ‘data’ estarão todos os valores retornados.

Bem, pessoal, é isso aí, meu primeiro artigo, e estou muito feliz em colaborar com um site que já me ajudou muito. Espero que seja útil, e até a segunda parte, onde, como já citado anteriormente, vamos aprender um pouco mais sobre as classes que compõe o processo e customizar o uso das classes utilizando OOP.

[]’s