Category Archives: Technical

Technical information about developing applications for the iPhone SDK.

Automating SQLite Database Creation

“If you want more effective programmers, you will discover that they should not waste their time debugging, they should not introduce the bugs to start with.”
Edsger Dijkstra

During the software development process, the more non-deterministic processes that enter into your workflow the greater chance of introducing unintended bugs or functional regression.  There’s nothing more frustrating than to fix a bug (or make an improvement) only to have something else in your app break.  Thus, it’s generally considered good practice to automate as much of your pipeline (from build to asset creation) as possible.  If you can automate something, do so!  It’ll save you time and effort later.

If you decide to use SQLite in your iPhone app, there are a few steps to follow in order to automate re-creation of your database.

For Daily Value, I used a couple of tools to construct and later manipulate the database.  On the PC, the process started with Microsoft Access to transform the relational database from the USDA into a number of Excel spreadsheets – one for each table.  From Access, this was accomplished by right clicking the tables and selecting “Export | Excel”.

Microsoft Excel 2007 was used heavily to manipulate and process the input data before it was ready to export into SQLite.  There are some subtle and sometimes frustrating differences between Excel 2007 and 2003.  It felt to me like exporting was more flexible in the earlier version.  Basically, the “standard” CSV is “comma separated values” which created an input parsing problem for both SQLite Manager for Firefox and the command line tool, sqlite3, because the commas used for field delimiters.

I dimly thought that in older versions of Excel, when exporting to CSV, a series of dialogs took you through the process and allowed you to specify a custom delimiter.  In a file full of strings with commas already, the ability to set the token was great.  In my case, I wanted to export the data using the pipe (|) symbol.  It took some digging but exporting to CSV in 2007 to a flavor that SQLite liked required changing the output separator token via the Control Panel!

Here’re the basic steps:

  1. With Excel closed, open the Control Panel
  2. Double click the Regional and Language Options
  3. On the Regional Options tab, click on the Customize button
  4. On the Numbers tab, change the List separator to “|” (without the quotes)

Now you can “Save As” in Excel using CSV with the custom separator.

I used SQLite Manager early in the development process because it was very convenient to not only import data, but it was nice working in a visual environment as the tables continued to undergo design changes.  Even after I automated the database creation, the tool was useful to inspect run-time changes from the Simulator.  It was also nice to see the SQL the tool generated when creating tables, indices, or other operations on the data.

Once the table structure solidified, I wrote a simple “text input file” to re-create the database using the sqlite3 schema command.

  1. Gather up the structure of your tables by using either SQLite Manager or sqlite3.  In the Firefox plug-in, SQLite Manager has a tab that describes the table structure.  Or, launch the Terminal, and open your database with sqlite3, then type “.schema <table_name>” to get the structure.
  2. Copy this information to TextEdit (or an editor of your preference).  The top portion of this file should issue all the table creation commands required to setup your database structure.
  3. Then add the sqlite3 import commands to import the CSV files.

.mode csv

.separator |

.import table_1.csv table_1

And so on.  If you need to insert data into the tables, or create indices on any tables, you can insert these commands at the end of the file.  My input file, named schema.txt, looked something like this:

CREATE TABLE “food” (“pk” INTEGER PRIMARY KEY NOT NULL, “group” INTEGER, “name” TEXT, “desc” TEXT);

CREATE TABLE “version” (“ver” INTEGER);

.mode csv

.separator |

.import food.csv food

CREATE INDEX idx_food_pk ON food (“pk” ASC);

INSERT INTO version (ver) VALUES (“2”);

A couple notes on the file format.  You can span SQL commands on multiple lines in order to make the file more human readable.  The semi-colon is important for any SQL statements used in the file.  You should remove any column header information from the CSV file prior to using the “.import” command as the column types most likely won’t match and cause the import to fail.  Also, the CSV files reside in the same directory as where you’ll create the database and issue the sqlite3 command as shown below:

%sqlite3 database.sqlite < schema.txt

If you really wanted to get more sophisticated, you could hook running (and copying) this freshly created database into Xcode as a build step.  In another entry, I’ll talk about how I use something similar to auto version builds based on the repository revision.

Data persistence choices

In roughing out the early data framework for Daily Value, one of the early considerations was data persistence – particularly user created data.  The app’s requirements included supporting user entered food data that could be treated “on par” with shipped food data.

Looking around at what the iPhone SDK supported, a couple choices quickly presented themselves: archiving, property lists, and SQLite.  While the temptation was to leap right into a relational database solution, some consideration was made for the other choices and in truth, Daily Value employs all of these techniques for various pieces of data.

There’s a nice write up in “Beginning iPhone Development” by Dave Mark and Jeff LaMarche so I won’t dive too deeply into it except to say property lists and archiving were discarded.  Although writing data in a binary format with archiving had some appeal for data obfuscation purposes, it would have also meant writing a bunch of “database-like” functionality that didn’t seem a good technical investment in time or resources.  So, SQLite was what I went with.

SQLite offers a lot of upside:

  • The API is written in C and is easy to navigate.
  • Storage and manipulation of the data was offloaded to the database framework.
  • There are a number of free tools that can be used to browse and quickly inspect the data (ex. SQLite Manager for FireFox)
  • Creation can be automated
  • Good performance on complex queries

The biggest drawback is an apparent lack of authentication or way to protect the data placed into the database.  Since our data was publicly available, this wasn’t much of an issue but it might be for some other apps.

The initial design called for all the data – both shipped and user generated – to be stored in a single database file.  The thought being that it’d be easier to code queries against and manage.  User data would contain some differentiator (either a column identifier or field) to denote it as “editable” (you don’t want folks mucking about with your data).

Apps that use persistent data, or write back cannot do so to files stored within their application bundle or else it breaks the code signing and things stop working.  So, when the app initially loads, the source data is copied to the Documents directory and opened from there.  Of course, the app checks first to see if the file already exists so it doesn’t overwrite an existing file.

Test rigs built for the simulator seemed to indicate that this was viable, but putting the app on the actual device proved otherwise.  Apple requires that apps fully launch quickly after no more than 5 seconds.  The first database prototypes were nearly 4 MB.  The bulk initial copy caused startup to be unacceptable taking over 10 seconds!

Trimming the database helped.  With a little bit of effort in making tables more relational and dropping columns that weren’t strictly required, the size got squeezed down to just under 2 MB.  Even so, the copy took too long – so what to do?

After digging about through the SQLite documentation, I came across the SQL “attach” command.  One neat feature in SQLite is that it supports the notion of opening multiple databases and treating them (generally) as a single entity.  Care was taken to create a “template” user database with pre-created tables that were different than the app supplied database.  While not strictly necessary since SQLite will allow you to have duplicate table names, it seemed prudent and an easy “design time” step.

When the app launches, if it doesn’t already exist, the “empty” user database (all 12 kb of it) is copied from the main bundle to the Documents directory and opened.  Then, the app “attaches” to the large bundle database with the restriction that none of the bundled data can be modified.  Startup times were acceptable and the additional complexity was very minimal due to the SQLite abstraction support.

Here’s a bit of code to get the job done – assuming that dbHandle is a member variable of your data class.

- (void)copyDataIfNeeded
{
   NSFileManager *fm = [NSFileManager defaultManager];
   NSArray *docPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
   NSString *docDir = [docPath objectAtIndex:0];
   NSString *writePath = [docDir stringByAppendingPathComponent:@”user.db”];

   BOOL success = [fm fileExistsAtPath:writePath];
   if (success)
      return;

   NSError *error;
   NSString *dbPath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:”user.db”];
   success = [fm copyItemAtPath:dbPath toPath:writePath error:&error];
   if (!success)
      NSAssert1(0, @”failed to create writable database with msg ‘%@’”, [error localizedDescription]);
}

- (void)attachDatabase
{
   [self copyDataIfNeeded];

   NSArray *path = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
   NSString *docDir = [path objectAtIndex:0];
   NSString *openPath = [docDir stringByAppendingPathComponent:”user.db”];

   if (sqlite3_open([openPath UTF8String], &dbHandle) == SQLITE_OK)
   {
      NSString *sysDBPath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:”main.db”];
      NSString *sqlString = [NSString stringWithFormat:@”ATTACH DATABASE ‘%@’ AS main”, sysDBPath];

      const char *sql = [sqlString UTF8String];
      sqlite3_stmt *statement;
      int success = 0;

      success = sqlite3_prepare_v2(dbHandle, sql, -1, &statement, NULL);
      NSAssert1(success == SQLITE_OK, @”Failed to prepare ATTACH with msg ‘%s’”, sqlite3_errmsg(dbHandle));

      success = sqlite3_step(statement);
      NSAssert1(success == SQLITE_DONE, @”Failed to execute ATTACH with msg ‘%s’”, sqlite3_errmsg(dbHandle));

      sqlite3_finalize(statement);
   }
   else
       NSAssert1(0, @”Failed to open database with msg ‘%@’”, sqlite3_errmsg(dbHandle));
}