c# pdf diff : Excel pdf bookmarks application SDK utility azure winforms html visual studio air_htmldevguide23-part468

225
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
For more information, see the descriptions for the 
SQLStatement.execute()
method (the 
prefetch
parameter 
description) and the 
SQLStatement.next()
method.
Inserting data
Adobe AIR 1.0 and later
Adding data to a database involves executing a SQL 
INSERT
statement. Once the statement has finished executing, you 
can access the primary key for the newly inserted row if the key was generated by the database.
Executing an INSERT statement
Adobe AIR 1.0 and later
To add data to a table in a database, you create and execute a SQLStatement instance whose text is a SQL 
INSERT
statement.
The following example uses a SQLStatement instance to add a row of data to the already-existing employees table. This 
example demonstrates inserting data using asynchronous execution mode. Note that this listing assumes that there is 
a SQLConnection instance named 
conn
that has already been instantiated and is already connected to a database. It 
also assumes that the “employees” table has already been created.
// Include AIRAliases.js to use air.* shortcuts  
// ... create and open the SQLConnection instance named conn ...  
// create the SQL statement  
var insertStmt = new air.SQLStatement();  
insertStmt.sqlConnection = conn;  
// define the SQL text  
var sql =   
"INSERT INTO employees (firstName, lastName, salary) " +   
"VALUES ('Bob', 'Smith', 8000)";  
insertStmt.text = sql;  
// register listeners for the result and failure (status) events  
insertStmt.addEventListener(air.SQLEvent.RESULT, insertResult);  
insertStmt.addEventListener(air.SQLErrorEvent.ERROR, insertError);  
// execute the statement  
insertStmt.execute();  
function insertResult(event)  
{  
air.trace("INSERT statement succeeded");  
}  
function insertError(event)  
{  
air.trace("Error message:", event.error.message);  
air.trace("Details:", event.error.details);  
}
Excel pdf bookmarks - add, remove, update PDF bookmarks in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your C# Project with Rapid PDF Internal Navigation Via Bookmark and Outline
bookmark template pdf; create bookmark pdf file
Excel pdf bookmarks - VB.NET PDF bookmark library: add, remove, update PDF bookmarks in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Your VB.NET Project with Rapid PDF Internal Navigation Via Bookmark and Outline
excel pdf bookmarks; bookmark a pdf file
226
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
The following example adds a row of data to the already-existing employees table, using synchronous execution mode. 
Note that this listing assumes that there is a SQLConnection instance named 
conn
that has already been instantiated 
and is already connected to a database. It also assumes that the “employees” table has already been created.
// Include AIRAliases.js to use air.* shortcuts  
// ... create and open the SQLConnection instance named conn ...  
// create the SQL statement  
var insertStmt = new air.SQLStatement();  
insertStmt.sqlConnection = conn;  
// define the SQL text  
var sql =   
"INSERT INTO employees (firstName, lastName, salary) " +   
"VALUES ('Bob', 'Smith', 8000)";  
insertStmt.text = sql;  
try  
{  
// execute the statement  
insertStmt.execute();  
air.trace("INSERT statement succeeded");  
}  
catch (error)  
{  
air.trace("Error message:", error.message);  
air.trace("Details:", error.details);  
}
Retrieving a database-generated primary key of an inserted row
Adobe AIR 1.0 and later
Often after inserting a row of data into a table, your code needs to know a database-generated primary key or row 
identifier value for the newly inserted row. For example, once you insert a row in one table, you might want to add 
rows in a related table. In that case you would want to insert the primary key value as a foreign key in the related table. 
The primary key of a newly inserted row can be retrieved using the SQLResult object associated with the statement 
execution. This is the same object that’s used to access result data after a 
SELECT
statement is executed. As with any 
SQL statement, when the execution of an 
INSERT
statement completes the runtime creates a SQLResult instance. You 
access the SQLResult instance by calling the SQLStatement object’s 
getResult()
method if you’re using an event 
listener or if you’re using synchronous execution mode. Alternatively, if you’re using asynchronous execution mode 
and you pass a Responder instance to the 
execute()
call, the SQLResult instance is passed as an argument to the result 
handler function. In any case, the SQLResult instance has a property, 
lastInsertRowID
, that contains the row 
identifier of the most-recently inserted row if the executed SQL statement is an 
INSERT
statement.
The following example demonstrates accessing the primary key of an inserted row in asynchronous execution mode:
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
document file. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. Also a preview
bookmark page in pdf; adding bookmarks to pdf document
C# PDF File Split Library: Split, seperate PDF into multiple files
Split PDF file by top level bookmarks. The following C# codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
delete bookmarks pdf; how to add bookmarks on pdf
227
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
insertStmt.text = "INSERT INTO ...";  
insertStmt.addEventListener(air.SQLEvent.RESULT, resultHandler);  
insertStmt.execute();  
function resultHandler(event)  
{  
// get the primary key  
var result = insertStmt.getResult();  
var primaryKey = result.lastInsertRowID;  
// do something with the primary key  
}
The following example demonstrates accessing the primary key of an inserted row in synchronous execution mode:
insertStmt.text = "INSERT INTO ...";  
try  
{  
insertStmt.execute();  
// get the primary key  
var result = insertStmt.getResult();  
var primaryKey = result.lastInsertRowID;  
// do something with the primary key  
}  
catch (error)  
{  
// respond to the error  
}
Note that the row identifier may or may not be the value of the column that is designated as the primary key column 
in the table definition, according to the following rules:
• If the table is defined with a primary key column whose affinity (column data type) is 
INTEGER
, the 
lastInsertRowID
property contains the value that was inserted into that row (or the value generated by the 
runtime if it’s an 
AUTOINCREMENT
column).
• If the table is defined with multiple primary key columns (a composite key) or with a single primary key column 
whose affinity is not 
INTEGER
, behind the scenes the database generates an integer row identifier value for the row. 
That generated value is the value of the 
lastInsertRowID
property.
• The value is always the row identifier of the most-recently inserted row. If an 
INSERT
statement causes a trigger to 
fire which in turn inserts a row, the 
lastInsertRowID
property contains the row identifier of the last row inserted 
by the trigger rather than the row created by the 
INSERT
statement. 
As a consequence of these rules, if you want to have an explicitly defined primary key column whose value is available 
after an 
INSERT
command through the 
SQLResult.lastInsertRowID
property, the column must be defined as an 
INTEGER PRIMARY KEY
column. Even if your table does not include an explicit 
INTEGER PRIMARY KEY
column, it is 
equally acceptable to use the database-generated row identifier as a primary key for your table in the sense of defining 
relationships with related tables. The row identifier column value is available in any SQL statement by using one of the 
special column names 
ROWID
_ROWID_
, or 
OID
. You can create a foreign key column in a related table and use the row 
VB.NET PDF File Split Library: Split, seperate PDF into multiple
Demo Code in VB.NET. The following VB.NET codes explain how to split a PDF file into multiple ones by PDF bookmarks or outlines.
create pdf bookmarks from word; create pdf with bookmarks from word
C# PDF File Compress Library: Compress reduce PDF size in C#.net
NET framework. Remove bookmarks, annotations, watermark, page labels and article threads from PDF while compressing. C# class demo
bookmarks pdf; bookmarks pdf documents
228
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
identifier value as the foreign key column value just as you would with an explicitly declared 
INTEGER PRIMARY KEY
column. In that sense, if you are using an arbitrary primary key rather than a natural key, and as long as you don’t mind 
the runtime generating the primary key value for you, it makes little difference whether you use an 
INTEGER PRIMARY 
KEY
column or the system-generated row identifier as a table’s primary key for defining a foreign key relationship with 
between two tables.
For more information about primary keys and generated row identifiers, see “SQL support in local databases” on 
page  341.
Changing or deleting data
Adobe AIR 1.0 and later
The process for executing other data manipulation operations is identical to the process used to execute a SQL 
SELECT
or 
INSERT
statement, as described in “Working with SQL statements” on page  214. Simply substitute a different SQL 
statement in the SQLStatement instance’s 
text
property:
• To change existing data in a table, use an 
UPDATE
statement.
• To delete one or more rows of data from a table, use a 
DELETE
statement.
For descriptions of these statements, see “SQL support in local databases” on page  341.
Working with multiple databases
Adobe AIR 1.0 and later
Use the 
SQLConnection.attach()
method to open a connection to an additional database on a SQLConnection 
instance that already has an open database. You give the attached database a name using the name parameter in the 
attach()
method call. When writing statements to manipulate that database, you can then use that name in a prefix 
(using the form 
database-name.table-name
) to qualify any table names in your SQL statements, indicating to the 
runtime that the table can be found in the named database.
You can execute a single SQL statement that includes tables from multiple databases that are connected to the same 
SQLConnection instance. If a transaction is created on the SQLConnection instance, that transaction applies to all SQL 
statements that are executed using the SQLConnection instance. This is true regardless of which attached database the 
statement runs on.
Alternatively, you can also create multiple SQLConnection instances in an application, each of which is connected to 
one or multiple databases. However, if you do use multiple connections to the same database keep in mind that a 
database transaction isn’t shared across SQLConnection instances. Consequently, if you connect to the same database 
file using multiple SQLConnection instances, you can’t rely on both connections’ data changes being applied in the 
expected manner. For example, if two 
UPDATE
or 
DELETE
statements are run against the same database through 
different SQLConnection instances, and an application error occurs after one operation takes place, the database data 
could be left in an intermediate state that would not be reversible and might affect the integrity of the database (and 
consequently the application).
XDoc.Excel for .NET, Comprehensive .NET Excel Imaging Features
zooming & rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Excel Convert. Convert Excel to PDF; Convert Excel
export bookmarks from pdf to excel; create pdf bookmarks online
.NET PDF SDK - Description of All PDF Processing Control Feastures
bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. PDF Create. Create PDF from Word (docx, doc); Create PDF from Excel
create bookmarks pdf files; add bookmark pdf
229
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
Handling database errors
Adobe AIR 1.0 and later
In general, database error handling is like other runtime error handling. You should write code that is prepared for 
errors that may occur, and respond to the errors rather than leave it up to the runtime to do so. In a general sense, the 
possible database errors can be divided into three categories: connection errors, SQL syntax errors, and constraint 
errors.
Connection errors
Adobe AIR 1.0 and later
Most database errors are connection errors, and they can occur during any operation. Although there are strategies for 
preventing connection errors, there is rarely a simple way to gracefully recover from a connection error if the database 
is a critical part of your application.
Most connection errors have to do with how the runtime interacts with the operating system, the file system, and the 
database file. For example, a connection error occurs if the user doesn’t have permission to create a database file in a 
particular location on the file system. The following strategies help to prevent connection errors:
Use user-specific database files 
Rather than using a single database file for all users who use the application on a single 
computer, give each user their own database file. The file should be located in a directory that’s associated with the 
user’s account. For example, it could be in the application’s storage directory, the user’s documents folder, the user’s 
desktop, and so forth.
Consider different user types 
Test your application with different types of user accounts, on different operating 
systems. Don’t assume that the user has administrator permission on the computer. Also, don’t assume that the 
individual who installed the application is the user who’s running the application.
Consider various file locations  
If you allow a user to specify where to save a database file or select a file to open, 
consider the possible file locations that the users might use. In addition, consider defining limits on where users can 
store (or from where they can open) database files. For example, you might only allow users to open files that are within 
their user account’s storage location.
If a connection error occurs, it most likely happens on the first attempt to create or open the database. This means that 
the user is unable to do any database-related operations in the application. For certain types of errors, such as read-
only or permission errors, one possible recovery technique is to copy the database file to a different location. The 
application can copy the database file to a different location where the user does have permission to create and write 
to files, and use that location instead.
Syntax errors
Adobe AIR 1.0 and later
A syntax error occurs when a SQL statement is incorrectly formed, and the application attempts to execute the 
statement. Because local database SQL statements are created as strings, compile-time SQL syntax checking is not 
possible. All SQL statements must be executed to check their syntax. Use the following strategies to prevent SQL syntax 
errors:
Test all SQL statements thoroughly 
If possible, while developing your application test your SQL statements separately 
before encoding them as statement text in the application code. In addition, use a code-testing approach such as unit 
testing to create a set of tests that exercise every possible option and variation in the code.
XDoc.Word for .NET, Advanced .NET Word Processing Features
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. Conversion. Word Create. Create Word from PDF; Create Word
create bookmarks in pdf; adding bookmarks to pdf reader
XDoc.PowerPoint for .NET, All Mature Features Introductions
& rotation; Outlines, bookmarks, & thumbnail display; Integrated annotation; More about Web Viewer ▶. PowerPoint Convert. Convert PowerPoint to PDF; Convert
pdf bookmark editor; how to bookmark a pdf in reader
230
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
Use statement parameters and avoid concatenating (dynamically generating) SQL 
Using parameters, and avoiding 
dynamically built SQL statements, means that the same SQL statement text is used each time a statement is executed. 
Consequently, it’s much easier to test your statements and limit the possible variation. If you must dynamically 
generate a SQL statement, keep the dynamic parts of the statement to a minimum. Also, carefully validate any user 
input to make sure it won’t cause syntax errors.
To recover from a syntax error, an application would need complex logic to be able to examine a SQL statement and 
correct its syntax. By following the previous guidelines for preventing syntax errors, your code can identify any 
potential run-time sources of SQL syntax errors (such as user input used in a statement). To recover from a syntax 
error, provide guidance to the user. Indicate what to correct to make the statement execute properly.
Constraint errors
Adobe AIR 1.0 and later
Constraint errors occur when an 
INSERT
or 
UPDATE
statement attempts to add data to a column. The error happens if 
the new data violates one of the defined constraints for the table or column. The set of possible constraints includes:
Unique constraint 
Indicates that across all the rows in a table, there cannot be duplicate values in one column. 
Alternatively, when multiple columns are combined in a unique constraint, the combination of values in those 
columns must not be duplicated. In other words, in terms of the specified unique column or columns, each row must 
be distinct.
Primary key constraint 
In terms of the data that a constraint allows and doesn’t allow, a primary key constraint is 
identical to a unique constraint.
Not null constraint 
Specifies that a single column cannot store a 
NULL
value and consequently that in every row, that 
column must have a value.
Check constraint 
Allows you to specify an arbitrary constraint on one or more tables. A common check constraint is 
a rule that define that a column’s value must be within certain bounds (for example, that a numeric column’s value 
must be larger than 0). Another common type of check constraint specifies relationships between column values (for 
example, that a column’s value must be different from the value of another column in the same row).
Data type (column affinity) constraint 
The runtime enforces the data type of columns’ values, and an error occurs if 
an attempt is made to store a value of the incorrect type in a column. However, in many conditions values are 
converted to match the column’s declared data type. See “Working with database data types” on page  231   for more 
information.
The runtime does not enforce constraints on foreign key values. In other words, foreign key values aren’t required to 
match an existing primary key value.
In addition to the predefined constraint types, the runtime SQL engine supports the use of triggers. A trigger is like an 
event handler. It is a predefined set of instructions that are carried out when a certain action happens. For example, a 
trigger could be defined that runs when data is inserted into or deleted from a particular table. One possible use of a 
trigger is to examine data changes and cause an error to occur if specified conditions aren’t met. Consequently, a 
trigger can serve the same purpose as a constraint, and the strategies for preventing and recovering from constraint 
errors also apply to trigger-generated errors. However, the error id for trigger-generated errors is different from the 
error id for constraint errors.
The set of constraints that apply to a particular table is determined while you’re designing an application. Consciously 
designing constraints makes it easier to design your application to prevent and recover from constraint errors. 
However, constraint errors are difficult to systematically predict and prevent. Prediction is difficult because constraint 
errors don’t appear until application data is added. Constraint errors occur with data that is added to a database after 
231
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
it’s created. These errors are often a result of the relationship between new data and data that already exists in the 
database. The following strategies can help you avoid many constraint errors:
Carefully plan database structure and constraints 
The purpose of constraints is to enforce application rules and help 
protect the integrity of the database’s data. When you’re planning your application, consider how to structure your 
database to support your application. As part of that process, identify rules for your data, such as whether certain 
values are required, whether a value has a default, whether duplicate values are allowed, and so forth. Those rules guide 
you in defining database constraints.
Explicitly specify column names 
An 
INSERT
statement can be written without explicitly specifying the columns into 
which values are to be inserted, but doing so is an unnecessary risk. By explicitly naming the columns into which values 
are to be inserted, you can allow for automatically generated values, columns with default values, and columns that 
allow 
NULL
values. In addition, by doing so you can ensure that all 
NOT NULL
columns have an explicit value inserted.
Use default values 
Whenever you specify a 
NOT NULL
constraint for a column, if at all possible specify a default value 
in the column definition. Application code can also provide default values. For example, your code can check if a String 
variable is 
null
and assign it a value before using it to set a statement parameter value.
Validate user-entered data 
Check user-entered data ahead of time to make sure that it obeys limits specified by 
constraints, especially in the case of 
NOT NULL
and 
CHECK
constraints. Naturally, a 
UNIQUE
constraint is more difficult 
to check for because doing so would require executing a 
SELECT
query to determine whether the data is unique.
Use triggers 
You can write a trigger that validates (and possibly replaces) inserted data or takes other actions to correct 
invalid data. This validation and correction can prevent a constraint error from occurring.
In many ways constraint errors are more difficult to prevent than other types of errors. Fortunately, there are several 
strategies to recover from constraint errors in ways that don’t make the application unstable or unusable:
Use conflict algorithms 
When you define a constraint on a column, and when you create an 
INSERT
or 
UPDATE
statement, you have the option of specifying a conflict algorithm. A conflict algorithm defines the action the database 
takes when a constraint violation occurs. There are several possible actions the database engine can take. The database 
engine can end a single statement or a whole transaction. It can ignore the error. It can even remove old data and 
replace it with the data that the code is attempting to store. 
For more information see the section “ON CONFLICT (conflict algorithms)” in the “SQL support in local databases” 
on page  341.
Provide corrective feedback 
The set of constraints that can affect a particular SQL command can be identified ahead 
of time. Consequently, you can anticipate constraint errors that a statement could cause. With that knowledge, you 
can build application logic to respond to a constraint error. For example, suppose an application includes a data entry 
form for entering new products. If the product name column in the database is defined with a 
UNIQUE
constraint, the 
action of inserting a new product row in the database could cause a constraint error. Consequently, the application is 
designed to anticipate a constraint error. When the error happens, the application alerts the user, indicating that the 
specified product name is already in use and asking the user to choose a different name. Another possible response is 
to allow the user to view information about the other product with the same name.
Working with database data types
Adobe AIR 1.0 and later
When a table is created in a database, the SQL statement for creating the table defines the affinity, or data type, for each 
column in the table. Although affinity declarations can be omitted, it’s a good idea to explicitly declare column affinity 
in your 
CREATE TABLE
SQL statements.
232
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
As a general rule, any object that you store in a database using an 
INSERT
statement is returned as an instance of the 
same data type when you execute a 
SELECT
statement. However, the data type of the retrieved value can be different 
depending on the affinity of the database column in which the value is stored. When a value is stored in a column, if 
its data type doesn’t match the column’s affinity, the database attempts to convert the value to match the column’s 
affinity. For example, if a database column is declared with 
NUMERIC
affinity, the database attempts to convert inserted 
data into a numeric storage class (
INTEGER
or 
REAL
) before storing the data. The database throws an error if the data 
can’t be converted. According to this rule, if the String “12345” is inserted into a 
NUMERIC
column, the database 
automatically converts it to the integer value 12345 before storing it in the database. When it’s retrieved with a 
SELECT
statement, the value is returned as an instance of a numeric data type (such as Number) rather than as a String instance.
The best way to avoid undesirable data type conversion is to follow two rules. First, define each column with the affinity 
that matches the type of data that it is intended to store. Next, only insert values whose data type matches the defined 
affinity. Following these rules provides two benefits. When you insert the data it isn’t converted unexpectedly (possibly 
losing its intended meaning as a result). In addition, when you retrieve the data it is returned with its original data type.
For more information about the available column affinity types and using data types in SQL statements, see the “Data 
type support” on page 362.
Using synchronous and asynchronous database 
operations
Adobe AIR 1.0 and later
Previous sections have described common database operations such as retrieving, inserting, updating, and deleting 
data, as well as creating a database file and tables and other objects within a database. The examples have demonstrated 
how to perform these operations both asynchronously and synchronously.
As a reminder, in asynchronous execution mode, you instruct the database engine to perform an operation. The 
database engine then works in the background while the application keeps running. When the operation finishes the 
database engine dispatches an event to alert you to that fact. The key benefit of asynchronous execution is that the 
runtime performs the database operations in the background while the main application code continues executing. 
This is especially valuable when the operation takes a notable amount of time to run.
On the other hand, in synchronous execution mode operations don’t run in the background. You tell the database 
engine to perform an operation. The code pauses at that point while the database engine does its work. When the 
operation completes, execution continues with the next line of your code.
A single database connection can’t execute some operations or statements synchronously and others asynchronously. 
You specify whether a SQLConnection operates in synchronous or asynchronous when you open the connection to 
the database. If you call 
SQLConnection.open()
the connection operates in synchronous execution mode, and if you 
call 
SQLConnection.openAsync()
the connection operates in asynchronous execution mode. Once a 
SQLConnection instance is connected to a database using 
open()
or 
openAsync()
, it is fixed to synchronous or 
asynchronous execution.
233
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
Using synchronous database operations
Adobe AIR 1.0 and later
There is little difference in the actual code that you use to execute and respond to operations when using synchronous 
execution, compared to the code for asynchronous execution mode. The key differences between the two approaches 
fall into two areas. The first is executing an operation that depends on another operation (such as 
SELECT
result rows 
or the primary key of the row added by an 
INSERT
statement). The second area of difference is in handling errors.
Writing code for synchronous operations
Adobe AIR 1.0 and later
The key difference between synchronous and asynchronous execution is that in synchronous mode you write the code 
as a single series of steps. In contrast, in asynchronous code you register event listeners and often divide operations 
among listener methods. When a database is connected in synchronous execution mode, you can execute a series of 
database operations in succession within a single code block. The following example demonstrates this technique:
// Include AIRAliases.js to use air.* shortcuts  
var conn = new air.SQLConnection();  
// The database file is in the application storage directory  
var folder = File.applicationStorageDirectory;  
var dbFile = folder.resolvePath("DBSample.db");  
// open the database  
conn.open(dbFile, air.OpenMode.UPDATE);  
// start a transaction  
conn.begin();  
// add the customer record to the database  
var insertCustomer = new air.SQLStatement();  
insertCustomer.sqlConnection = conn;  
insertCustomer.text =  
"INSERT INTO customers (firstName, lastName) " +   
"VALUES ('Bob', 'Jones')";  
insertCustomer.execute();  
var customerId = insertCustomer.getResult().lastInsertRowID;  
// add a related phone number record for the customer  
var insertPhoneNumber = new air.SQLStatement();  
insertPhoneNumber.sqlConnection = conn;  
insertPhoneNumber.text =   
"INSERT INTO customerPhoneNumbers (customerId, number) " +   
"VALUES (:customerId, '800-555-1234')";  
insertPhoneNumber.parameters[":customerId"] = customerId;  
insertPhoneNumber.execute();  
// commit the transaction  
conn.commit();
234
HTML DEVELOPER’S GUIDE FOR ADOBE AIR
Working with local SQL databases in AIR
Last updated 9/28/2011
As you can see, you call the same methods to perform database operations whether you’re using synchronous or 
asynchronous execution. The key differences between the two approaches are executing an operation that depends on 
another operation and handling errors.
Executing an operation that depends on another operation
Adobe AIR 1.0 and later
When you’re using synchronous execution mode, you don’t need to write code that listens for an event to determine 
when an operation completes. Instead, you can assume that if an operation in one line of code completes successfully, 
execution continues with the next line of code. Consequently, to perform an operation that depends on the success of 
another operation, simply write the dependent code immediately following the operation on which it depends. For 
instance, to code an application to begin a transaction, execute an 
INSERT
statement, retrieve the primary key of the 
inserted row, insert that primary key into another row of a different table, and finally commit the transaction, the code 
can all be written as a series of statements. The following example demonstrates these operations:
// Include AIRAliases.js to use air.* shortcuts  
var conn = new air.SQLConnection();  
// The database file is in the application storage directory  
var folder = File.applicationStorageDirectory;  
var dbFile = folder.resolvePath("DBSample.db");  
// open the database  
conn.open(dbFile, air.OpenMode.UPDATE);  
// start a transaction  
conn.begin();  
// add the customer record to the database  
var insertCustomer = new air.SQLStatement();  
insertCustomer.sqlConnection = conn;  
insertCustomer.text =  
"INSERT INTO customers (firstName, lastName) " +   
"VALUES ('Bob', 'Jones')";  
insertCustomer.execute();  
var customerId = insertCustomer.getResult().lastInsertRowID;  
// add a related phone number record for the customer  
var insertPhoneNumber = new air.SQLStatement();  
insertPhoneNumber.sqlConnection = conn;  
insertPhoneNumber.text =   
"INSERT INTO customerPhoneNumbers (customerId, number) " +   
"VALUES (:customerId, '800-555-1234')";  
insertPhoneNumber.parameters[":customerId"] = customerId;  
insertPhoneNumber.execute();  
// commit the transaction  
conn.commit();
Documents you may be interested
Documents you may be interested