sync: Put sqlite_utils.* into sqlite_utils namespace.

chrome/browser/sync/syncable/directory_backing_store.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync/syncable/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CoreFoundation.h>
@@ skipping 31 matching lines @@
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
 
 // Increment this version whenever updating DB tables.
 extern const int32 kCurrentDBVersion;  // Global visibility for our unittest.
 const int32 kCurrentDBVersion = 76;
 
 namespace {
 
 int ExecQuery(sqlite3* dbhandle, const char* query) {
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   int result = statement.prepare(dbhandle, query);
   if (SQLITE_OK != result)
     return result;
   do {
     result = statement.step();
   } while (SQLITE_ROW == result);
 
   return result;
 }
 
 string GenerateCacheGUID() {
   return Generate128BitRandomBase64String();
 }
 
 }  // namespace
 
 
 // Iterate over the fields of |entry| and bind each to |statement| for
 // updating.  Returns the number of args bound.
-int BindFields(const EntryKernel& entry, SQLStatement* statement) {
+int BindFields(const EntryKernel& entry,
+               sqlite_utils::SQLStatement* statement) {
   int index = 0;
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     statement->bind_int64(index++, entry.ref(static_cast<Int64Field>(i)));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     statement->bind_string(index++, entry.ref(static_cast<IdField>(i)).s_);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     statement->bind_int(index++, entry.ref(static_cast<BitField>(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     statement->bind_string(index++, entry.ref(static_cast<StringField>(i)));
   }
   std::string temp;
   for ( ; i < PROTO_FIELDS_END; ++i) {
     entry.ref(static_cast<ProtoField>(i)).SerializeToString(&temp);
     statement->bind_blob(index++, temp.data(), temp.length());
   }
   return index;
 }
 
 // The caller owns the returned EntryKernel*.
-int UnpackEntry(SQLStatement* statement, EntryKernel** kernel) {
+int UnpackEntry(sqlite_utils::SQLStatement* statement, EntryKernel** kernel) {
   *kernel = NULL;
   int query_result = statement->step();
   if (SQLITE_ROW == query_result) {
     *kernel = new EntryKernel;
     (*kernel)->clear_dirty(NULL);
     DCHECK(statement->column_count() == static_cast<int>(FIELD_COUNT));
     int i = 0;
     for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
       (*kernel)->put(static_cast<Int64Field>(i), statement->column_int64(i));
     }
@@ skipping 81 matching lines @@
     sqlite3_busy_timeout(scoped_handle.get(), std::numeric_limits<int>::max());
     {
       string integrity_error;
       bool is_ok = CheckIntegrity(scoped_handle.get(), &integrity_error);
       if (!is_ok) {
         LOG(ERROR) << "Integrity check failed: " << integrity_error;
         return false;
       }
     }
     {
-      SQLStatement statement;
+      sqlite_utils::SQLStatement statement;
       statement.prepare(scoped_handle.get(), "PRAGMA fullfsync = 1");
       if (SQLITE_DONE != statement.step()) {
         LOG(ERROR) << sqlite3_errmsg(scoped_handle.get());
         return false;
       }
     }
     {
-      SQLStatement statement;
+      sqlite_utils::SQLStatement statement;
       statement.prepare(scoped_handle.get(), "PRAGMA synchronous = 2");
       if (SQLITE_DONE != statement.step()) {
         LOG(ERROR) << sqlite3_errmsg(scoped_handle.get());
         return false;
       }
     }
     sqlite3_busy_timeout(scoped_handle.release(),
                          kDirectoryBackingStoreBusyTimeoutMs);
 #if defined(OS_WIN)
     // Do not index this file. Scanning can occur every time we close the file,
     // which causes long delays in SQLite's file locking.
     const DWORD attrs = GetFileAttributes(backing_filepath_.value().c_str());
     const BOOL attrs_set =
       SetFileAttributes(backing_filepath_.value().c_str(),
                         attrs | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);
 #endif
 
     return true;
   }
   return false;
 }
 
 bool DirectoryBackingStore::CheckIntegrity(sqlite3* handle, string* error)
     const {
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   statement.prepare(handle, "PRAGMA integrity_check(1)");
   if (SQLITE_ROW != statement.step()) {
     *error =  sqlite3_errmsg(handle);
     return false;
   }
   string integrity_result = statement.column_text(0);
   if (integrity_result != "ok") {
     *error = integrity_result;
     return false;
   }
@@ skipping 90 matching lines @@
   sqlite3* dbhandle = LazyGetSaveHandle();
 
   string query = "DELETE FROM metas WHERE metahandle IN (";
   for (MetahandleSet::const_iterator it = handles.begin(); it != handles.end();
        ++it) {
     if (it != handles.begin())
       query.append(",");
     query.append(base::Int64ToString(*it));
   }
   query.append(")");
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   int result = statement.prepare(dbhandle, query.data(), query.size());
   if (SQLITE_OK == result)
     result = statement.step();
 
   return SQLITE_DONE == result;
 }
 
 bool DirectoryBackingStore::SaveChanges(
     const Directory::SaveChangesSnapshot& snapshot) {
   sqlite3* dbhandle = LazyGetSaveHandle();
 
   // SQLTransaction::BeginExclusive causes a disk write to occur. This is not
   // something that should happen every 10 seconds when this function runs, so
   // just stop here if there's nothing to save.
   bool save_info =
     (Directory::KERNEL_SHARE_INFO_DIRTY == snapshot.kernel_info_status);
   if (snapshot.dirty_metas.size() < 1 && !save_info)
     return true;
 
-  SQLTransaction transaction(dbhandle);
+  sqlite_utils::SQLTransaction transaction(dbhandle);
   if (SQLITE_OK != transaction.BeginExclusive())
     return false;
 
   for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
     DCHECK(i->is_dirty());
     if (!SaveEntryToDB(*i))
       return false;
   }
 
   if (!DeleteEntries(snapshot.metahandles_to_purge))
     return false;
 
   if (save_info) {
     const Directory::PersistedKernelInfo& info = snapshot.kernel_info;
-    SQLStatement update;
+    sqlite_utils::SQLStatement update;
     update.prepare(dbhandle, "UPDATE share_info "
                    "SET store_birthday = ?, "
                    "next_id = ?, "
                    "notification_state = ? ");
 
     update.bind_string(0, info.store_birthday);
     update.bind_int64(1, info.next_id);
     update.bind_blob(2, info.notification_state.data(),
                      info.notification_state.size());
 
     if (!(SQLITE_DONE == update.step() &&
           SQLITE_OK == update.reset() &&
           1 == update.changes())) {
       return false;
     }
 
     for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-      SQLStatement op;
+      sqlite_utils::SQLStatement op;
       op.prepare(dbhandle, "INSERT OR REPLACE INTO models (model_id, "
       "progress_marker, initial_sync_ended) VALUES ( ?, ?, ?)");
       // We persist not ModelType but rather a protobuf-derived ID.
       string model_id = ModelTypeEnumToModelId(ModelTypeFromInt(i));
       string progress_marker;
       info.download_progress[i].SerializeToString(&progress_marker);
       op.bind_blob(0, model_id.data(), model_id.length());
       op.bind_blob(1, progress_marker.data(), progress_marker.length());
       op.bind_bool(2, info.initial_sync_ended[i]);
 
       if (!(SQLITE_DONE == op.step() &&
             SQLITE_OK == op.reset() &&
             1 == op.changes())) {
         return false;
       }
     }
   }
 
   return (SQLITE_OK == transaction.Commit());
 }
 
 DirOpenResult DirectoryBackingStore::InitializeTables() {
-  SQLTransaction transaction(load_dbhandle_);
+  sqlite_utils::SQLTransaction transaction(load_dbhandle_);
   if (SQLITE_OK != transaction.BeginExclusive()) {
     return FAILED_DISK_FULL;
   }
   int version_on_disk = GetVersion();
   int last_result = SQLITE_DONE;
 
   // Upgrade from version 67. Version 67 was widely distributed as the original
   // Bookmark Sync release. Version 68 removed unique naming.
   if (version_on_disk == 67) {
     if (MigrateVersion67To68())
@@ skipping 62 matching lines @@
       return FAILED_NEWER_VERSION;
     }
     // Fallback (re-sync everything) migration path.
     VLOG(1) << "Old/null sync database, version " << version_on_disk;
     // Delete the existing database (if any), and create a fresh one.
     DropAllTables();
     last_result = CreateTables();
   }
   if (SQLITE_DONE == last_result) {
     {
-      SQLStatement statement;
+      sqlite_utils::SQLStatement statement;
       statement.prepare(load_dbhandle_,
           "SELECT db_create_version, db_create_time FROM share_info");
       if (SQLITE_ROW != statement.step()) {
         transaction.Rollback();
         return FAILED_DISK_FULL;
       }
       string db_create_version = statement.column_text(0);
       int db_create_time = statement.column_int(1);
       statement.reset();
       VLOG(1) << "DB created at " << db_create_time << " by version " <<
@@ skipping 58 matching lines @@
   needs_column_refresh_ = false;
   return true;
 }
 
 bool DirectoryBackingStore::LoadEntries(MetahandlesIndex* entry_bucket) {
   string select;
   select.reserve(kUpdateStatementBufferSize);
   select.append("SELECT ");
   AppendColumnList(&select);
   select.append(" FROM metas ");
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   statement.prepare(load_dbhandle_, select.c_str());
   base::hash_set<int64> handles;
   EntryKernel* kernel = NULL;
   int query_result;
   while (SQLITE_ROW == (query_result = UnpackEntry(&statement, &kernel))) {
     DCHECK(handles.insert(kernel->ref(META_HANDLE)).second);  // Only in debug.
     entry_bucket->insert(kernel);
   }
   return SQLITE_DONE == query_result;
 }
 
 bool DirectoryBackingStore::LoadInfo(Directory::KernelLoadInfo* info) {
   {
-    SQLStatement query;
+    sqlite_utils::SQLStatement query;
     query.prepare(load_dbhandle_,
                   "SELECT store_birthday, next_id, cache_guid, "
                   "notification_state "
                   "FROM share_info");
     if (SQLITE_ROW != query.step())
       return false;
     info->kernel_info.store_birthday = query.column_string(0);
     info->kernel_info.next_id = query.column_int64(1);
     info->cache_guid = query.column_string(2);
     query.column_blob_as_string(3, &info->kernel_info.notification_state);
   }
   {
-    SQLStatement query;
+    sqlite_utils::SQLStatement query;
     query.prepare(load_dbhandle_,
         "SELECT model_id, progress_marker, initial_sync_ended "
         "FROM models");
     while (SQLITE_ROW == query.step()) {
       ModelType type = ModelIdToModelTypeEnum(query.column_blob(0),
                                               query.column_bytes(0));
       if (type != UNSPECIFIED && type != TOP_LEVEL_FOLDER) {
         info->kernel_info.download_progress[type].ParseFromArray(
             query.column_blob(1), query.column_bytes(1));
         info->kernel_info.initial_sync_ended[type] = query.column_bool(2);
       }
     }
   }
   {
-    SQLStatement query;
+    sqlite_utils::SQLStatement query;
     query.prepare(load_dbhandle_,
                   "SELECT MAX(metahandle) FROM metas");
     if (SQLITE_ROW != query.step())
       return false;
     info->max_metahandle = query.column_int64(0);
   }
   return true;
 }
 
 bool DirectoryBackingStore::SaveEntryToDB(const EntryKernel& entry) {
@@ skipping 10 matching lines @@
     query.append(separator);
     values.append(separator);
     separator = ", ";
     query.append(ColumnName(i));
     values.append("?");
   }
 
   query.append(" ) ");
   values.append(" )");
   query.append(values);
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   statement.prepare(save_dbhandle_, query.c_str());
   BindFields(entry, &statement);
   return (SQLITE_DONE == statement.step() &&
           SQLITE_OK == statement.reset() &&
           1 == statement.changes());
 }
 
 bool DirectoryBackingStore::DropDeletedEntries() {
   static const char delete_metas[] = "DELETE FROM metas WHERE metahandle IN "
                                      "(SELECT metahandle from death_row)";
   // Put all statements into a transaction for better performance
-  SQLTransaction transaction(load_dbhandle_);
+  sqlite_utils::SQLTransaction transaction(load_dbhandle_);
   transaction.Begin();
   if (SQLITE_DONE != ExecQuery(
                          load_dbhandle_,
                          "CREATE TEMP TABLE death_row (metahandle BIGINT)")) {
     return false;
   }
   if (SQLITE_DONE != ExecQuery(load_dbhandle_,
                                "INSERT INTO death_row "
                                "SELECT metahandle from metas WHERE is_del > 0 "
                                " AND is_unsynced < 1"
                                " AND is_unapplied_update < 1")) {
     return false;
   }
   if (SQLITE_DONE != ExecQuery(load_dbhandle_, delete_metas)) {
     return false;
   }
   if (SQLITE_DONE != ExecQuery(load_dbhandle_, "DROP TABLE death_row")) {
     return false;
   }
   transaction.Commit();
   return true;
 }
 
 int DirectoryBackingStore::SafeDropTable(const char* table_name) {
   string query = "DROP TABLE IF EXISTS ";
   query.append(table_name);
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   int result = statement.prepare(load_dbhandle_, query.data(),
                                  query.size());
   if (SQLITE_OK == result) {
     result = statement.step();
     if (SQLITE_DONE == result)
       statement.finalize();
   }
 
   return result;
 }
@@ skipping 22 matching lines @@
 // static
 string DirectoryBackingStore::ModelTypeEnumToModelId(ModelType model_type) {
   sync_pb::EntitySpecifics specifics;
   syncable::AddDefaultExtensionValue(model_type, &specifics);
   return specifics.SerializeAsString();
 }
 
 bool DirectoryBackingStore::MigrateToSpecifics(
     const char* old_columns,
     const char* specifics_column,
-    void (*handler_function)(SQLStatement* old_value_query,
+    void (*handler_function)(sqlite_utils::SQLStatement* old_value_query,
                              int old_value_column,
                              sync_pb::EntitySpecifics* mutable_new_value)) {
   std::string query_sql = base::StringPrintf(
       "SELECT metahandle, %s, %s FROM metas", specifics_column, old_columns);
   std::string update_sql = base::StringPrintf(
       "UPDATE metas SET %s = ? WHERE metahandle = ?", specifics_column);
-  SQLStatement query;
+  sqlite_utils::SQLStatement query;
   query.prepare(load_dbhandle_, query_sql.c_str());
   while (query.step() == SQLITE_ROW) {
     int64 metahandle = query.column_int64(0);
     std::string new_value_bytes;
     query.column_blob_as_string(1, &new_value_bytes);
     sync_pb::EntitySpecifics new_value;
     new_value.ParseFromString(new_value_bytes);
     handler_function(&query, 2, &new_value);
     new_value.SerializeToString(&new_value_bytes);
 
-    SQLStatement update;
+    sqlite_utils::SQLStatement update;
     update.prepare(load_dbhandle_, update_sql.data(), update_sql.length());
     update.bind_blob(0, new_value_bytes.data(), new_value_bytes.length());
     update.bind_int64(1, metahandle);
     if (update.step() != SQLITE_DONE) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool DirectoryBackingStore::AddColumn(const ColumnSpec* column) {
-  SQLStatement add_column;
+  sqlite_utils::SQLStatement add_column;
   std::string sql = base::StringPrintf(
       "ALTER TABLE metas ADD COLUMN %s %s", column->name, column->spec);
   add_column.prepare(load_dbhandle_, sql.c_str());
   return add_column.step() == SQLITE_DONE;
 }
 
 bool DirectoryBackingStore::SetVersion(int version) {
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   statement.prepare(load_dbhandle_, "UPDATE share_version SET data = ?");
   statement.bind_int(0, version);
   return statement.step() == SQLITE_DONE;
 }
 
 int DirectoryBackingStore::GetVersion() {
   if (!sqlite_utils::DoesSqliteTableExist(load_dbhandle_, "share_version"))
     return 0;
-  SQLStatement version_query;
+  sqlite_utils::SQLStatement version_query;
   version_query.prepare(load_dbhandle_, "SELECT data from share_version");
   if (SQLITE_ROW != version_query.step())
     return 0;
   int value = version_query.column_int(0);
   if (version_query.reset() != SQLITE_OK)
     return 0;
   return value;
 }
 
 bool DirectoryBackingStore::MigrateVersion67To68() {
@@ skipping 14 matching lines @@
   // we rename the column again, we need to inline the old
   // intermediate name / column spec.
   if (!AddColumn(&g_metas_columns[UNIQUE_SERVER_TAG])) {
     return false;
   }
   if (!AddColumn(&g_metas_columns[UNIQUE_CLIENT_TAG])) {
     return false;
   }
   needs_column_refresh_ = true;
 
-  SQLStatement statement;
+  sqlite_utils::SQLStatement statement;
   statement.prepare(load_dbhandle_,
       "UPDATE metas SET unique_server_tag = singleton_tag");
   return statement.step() == SQLITE_DONE;
 }
 
 namespace {
 
 // Callback passed to MigrateToSpecifics for the v68->v69 migration.  See
 // MigrateVersion68To69().
-void EncodeBookmarkURLAndFavicon(SQLStatement* old_value_query,
+void EncodeBookmarkURLAndFavicon(sqlite_utils::SQLStatement* old_value_query,
                                  int old_value_column,
                                  sync_pb::EntitySpecifics* mutable_new_value) {
   // Extract data from the column trio we expect.
   bool old_is_bookmark_object = old_value_query->column_bool(old_value_column);
   std::string old_url = old_value_query->column_string(old_value_column + 1);
   std::string old_favicon;
   old_value_query->column_blob_as_string(old_value_column + 2, &old_favicon);
   bool old_is_dir = old_value_query->column_bool(old_value_column + 3);
 
   if (old_is_bookmark_object) {
@@ skipping 39 matching lines @@
                            "server_bookmark_url, "
                            "server_bookmark_favicon, "
                            "server_is_dir"),
                           "server_specifics",
                           &EncodeBookmarkURLAndFavicon)) {
     return false;
   }
 
   // Lastly, fix up the "Google Chrome" folder, which is of the TOP_LEVEL_FOLDER
   // ModelType: it shouldn't have BookmarkSpecifics.
-  SQLStatement clear_permanent_items;
+  sqlite_utils::SQLStatement clear_permanent_items;
   clear_permanent_items.prepare(load_dbhandle_,
       "UPDATE metas SET specifics = NULL, server_specifics = NULL WHERE "
       "singleton_tag IN ('google_chrome')");
   if (clear_permanent_items.step() != SQLITE_DONE)
     return false;
 
   SetVersion(69);
   needs_column_refresh_ = true;  // Trigger deletion of old columns.
   return true;
 }
 
 // Version 71, the columns 'initial_sync_ended' and 'last_sync_timestamp'
 // were removed from the share_info table.  They were replaced by
 // the 'models' table, which has these values on a per-datatype basis.
 bool DirectoryBackingStore::MigrateVersion70To71() {
   if (SQLITE_DONE != CreateV71ModelsTable())
     return false;
 
   // Move data from the old share_info columns to the new models table.
   {
-    SQLStatement fetch;
+    sqlite_utils::SQLStatement fetch;
     fetch.prepare(load_dbhandle_,
         "SELECT last_sync_timestamp, initial_sync_ended FROM share_info");
 
     if (SQLITE_ROW != fetch.step())
       return false;
     int64 last_sync_timestamp = fetch.column_int64(0);
     bool initial_sync_ended = fetch.column_bool(1);
     if (SQLITE_DONE != fetch.step())
       return false;
-    SQLStatement update;
+    sqlite_utils::SQLStatement update;
     update.prepare(load_dbhandle_, "INSERT INTO models (model_id, "
         "last_download_timestamp, initial_sync_ended) VALUES (?, ?, ?)");
     string bookmark_model_id = ModelTypeEnumToModelId(BOOKMARKS);
     update.bind_blob(0, bookmark_model_id.data(), bookmark_model_id.size());
     update.bind_int64(1, last_sync_timestamp);
     update.bind_bool(2, initial_sync_ended);
     if (SQLITE_DONE != update.step())
       return false;
   }
 
@@ skipping 101 matching lines @@
   // last_download_timestamp, thereby preserving the download state.
 
   // Move aside the old table and create a new empty one at the current schema.
   if (SQLITE_DONE != ExecQuery(load_dbhandle_,
           "ALTER TABLE models RENAME TO temp_models")) {
     return false;
   }
   if (!CreateModelsTable())
     return false;
 
-  SQLStatement query;
+  sqlite_utils::SQLStatement query;
   query.prepare(load_dbhandle_,
       "SELECT model_id, last_download_timestamp, initial_sync_ended "
       "FROM temp_models");
   while (SQLITE_ROW == query.step()) {
     ModelType type = ModelIdToModelTypeEnum(query.column_blob(0),
                                             query.column_bytes(0));
     if (type != UNSPECIFIED) {
       // Set the |timestamp_token_for_migration| on a new
       // DataTypeProgressMarker, using the old value of last_download_timestamp.
       // The server will turn this into a real token on our behalf the next
       // time we check for updates.
       sync_pb::DataTypeProgressMarker progress_marker;
       progress_marker.set_data_type_id(
           GetExtensionFieldNumberFromModelType(type));
       progress_marker.set_timestamp_token_for_migration(query.column_int64(1));
       std::string progress_blob;
       progress_marker.SerializeToString(&progress_blob);
 
-      SQLStatement update;
+      sqlite_utils::SQLStatement update;
       update.prepare(load_dbhandle_, "INSERT INTO models (model_id, "
           "progress_marker, initial_sync_ended) VALUES (?, ?, ?)");
       update.bind_blob(0, query.column_blob(0), query.column_bytes(0));
       update.bind_blob(1, progress_blob.data(), progress_blob.length());
       update.bind_bool(2, query.column_bool(2));
       if (SQLITE_DONE != update.step())
         return false;
     }
   }
   // Drop the old table.
@@ skipping 18 matching lines @@
 
 int DirectoryBackingStore::CreateTables() {
   VLOG(1) << "First run, creating tables";
   // Create two little tables share_version and share_info
   int result = ExecQuery(load_dbhandle_,
                          "CREATE TABLE share_version ("
                          "id VARCHAR(128) primary key, data INT)");
   if (result != SQLITE_DONE)
     return result;
   {
-    SQLStatement statement;
+    sqlite_utils::SQLStatement statement;
     statement.prepare(load_dbhandle_, "INSERT INTO share_version VALUES(?, ?)");
     statement.bind_string(0, dir_name_);
     statement.bind_int(1, kCurrentDBVersion);
     result = statement.step();
   }
   if (result != SQLITE_DONE)
     return result;
 
   const bool kCreateAsTempShareInfo = false;
   result = CreateShareInfoTable(kCreateAsTempShareInfo);
   if (result != SQLITE_DONE)
     return result;
   {
-    SQLStatement statement;
+    sqlite_utils::SQLStatement statement;
     statement.prepare(load_dbhandle_, "INSERT INTO share_info VALUES"
                                       "(?, "  // id
                                       "?, "   // name
                                       "?, "   // store_birthday
                                       "?, "   // db_create_version
                                       "?, "   // db_create_time
                                       "-2, "  // next_id
                                       "?, "   // cache_guid
                                       "?);");  // notification_state
     statement.bind_string(0, dir_name_);                   // id
@@ skipping 11 matching lines @@
   result = CreateModelsTable();
   if (result != SQLITE_DONE)
     return result;
   // Create the big metas table.
   result = CreateMetasTable(false);
   if (result != SQLITE_DONE)
     return result;
   {
     // Insert the entry for the root into the metas table.
     const int64 now = Now();
-    SQLStatement statement;
+    sqlite_utils::SQLStatement statement;
     statement.prepare(load_dbhandle_,
                       "INSERT INTO metas "
                       "( id, metahandle, is_dir, ctime, mtime) "
                       "VALUES ( \"r\", 1, 1, ?, ?)");
     statement.bind_int64(0, now);
     statement.bind_int64(1, now);
     result = statement.step();
   }
   return result;
 }
@@ skipping 70 matching lines @@
       "id TEXT primary key, "
       "name TEXT, "
       "store_birthday TEXT, "
       "db_create_version TEXT, "
       "db_create_time INT, "
       "next_id INT default -2, "
       "cache_guid TEXT )");
   return ExecQuery(load_dbhandle_, query.c_str());
 }
 }  // namespace syncable