flash SQLite包装类

aa0660

[转]http://www.flepstudio.com/flash/actionscript3/documentation/html/com_flepstudio_air_sqlite_SQLite.html

package com.flepstudio.air.sqlite
{
import flash.data.*;
import flash.events.*;
import flash.filesystem.File;
import flash.display.MovieClip;
[Event(name="open", type="flash.events.SQLEvent")]
[Event(name="close", type="flash.events.SQLEvent")]
[Event(name="error", type="flash.events.SQLErrorEvent")]
/**
* SQLite is a ValueObject for the FlepStudio API.
* This class manages the SQLite database in Adobe Air
*
* @author Filippo Lughi
* @version Actionscript 3.0
*/
public class SQLite extends MovieClip
{
private var _connection:SQLConnection;
private var _databaseFileName:String;   
private var _databaseFile:File;
private var _statement:SQLStatement;
public function SQLite()
{
addEventListener(Event.ADDED_TO_STAGE,init);
}
private function init(evt:Event):void
{
removeEventListener(Event.ADDED_TO_STAGE,init);
trace("I am ready to dispatch events to my parent/root");
}

/**
* get the database file name
*/
[Bindable]
public function get file_name():String
{
return _databaseFileName;
}

/**
* set the database file name
*/
public function set file_name(s:String):void
{
_databaseFileName=s;
}

/**
* get the database file
*/
public function get file():File
{
return _databaseFile;
}

/**
* set the database file
*/
public function set file(f:File):void
{
_databaseFile=File.documentsDirectory.resolvePath(file_name);
}

/**
* get the database connection
*/
[Bindable]
public function get connection():SQLConnection
{
return _connection;
}        

/**
* set the database connection
*/
public function set connection(conn:SQLConnection):void
{
_connection=conn;
}

/**
* get the statement
*/
[Bindable]
public function get statement():SQLStatement
{
return _statement;
}        

/**
* set the statement
*/
public function set statement(s:SQLStatement):void
{
_statement=s;
}

/**
* connect to database
*/
public function connect():void
{
_connection=new SQLConnection();
_connection.addEventListener(SQLEvent.OPEN,onDatabaseOpen);
_connection.addEventListener(SQLEvent.CLOSE,onDatabaseClose);
_connection.addEventListener(SQLErrorEvent.ERROR,onDatabaseError);
_connection.openAsync(_databaseFile,SQLMode.READ);
}

/**
* create the database
*/
public function create():void
{
_connection=new SQLConnection();
_connection.addEventListener(SQLEvent.OPEN,onDatabaseCreated);
_connection.addEventListener(SQLEvent.CLOSE,onDatabaseClose);
_connection.addEventListener(SQLErrorEvent.ERROR,onDatabaseError);
_connection.openAsync(_databaseFile,SQLMode.CREATE);
}

/**
* populate the database
*/
public function execute(query:String=null):void
{
_statement=new SQLStatement();
_statement.sqlConnection=_connection;
_statement.text=query;
_statement.addEventListener(SQLEvent.RESULT,onQueryResult);
_statement.addEventListener(SQLErrorEvent.ERROR,onQueryError);
_statement.execute();
}

/**
* disconnect to database
*/
public function close():void
{
_connection.close();
}

/**
* dispatch when query has been done
*/
private function onQueryResult(evt:SQLEvent):void
{
trace(_statement.getResult().data);
dispatchEvent(evt);
}

/**
* dispatch if a query error occurs
*/
private function onQueryError(evt:SQLErrorEvent):void
{
dispatchEvent(evt);
}

/**
* dispatch when database is open
*/
private function onDatabaseOpen(evt:SQLEvent):void
{
_connection.removeEventListener(SQLEvent.OPEN,onDatabaseOpen);
dispatchEvent(evt);
}

/**
* dispatch when database is created
*/
private function onDatabaseCreated(evt:SQLEvent):void
{
_connection.removeEventListener(SQLEvent.OPEN,onDatabaseCreated);
dispatchEvent(new SQLEvent("created"));
}

/**
* dispatch when database is close
*/
private function onDatabaseClose(evt:SQLEvent):void
{
_connection.removeEventListener(SQLEvent.CLOSE,onDatabaseClose);
dispatchEvent(evt);
}

/**
* dispatch a database error
*/
private function onDatabaseError(evt:SQLErrorEvent):void
{
_connection.removeEventListener(SQLErrorEvent.ERROR,onDatabaseError);
dispatchEvent(evt);
}
}
}