Home | History | Annotate | Download | only in sql
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "sql/connection.h"
      6 
      7 #include <string.h>
      8 
      9 #include "base/files/file_path.h"
     10 #include "base/file_util.h"
     11 #include "base/lazy_instance.h"
     12 #include "base/logging.h"
     13 #include "base/metrics/histogram.h"
     14 #include "base/metrics/sparse_histogram.h"
     15 #include "base/strings/string_split.h"
     16 #include "base/strings/string_util.h"
     17 #include "base/strings/stringprintf.h"
     18 #include "base/strings/utf_string_conversions.h"
     19 #include "base/synchronization/lock.h"
     20 #include "sql/statement.h"
     21 #include "third_party/sqlite/sqlite3.h"
     22 
     23 #if defined(OS_IOS) && defined(USE_SYSTEM_SQLITE)
     24 #include "third_party/sqlite/src/ext/icu/sqliteicu.h"
     25 #endif
     26 
     27 namespace {
     28 
     29 // Spin for up to a second waiting for the lock to clear when setting
     30 // up the database.
     31 // TODO(shess): Better story on this.  http://crbug.com/56559
     32 const int kBusyTimeoutSeconds = 1;
     33 
     34 class ScopedBusyTimeout {
     35  public:
     36   explicit ScopedBusyTimeout(sqlite3* db)
     37       : db_(db) {
     38   }
     39   ~ScopedBusyTimeout() {
     40     sqlite3_busy_timeout(db_, 0);
     41   }
     42 
     43   int SetTimeout(base::TimeDelta timeout) {
     44     DCHECK_LT(timeout.InMilliseconds(), INT_MAX);
     45     return sqlite3_busy_timeout(db_,
     46                                 static_cast<int>(timeout.InMilliseconds()));
     47   }
     48 
     49  private:
     50   sqlite3* db_;
     51 };
     52 
     53 // Helper to "safely" enable writable_schema.  No error checking
     54 // because it is reasonable to just forge ahead in case of an error.
     55 // If turning it on fails, then most likely nothing will work, whereas
     56 // if turning it off fails, it only matters if some code attempts to
     57 // continue working with the database and tries to modify the
     58 // sqlite_master table (none of our code does this).
     59 class ScopedWritableSchema {
     60  public:
     61   explicit ScopedWritableSchema(sqlite3* db)
     62       : db_(db) {
     63     sqlite3_exec(db_, "PRAGMA writable_schema=1", NULL, NULL, NULL);
     64   }
     65   ~ScopedWritableSchema() {
     66     sqlite3_exec(db_, "PRAGMA writable_schema=0", NULL, NULL, NULL);
     67   }
     68 
     69  private:
     70   sqlite3* db_;
     71 };
     72 
     73 // Helper to wrap the sqlite3_backup_*() step of Raze().  Return
     74 // SQLite error code from running the backup step.
     75 int BackupDatabase(sqlite3* src, sqlite3* dst, const char* db_name) {
     76   DCHECK_NE(src, dst);
     77   sqlite3_backup* backup = sqlite3_backup_init(dst, db_name, src, db_name);
     78   if (!backup) {
     79     // Since this call only sets things up, this indicates a gross
     80     // error in SQLite.
     81     DLOG(FATAL) << "Unable to start sqlite3_backup(): " << sqlite3_errmsg(dst);
     82     return sqlite3_errcode(dst);
     83   }
     84 
     85   // -1 backs up the entire database.
     86   int rc = sqlite3_backup_step(backup, -1);
     87   int pages = sqlite3_backup_pagecount(backup);
     88   sqlite3_backup_finish(backup);
     89 
     90   // If successful, exactly one page should have been backed up.  If
     91   // this breaks, check this function to make sure assumptions aren't
     92   // being broken.
     93   if (rc == SQLITE_DONE)
     94     DCHECK_EQ(pages, 1);
     95 
     96   return rc;
     97 }
     98 
     99 // Be very strict on attachment point.  SQLite can handle a much wider
    100 // character set with appropriate quoting, but Chromium code should
    101 // just use clean names to start with.
    102 bool ValidAttachmentPoint(const char* attachment_point) {
    103   for (size_t i = 0; attachment_point[i]; ++i) {
    104     if (!((attachment_point[i] >= '0' && attachment_point[i] <= '9') ||
    105           (attachment_point[i] >= 'a' && attachment_point[i] <= 'z') ||
    106           (attachment_point[i] >= 'A' && attachment_point[i] <= 'Z') ||
    107           attachment_point[i] == '_')) {
    108       return false;
    109     }
    110   }
    111   return true;
    112 }
    113 
    114 // SQLite automatically calls sqlite3_initialize() lazily, but
    115 // sqlite3_initialize() uses double-checked locking and thus can have
    116 // data races.
    117 //
    118 // TODO(shess): Another alternative would be to have
    119 // sqlite3_initialize() called as part of process bring-up.  If this
    120 // is changed, remove the dynamic_annotations dependency in sql.gyp.
    121 base::LazyInstance<base::Lock>::Leaky
    122     g_sqlite_init_lock = LAZY_INSTANCE_INITIALIZER;
    123 void InitializeSqlite() {
    124   base::AutoLock lock(g_sqlite_init_lock.Get());
    125   sqlite3_initialize();
    126 }
    127 
    128 }  // namespace
    129 
    130 namespace sql {
    131 
    132 // static
    133 Connection::ErrorIgnorerCallback* Connection::current_ignorer_cb_ = NULL;
    134 
    135 // static
    136 bool Connection::ShouldIgnoreSqliteError(int error) {
    137   if (!current_ignorer_cb_)
    138     return false;
    139   return current_ignorer_cb_->Run(error);
    140 }
    141 
    142 // static
    143 void Connection::SetErrorIgnorer(Connection::ErrorIgnorerCallback* cb) {
    144   CHECK(current_ignorer_cb_ == NULL);
    145   current_ignorer_cb_ = cb;
    146 }
    147 
    148 // static
    149 void Connection::ResetErrorIgnorer() {
    150   CHECK(current_ignorer_cb_);
    151   current_ignorer_cb_ = NULL;
    152 }
    153 
    154 bool StatementID::operator<(const StatementID& other) const {
    155   if (number_ != other.number_)
    156     return number_ < other.number_;
    157   return strcmp(str_, other.str_) < 0;
    158 }
    159 
    160 Connection::StatementRef::StatementRef(Connection* connection,
    161                                        sqlite3_stmt* stmt,
    162                                        bool was_valid)
    163     : connection_(connection),
    164       stmt_(stmt),
    165       was_valid_(was_valid) {
    166   if (connection)
    167     connection_->StatementRefCreated(this);
    168 }
    169 
    170 Connection::StatementRef::~StatementRef() {
    171   if (connection_)
    172     connection_->StatementRefDeleted(this);
    173   Close(false);
    174 }
    175 
    176 void Connection::StatementRef::Close(bool forced) {
    177   if (stmt_) {
    178     // Call to AssertIOAllowed() cannot go at the beginning of the function
    179     // because Close() is called unconditionally from destructor to clean
    180     // connection_. And if this is inactive statement this won't cause any
    181     // disk access and destructor most probably will be called on thread
    182     // not allowing disk access.
    183     // TODO(paivanof (at) gmail.com): This should move to the beginning
    184     // of the function. http://crbug.com/136655.
    185     AssertIOAllowed();
    186     sqlite3_finalize(stmt_);
    187     stmt_ = NULL;
    188   }
    189   connection_ = NULL;  // The connection may be getting deleted.
    190 
    191   // Forced close is expected to happen from a statement error
    192   // handler.  In that case maintain the sense of |was_valid_| which
    193   // previously held for this ref.
    194   was_valid_ = was_valid_ && forced;
    195 }
    196 
    197 Connection::Connection()
    198     : db_(NULL),
    199       page_size_(0),
    200       cache_size_(0),
    201       exclusive_locking_(false),
    202       restrict_to_user_(false),
    203       transaction_nesting_(0),
    204       needs_rollback_(false),
    205       in_memory_(false),
    206       poisoned_(false) {
    207 }
    208 
    209 Connection::~Connection() {
    210   Close();
    211 }
    212 
    213 bool Connection::Open(const base::FilePath& path) {
    214   if (!histogram_tag_.empty()) {
    215     int64 size_64 = 0;
    216     if (base::GetFileSize(path, &size_64)) {
    217       size_t sample = static_cast<size_t>(size_64 / 1024);
    218       std::string full_histogram_name = "Sqlite.SizeKB." + histogram_tag_;
    219       base::HistogramBase* histogram =
    220           base::Histogram::FactoryGet(
    221               full_histogram_name, 1, 1000000, 50,
    222               base::HistogramBase::kUmaTargetedHistogramFlag);
    223       if (histogram)
    224         histogram->Add(sample);
    225     }
    226   }
    227 
    228 #if defined(OS_WIN)
    229   return OpenInternal(WideToUTF8(path.value()), RETRY_ON_POISON);
    230 #elif defined(OS_POSIX)
    231   return OpenInternal(path.value(), RETRY_ON_POISON);
    232 #endif
    233 }
    234 
    235 bool Connection::OpenInMemory() {
    236   in_memory_ = true;
    237   return OpenInternal(":memory:", NO_RETRY);
    238 }
    239 
    240 bool Connection::OpenTemporary() {
    241   return OpenInternal("", NO_RETRY);
    242 }
    243 
    244 void Connection::CloseInternal(bool forced) {
    245   // TODO(shess): Calling "PRAGMA journal_mode = DELETE" at this point
    246   // will delete the -journal file.  For ChromiumOS or other more
    247   // embedded systems, this is probably not appropriate, whereas on
    248   // desktop it might make some sense.
    249 
    250   // sqlite3_close() needs all prepared statements to be finalized.
    251 
    252   // Release cached statements.
    253   statement_cache_.clear();
    254 
    255   // With cached statements released, in-use statements will remain.
    256   // Closing the database while statements are in use is an API
    257   // violation, except for forced close (which happens from within a
    258   // statement's error handler).
    259   DCHECK(forced || open_statements_.empty());
    260 
    261   // Deactivate any outstanding statements so sqlite3_close() works.
    262   for (StatementRefSet::iterator i = open_statements_.begin();
    263        i != open_statements_.end(); ++i)
    264     (*i)->Close(forced);
    265   open_statements_.clear();
    266 
    267   if (db_) {
    268     // Call to AssertIOAllowed() cannot go at the beginning of the function
    269     // because Close() must be called from destructor to clean
    270     // statement_cache_, it won't cause any disk access and it most probably
    271     // will happen on thread not allowing disk access.
    272     // TODO(paivanof (at) gmail.com): This should move to the beginning
    273     // of the function. http://crbug.com/136655.
    274     AssertIOAllowed();
    275 
    276     int rc = sqlite3_close(db_);
    277     if (rc != SQLITE_OK) {
    278       UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.CloseFailure", rc);
    279       DLOG(FATAL) << "sqlite3_close failed: " << GetErrorMessage();
    280     }
    281   }
    282   db_ = NULL;
    283 }
    284 
    285 void Connection::Close() {
    286   // If the database was already closed by RazeAndClose(), then no
    287   // need to close again.  Clear the |poisoned_| bit so that incorrect
    288   // API calls are caught.
    289   if (poisoned_) {
    290     poisoned_ = false;
    291     return;
    292   }
    293 
    294   CloseInternal(false);
    295 }
    296 
    297 void Connection::Preload() {
    298   AssertIOAllowed();
    299 
    300   if (!db_) {
    301     DLOG_IF(FATAL, !poisoned_) << "Cannot preload null db";
    302     return;
    303   }
    304 
    305   // A statement must be open for the preload command to work. If the meta
    306   // table doesn't exist, it probably means this is a new database and there
    307   // is nothing to preload (so it's OK we do nothing).
    308   if (!DoesTableExist("meta"))
    309     return;
    310   Statement dummy(GetUniqueStatement("SELECT * FROM meta"));
    311   if (!dummy.Step())
    312     return;
    313 
    314 #if !defined(USE_SYSTEM_SQLITE)
    315   // This function is only defined in Chromium's version of sqlite.
    316   // Do not call it when using system sqlite.
    317   sqlite3_preload(db_);
    318 #endif
    319 }
    320 
    321 void Connection::TrimMemory(bool aggressively) {
    322   if (!db_)
    323     return;
    324 
    325   // TODO(shess): investigate using sqlite3_db_release_memory() when possible.
    326   int original_cache_size;
    327   {
    328     Statement sql_get_original(GetUniqueStatement("PRAGMA cache_size"));
    329     if (!sql_get_original.Step()) {
    330       DLOG(WARNING) << "Could not get cache size " << GetErrorMessage();
    331       return;
    332     }
    333     original_cache_size = sql_get_original.ColumnInt(0);
    334   }
    335   int shrink_cache_size = aggressively ? 1 : (original_cache_size / 2);
    336 
    337   // Force sqlite to try to reduce page cache usage.
    338   const std::string sql_shrink =
    339       base::StringPrintf("PRAGMA cache_size=%d", shrink_cache_size);
    340   if (!Execute(sql_shrink.c_str()))
    341     DLOG(WARNING) << "Could not shrink cache size: " << GetErrorMessage();
    342 
    343   // Restore cache size.
    344   const std::string sql_restore =
    345       base::StringPrintf("PRAGMA cache_size=%d", original_cache_size);
    346   if (!Execute(sql_restore.c_str()))
    347     DLOG(WARNING) << "Could not restore cache size: " << GetErrorMessage();
    348 }
    349 
    350 // Create an in-memory database with the existing database's page
    351 // size, then backup that database over the existing database.
    352 bool Connection::Raze() {
    353   AssertIOAllowed();
    354 
    355   if (!db_) {
    356     DLOG_IF(FATAL, !poisoned_) << "Cannot raze null db";
    357     return false;
    358   }
    359 
    360   if (transaction_nesting_ > 0) {
    361     DLOG(FATAL) << "Cannot raze within a transaction";
    362     return false;
    363   }
    364 
    365   sql::Connection null_db;
    366   if (!null_db.OpenInMemory()) {
    367     DLOG(FATAL) << "Unable to open in-memory database.";
    368     return false;
    369   }
    370 
    371   if (page_size_) {
    372     // Enforce SQLite restrictions on |page_size_|.
    373     DCHECK(!(page_size_ & (page_size_ - 1)))
    374         << " page_size_ " << page_size_ << " is not a power of two.";
    375     const int kSqliteMaxPageSize = 32768;  // from sqliteLimit.h
    376     DCHECK_LE(page_size_, kSqliteMaxPageSize);
    377     const std::string sql =
    378         base::StringPrintf("PRAGMA page_size=%d", page_size_);
    379     if (!null_db.Execute(sql.c_str()))
    380       return false;
    381   }
    382 
    383 #if defined(OS_ANDROID)
    384   // Android compiles with SQLITE_DEFAULT_AUTOVACUUM.  Unfortunately,
    385   // in-memory databases do not respect this define.
    386   // TODO(shess): Figure out a way to set this without using platform
    387   // specific code.  AFAICT from sqlite3.c, the only way to do it
    388   // would be to create an actual filesystem database, which is
    389   // unfortunate.
    390   if (!null_db.Execute("PRAGMA auto_vacuum = 1"))
    391     return false;
    392 #endif
    393 
    394   // The page size doesn't take effect until a database has pages, and
    395   // at this point the null database has none.  Changing the schema
    396   // version will create the first page.  This will not affect the
    397   // schema version in the resulting database, as SQLite's backup
    398   // implementation propagates the schema version from the original
    399   // connection to the new version of the database, incremented by one
    400   // so that other readers see the schema change and act accordingly.
    401   if (!null_db.Execute("PRAGMA schema_version = 1"))
    402     return false;
    403 
    404   // SQLite tracks the expected number of database pages in the first
    405   // page, and if it does not match the total retrieved from a
    406   // filesystem call, treats the database as corrupt.  This situation
    407   // breaks almost all SQLite calls.  "PRAGMA writable_schema" can be
    408   // used to hint to SQLite to soldier on in that case, specifically
    409   // for purposes of recovery.  [See SQLITE_CORRUPT_BKPT case in
    410   // sqlite3.c lockBtree().]
    411   // TODO(shess): With this, "PRAGMA auto_vacuum" and "PRAGMA
    412   // page_size" can be used to query such a database.
    413   ScopedWritableSchema writable_schema(db_);
    414 
    415   const char* kMain = "main";
    416   int rc = BackupDatabase(null_db.db_, db_, kMain);
    417   UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.RazeDatabase",rc);
    418 
    419   // The destination database was locked.
    420   if (rc == SQLITE_BUSY) {
    421     return false;
    422   }
    423 
    424   // SQLITE_NOTADB can happen if page 1 of db_ exists, but is not
    425   // formatted correctly.  SQLITE_IOERR_SHORT_READ can happen if db_
    426   // isn't even big enough for one page.  Either way, reach in and
    427   // truncate it before trying again.
    428   // TODO(shess): Maybe it would be worthwhile to just truncate from
    429   // the get-go?
    430   if (rc == SQLITE_NOTADB || rc == SQLITE_IOERR_SHORT_READ) {
    431     sqlite3_file* file = NULL;
    432     rc = sqlite3_file_control(db_, "main", SQLITE_FCNTL_FILE_POINTER, &file);
    433     if (rc != SQLITE_OK) {
    434       DLOG(FATAL) << "Failure getting file handle.";
    435       return false;
    436     } else if (!file) {
    437       DLOG(FATAL) << "File handle is empty.";
    438       return false;
    439     }
    440 
    441     rc = file->pMethods->xTruncate(file, 0);
    442     if (rc != SQLITE_OK) {
    443       UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.RazeDatabaseTruncate",rc);
    444       DLOG(FATAL) << "Failed to truncate file.";
    445       return false;
    446     }
    447 
    448     rc = BackupDatabase(null_db.db_, db_, kMain);
    449     UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.RazeDatabase2",rc);
    450 
    451     if (rc != SQLITE_DONE) {
    452       DLOG(FATAL) << "Failed retrying Raze().";
    453     }
    454   }
    455 
    456   // The entire database should have been backed up.
    457   if (rc != SQLITE_DONE) {
    458     // TODO(shess): Figure out which other cases can happen.
    459     DLOG(FATAL) << "Unable to copy entire null database.";
    460     return false;
    461   }
    462 
    463   return true;
    464 }
    465 
    466 bool Connection::RazeWithTimout(base::TimeDelta timeout) {
    467   if (!db_) {
    468     DLOG_IF(FATAL, !poisoned_) << "Cannot raze null db";
    469     return false;
    470   }
    471 
    472   ScopedBusyTimeout busy_timeout(db_);
    473   busy_timeout.SetTimeout(timeout);
    474   return Raze();
    475 }
    476 
    477 bool Connection::RazeAndClose() {
    478   if (!db_) {
    479     DLOG_IF(FATAL, !poisoned_) << "Cannot raze null db";
    480     return false;
    481   }
    482 
    483   // Raze() cannot run in a transaction.
    484   RollbackAllTransactions();
    485 
    486   bool result = Raze();
    487 
    488   CloseInternal(true);
    489 
    490   // Mark the database so that future API calls fail appropriately,
    491   // but don't DCHECK (because after calling this function they are
    492   // expected to fail).
    493   poisoned_ = true;
    494 
    495   return result;
    496 }
    497 
    498 void Connection::Poison() {
    499   if (!db_) {
    500     DLOG_IF(FATAL, !poisoned_) << "Cannot poison null db";
    501     return;
    502   }
    503 
    504   RollbackAllTransactions();
    505   CloseInternal(true);
    506 
    507   // Mark the database so that future API calls fail appropriately,
    508   // but don't DCHECK (because after calling this function they are
    509   // expected to fail).
    510   poisoned_ = true;
    511 }
    512 
    513 // TODO(shess): To the extent possible, figure out the optimal
    514 // ordering for these deletes which will prevent other connections
    515 // from seeing odd behavior.  For instance, it may be necessary to
    516 // manually lock the main database file in a SQLite-compatible fashion
    517 // (to prevent other processes from opening it), then delete the
    518 // journal files, then delete the main database file.  Another option
    519 // might be to lock the main database file and poison the header with
    520 // junk to prevent other processes from opening it successfully (like
    521 // Gears "SQLite poison 3" trick).
    522 //
    523 // static
    524 bool Connection::Delete(const base::FilePath& path) {
    525   base::ThreadRestrictions::AssertIOAllowed();
    526 
    527   base::FilePath journal_path(path.value() + FILE_PATH_LITERAL("-journal"));
    528   base::FilePath wal_path(path.value() + FILE_PATH_LITERAL("-wal"));
    529 
    530   base::DeleteFile(journal_path, false);
    531   base::DeleteFile(wal_path, false);
    532   base::DeleteFile(path, false);
    533 
    534   return !base::PathExists(journal_path) &&
    535       !base::PathExists(wal_path) &&
    536       !base::PathExists(path);
    537 }
    538 
    539 bool Connection::BeginTransaction() {
    540   if (needs_rollback_) {
    541     DCHECK_GT(transaction_nesting_, 0);
    542 
    543     // When we're going to rollback, fail on this begin and don't actually
    544     // mark us as entering the nested transaction.
    545     return false;
    546   }
    547 
    548   bool success = true;
    549   if (!transaction_nesting_) {
    550     needs_rollback_ = false;
    551 
    552     Statement begin(GetCachedStatement(SQL_FROM_HERE, "BEGIN TRANSACTION"));
    553     if (!begin.Run())
    554       return false;
    555   }
    556   transaction_nesting_++;
    557   return success;
    558 }
    559 
    560 void Connection::RollbackTransaction() {
    561   if (!transaction_nesting_) {
    562     DLOG_IF(FATAL, !poisoned_) << "Rolling back a nonexistent transaction";
    563     return;
    564   }
    565 
    566   transaction_nesting_--;
    567 
    568   if (transaction_nesting_ > 0) {
    569     // Mark the outermost transaction as needing rollback.
    570     needs_rollback_ = true;
    571     return;
    572   }
    573 
    574   DoRollback();
    575 }
    576 
    577 bool Connection::CommitTransaction() {
    578   if (!transaction_nesting_) {
    579     DLOG_IF(FATAL, !poisoned_) << "Rolling back a nonexistent transaction";
    580     return false;
    581   }
    582   transaction_nesting_--;
    583 
    584   if (transaction_nesting_ > 0) {
    585     // Mark any nested transactions as failing after we've already got one.
    586     return !needs_rollback_;
    587   }
    588 
    589   if (needs_rollback_) {
    590     DoRollback();
    591     return false;
    592   }
    593 
    594   Statement commit(GetCachedStatement(SQL_FROM_HERE, "COMMIT"));
    595   return commit.Run();
    596 }
    597 
    598 void Connection::RollbackAllTransactions() {
    599   if (transaction_nesting_ > 0) {
    600     transaction_nesting_ = 0;
    601     DoRollback();
    602   }
    603 }
    604 
    605 bool Connection::AttachDatabase(const base::FilePath& other_db_path,
    606                                 const char* attachment_point) {
    607   DCHECK(ValidAttachmentPoint(attachment_point));
    608 
    609   Statement s(GetUniqueStatement("ATTACH DATABASE ? AS ?"));
    610 #if OS_WIN
    611   s.BindString16(0, other_db_path.value());
    612 #else
    613   s.BindString(0, other_db_path.value());
    614 #endif
    615   s.BindString(1, attachment_point);
    616   return s.Run();
    617 }
    618 
    619 bool Connection::DetachDatabase(const char* attachment_point) {
    620   DCHECK(ValidAttachmentPoint(attachment_point));
    621 
    622   Statement s(GetUniqueStatement("DETACH DATABASE ?"));
    623   s.BindString(0, attachment_point);
    624   return s.Run();
    625 }
    626 
    627 int Connection::ExecuteAndReturnErrorCode(const char* sql) {
    628   AssertIOAllowed();
    629   if (!db_) {
    630     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
    631     return SQLITE_ERROR;
    632   }
    633   return sqlite3_exec(db_, sql, NULL, NULL, NULL);
    634 }
    635 
    636 bool Connection::Execute(const char* sql) {
    637   if (!db_) {
    638     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
    639     return false;
    640   }
    641 
    642   int error = ExecuteAndReturnErrorCode(sql);
    643   if (error != SQLITE_OK)
    644     error = OnSqliteError(error, NULL, sql);
    645 
    646   // This needs to be a FATAL log because the error case of arriving here is
    647   // that there's a malformed SQL statement. This can arise in development if
    648   // a change alters the schema but not all queries adjust.  This can happen
    649   // in production if the schema is corrupted.
    650   if (error == SQLITE_ERROR)
    651     DLOG(FATAL) << "SQL Error in " << sql << ", " << GetErrorMessage();
    652   return error == SQLITE_OK;
    653 }
    654 
    655 bool Connection::ExecuteWithTimeout(const char* sql, base::TimeDelta timeout) {
    656   if (!db_) {
    657     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
    658     return false;
    659   }
    660 
    661   ScopedBusyTimeout busy_timeout(db_);
    662   busy_timeout.SetTimeout(timeout);
    663   return Execute(sql);
    664 }
    665 
    666 bool Connection::HasCachedStatement(const StatementID& id) const {
    667   return statement_cache_.find(id) != statement_cache_.end();
    668 }
    669 
    670 scoped_refptr<Connection::StatementRef> Connection::GetCachedStatement(
    671     const StatementID& id,
    672     const char* sql) {
    673   CachedStatementMap::iterator i = statement_cache_.find(id);
    674   if (i != statement_cache_.end()) {
    675     // Statement is in the cache. It should still be active (we're the only
    676     // one invalidating cached statements, and we'll remove it from the cache
    677     // if we do that. Make sure we reset it before giving out the cached one in
    678     // case it still has some stuff bound.
    679     DCHECK(i->second->is_valid());
    680     sqlite3_reset(i->second->stmt());
    681     return i->second;
    682   }
    683 
    684   scoped_refptr<StatementRef> statement = GetUniqueStatement(sql);
    685   if (statement->is_valid())
    686     statement_cache_[id] = statement;  // Only cache valid statements.
    687   return statement;
    688 }
    689 
    690 scoped_refptr<Connection::StatementRef> Connection::GetUniqueStatement(
    691     const char* sql) {
    692   AssertIOAllowed();
    693 
    694   // Return inactive statement.
    695   if (!db_)
    696     return new StatementRef(NULL, NULL, poisoned_);
    697 
    698   sqlite3_stmt* stmt = NULL;
    699   int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
    700   if (rc != SQLITE_OK) {
    701     // This is evidence of a syntax error in the incoming SQL.
    702     DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
    703 
    704     // It could also be database corruption.
    705     OnSqliteError(rc, NULL, sql);
    706     return new StatementRef(NULL, NULL, false);
    707   }
    708   return new StatementRef(this, stmt, true);
    709 }
    710 
    711 scoped_refptr<Connection::StatementRef> Connection::GetUntrackedStatement(
    712     const char* sql) const {
    713   // Return inactive statement.
    714   if (!db_)
    715     return new StatementRef(NULL, NULL, poisoned_);
    716 
    717   sqlite3_stmt* stmt = NULL;
    718   int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
    719   if (rc != SQLITE_OK) {
    720     // This is evidence of a syntax error in the incoming SQL.
    721     DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
    722     return new StatementRef(NULL, NULL, false);
    723   }
    724   return new StatementRef(NULL, stmt, true);
    725 }
    726 
    727 std::string Connection::GetSchema() const {
    728   // The ORDER BY should not be necessary, but relying on organic
    729   // order for something like this is questionable.
    730   const char* kSql =
    731       "SELECT type, name, tbl_name, sql "
    732       "FROM sqlite_master ORDER BY 1, 2, 3, 4";
    733   Statement statement(GetUntrackedStatement(kSql));
    734 
    735   std::string schema;
    736   while (statement.Step()) {
    737     schema += statement.ColumnString(0);
    738     schema += '|';
    739     schema += statement.ColumnString(1);
    740     schema += '|';
    741     schema += statement.ColumnString(2);
    742     schema += '|';
    743     schema += statement.ColumnString(3);
    744     schema += '\n';
    745   }
    746 
    747   return schema;
    748 }
    749 
    750 bool Connection::IsSQLValid(const char* sql) {
    751   AssertIOAllowed();
    752   if (!db_) {
    753     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
    754     return false;
    755   }
    756 
    757   sqlite3_stmt* stmt = NULL;
    758   if (sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL) != SQLITE_OK)
    759     return false;
    760 
    761   sqlite3_finalize(stmt);
    762   return true;
    763 }
    764 
    765 bool Connection::DoesTableExist(const char* table_name) const {
    766   return DoesTableOrIndexExist(table_name, "table");
    767 }
    768 
    769 bool Connection::DoesIndexExist(const char* index_name) const {
    770   return DoesTableOrIndexExist(index_name, "index");
    771 }
    772 
    773 bool Connection::DoesTableOrIndexExist(
    774     const char* name, const char* type) const {
    775   const char* kSql = "SELECT name FROM sqlite_master WHERE type=? AND name=?";
    776   Statement statement(GetUntrackedStatement(kSql));
    777   statement.BindString(0, type);
    778   statement.BindString(1, name);
    779 
    780   return statement.Step();  // Table exists if any row was returned.
    781 }
    782 
    783 bool Connection::DoesColumnExist(const char* table_name,
    784                                  const char* column_name) const {
    785   std::string sql("PRAGMA TABLE_INFO(");
    786   sql.append(table_name);
    787   sql.append(")");
    788 
    789   Statement statement(GetUntrackedStatement(sql.c_str()));
    790   while (statement.Step()) {
    791     if (!statement.ColumnString(1).compare(column_name))
    792       return true;
    793   }
    794   return false;
    795 }
    796 
    797 int64 Connection::GetLastInsertRowId() const {
    798   if (!db_) {
    799     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
    800     return 0;
    801   }
    802   return sqlite3_last_insert_rowid(db_);
    803 }
    804 
    805 int Connection::GetLastChangeCount() const {
    806   if (!db_) {
    807     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
    808     return 0;
    809   }
    810   return sqlite3_changes(db_);
    811 }
    812 
    813 int Connection::GetErrorCode() const {
    814   if (!db_)
    815     return SQLITE_ERROR;
    816   return sqlite3_errcode(db_);
    817 }
    818 
    819 int Connection::GetLastErrno() const {
    820   if (!db_)
    821     return -1;
    822 
    823   int err = 0;
    824   if (SQLITE_OK != sqlite3_file_control(db_, NULL, SQLITE_LAST_ERRNO, &err))
    825     return -2;
    826 
    827   return err;
    828 }
    829 
    830 const char* Connection::GetErrorMessage() const {
    831   if (!db_)
    832     return "sql::Connection has no connection.";
    833   return sqlite3_errmsg(db_);
    834 }
    835 
    836 bool Connection::OpenInternal(const std::string& file_name,
    837                               Connection::Retry retry_flag) {
    838   AssertIOAllowed();
    839 
    840   if (db_) {
    841     DLOG(FATAL) << "sql::Connection is already open.";
    842     return false;
    843   }
    844 
    845   // Make sure sqlite3_initialize() is called before anything else.
    846   InitializeSqlite();
    847 
    848   // If |poisoned_| is set, it means an error handler called
    849   // RazeAndClose().  Until regular Close() is called, the caller
    850   // should be treating the database as open, but is_open() currently
    851   // only considers the sqlite3 handle's state.
    852   // TODO(shess): Revise is_open() to consider poisoned_, and review
    853   // to see if any non-testing code even depends on it.
    854   DLOG_IF(FATAL, poisoned_) << "sql::Connection is already open.";
    855   poisoned_ = false;
    856 
    857   int err = sqlite3_open(file_name.c_str(), &db_);
    858   if (err != SQLITE_OK) {
    859     // Extended error codes cannot be enabled until a handle is
    860     // available, fetch manually.
    861     err = sqlite3_extended_errcode(db_);
    862 
    863     // Histogram failures specific to initial open for debugging
    864     // purposes.
    865     UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.OpenFailure", err);
    866 
    867     OnSqliteError(err, NULL, "-- sqlite3_open()");
    868     bool was_poisoned = poisoned_;
    869     Close();
    870 
    871     if (was_poisoned && retry_flag == RETRY_ON_POISON)
    872       return OpenInternal(file_name, NO_RETRY);
    873     return false;
    874   }
    875 
    876   // TODO(shess): OS_WIN support?
    877 #if defined(OS_POSIX)
    878   if (restrict_to_user_) {
    879     DCHECK_NE(file_name, std::string(":memory"));
    880     base::FilePath file_path(file_name);
    881     int mode = 0;
    882     // TODO(shess): Arguably, failure to retrieve and change
    883     // permissions should be fatal if the file exists.
    884     if (base::GetPosixFilePermissions(file_path, &mode)) {
    885       mode &= base::FILE_PERMISSION_USER_MASK;
    886       base::SetPosixFilePermissions(file_path, mode);
    887 
    888       // SQLite sets the permissions on these files from the main
    889       // database on create.  Set them here in case they already exist
    890       // at this point.  Failure to set these permissions should not
    891       // be fatal unless the file doesn't exist.
    892       base::FilePath journal_path(file_name + FILE_PATH_LITERAL("-journal"));
    893       base::FilePath wal_path(file_name + FILE_PATH_LITERAL("-wal"));
    894       base::SetPosixFilePermissions(journal_path, mode);
    895       base::SetPosixFilePermissions(wal_path, mode);
    896     }
    897   }
    898 #endif  // defined(OS_POSIX)
    899 
    900   // SQLite uses a lookaside buffer to improve performance of small mallocs.
    901   // Chromium already depends on small mallocs being efficient, so we disable
    902   // this to avoid the extra memory overhead.
    903   // This must be called immediatly after opening the database before any SQL
    904   // statements are run.
    905   sqlite3_db_config(db_, SQLITE_DBCONFIG_LOOKASIDE, NULL, 0, 0);
    906 
    907   // Enable extended result codes to provide more color on I/O errors.
    908   // Not having extended result codes is not a fatal problem, as
    909   // Chromium code does not attempt to handle I/O errors anyhow.  The
    910   // current implementation always returns SQLITE_OK, the DCHECK is to
    911   // quickly notify someone if SQLite changes.
    912   err = sqlite3_extended_result_codes(db_, 1);
    913   DCHECK_EQ(err, SQLITE_OK) << "Could not enable extended result codes";
    914 
    915   // sqlite3_open() does not actually read the database file (unless a
    916   // hot journal is found).  Successfully executing this pragma on an
    917   // existing database requires a valid header on page 1.
    918   // TODO(shess): For now, just probing to see what the lay of the
    919   // land is.  If it's mostly SQLITE_NOTADB, then the database should
    920   // be razed.
    921   err = ExecuteAndReturnErrorCode("PRAGMA auto_vacuum");
    922   if (err != SQLITE_OK)
    923     UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.OpenProbeFailure", err);
    924 
    925 #if defined(OS_IOS) && defined(USE_SYSTEM_SQLITE)
    926   // The version of SQLite shipped with iOS doesn't enable ICU, which includes
    927   // REGEXP support. Add it in dynamically.
    928   err = sqlite3IcuInit(db_);
    929   DCHECK_EQ(err, SQLITE_OK) << "Could not enable ICU support";
    930 #endif  // OS_IOS && USE_SYSTEM_SQLITE
    931 
    932   // If indicated, lock up the database before doing anything else, so
    933   // that the following code doesn't have to deal with locking.
    934   // TODO(shess): This code is brittle.  Find the cases where code
    935   // doesn't request |exclusive_locking_| and audit that it does the
    936   // right thing with SQLITE_BUSY, and that it doesn't make
    937   // assumptions about who might change things in the database.
    938   // http://crbug.com/56559
    939   if (exclusive_locking_) {
    940     // TODO(shess): This should probably be a failure.  Code which
    941     // requests exclusive locking but doesn't get it is almost certain
    942     // to be ill-tested.
    943     ignore_result(Execute("PRAGMA locking_mode=EXCLUSIVE"));
    944   }
    945 
    946   // http://www.sqlite.org/pragma.html#pragma_journal_mode
    947   // DELETE (default) - delete -journal file to commit.
    948   // TRUNCATE - truncate -journal file to commit.
    949   // PERSIST - zero out header of -journal file to commit.
    950   // journal_size_limit provides size to trim to in PERSIST.
    951   // TODO(shess): Figure out if PERSIST and journal_size_limit really
    952   // matter.  In theory, it keeps pages pre-allocated, so if
    953   // transactions usually fit, it should be faster.
    954   ignore_result(Execute("PRAGMA journal_mode = PERSIST"));
    955   ignore_result(Execute("PRAGMA journal_size_limit = 16384"));
    956 
    957   const base::TimeDelta kBusyTimeout =
    958     base::TimeDelta::FromSeconds(kBusyTimeoutSeconds);
    959 
    960   if (page_size_ != 0) {
    961     // Enforce SQLite restrictions on |page_size_|.
    962     DCHECK(!(page_size_ & (page_size_ - 1)))
    963         << " page_size_ " << page_size_ << " is not a power of two.";
    964     const int kSqliteMaxPageSize = 32768;  // from sqliteLimit.h
    965     DCHECK_LE(page_size_, kSqliteMaxPageSize);
    966     const std::string sql =
    967         base::StringPrintf("PRAGMA page_size=%d", page_size_);
    968     ignore_result(ExecuteWithTimeout(sql.c_str(), kBusyTimeout));
    969   }
    970 
    971   if (cache_size_ != 0) {
    972     const std::string sql =
    973         base::StringPrintf("PRAGMA cache_size=%d", cache_size_);
    974     ignore_result(ExecuteWithTimeout(sql.c_str(), kBusyTimeout));
    975   }
    976 
    977   if (!ExecuteWithTimeout("PRAGMA secure_delete=ON", kBusyTimeout)) {
    978     bool was_poisoned = poisoned_;
    979     Close();
    980     if (was_poisoned && retry_flag == RETRY_ON_POISON)
    981       return OpenInternal(file_name, NO_RETRY);
    982     return false;
    983   }
    984 
    985   return true;
    986 }
    987 
    988 void Connection::DoRollback() {
    989   Statement rollback(GetCachedStatement(SQL_FROM_HERE, "ROLLBACK"));
    990   rollback.Run();
    991   needs_rollback_ = false;
    992 }
    993 
    994 void Connection::StatementRefCreated(StatementRef* ref) {
    995   DCHECK(open_statements_.find(ref) == open_statements_.end());
    996   open_statements_.insert(ref);
    997 }
    998 
    999 void Connection::StatementRefDeleted(StatementRef* ref) {
   1000   StatementRefSet::iterator i = open_statements_.find(ref);
   1001   if (i == open_statements_.end())
   1002     DLOG(FATAL) << "Could not find statement";
   1003   else
   1004     open_statements_.erase(i);
   1005 }
   1006 
   1007 void Connection::AddTaggedHistogram(const std::string& name,
   1008                                     size_t sample) const {
   1009   if (histogram_tag_.empty())
   1010     return;
   1011 
   1012   // TODO(shess): The histogram macros create a bit of static storage
   1013   // for caching the histogram object.  This code shouldn't execute
   1014   // often enough for such caching to be crucial.  If it becomes an
   1015   // issue, the object could be cached alongside histogram_prefix_.
   1016   std::string full_histogram_name = name + "." + histogram_tag_;
   1017   base::HistogramBase* histogram =
   1018       base::SparseHistogram::FactoryGet(
   1019           full_histogram_name,
   1020           base::HistogramBase::kUmaTargetedHistogramFlag);
   1021   if (histogram)
   1022     histogram->Add(sample);
   1023 }
   1024 
   1025 int Connection::OnSqliteError(int err, sql::Statement *stmt, const char* sql) {
   1026   UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.Error", err);
   1027   AddTaggedHistogram("Sqlite.Error", err);
   1028 
   1029   // Always log the error.
   1030   if (!sql && stmt)
   1031     sql = stmt->GetSQLStatement();
   1032   if (!sql)
   1033     sql = "-- unknown";
   1034   LOG(ERROR) << histogram_tag_ << " sqlite error " << err
   1035              << ", errno " << GetLastErrno()
   1036              << ": " << GetErrorMessage()
   1037              << ", sql: " << sql;
   1038 
   1039   if (!error_callback_.is_null()) {
   1040     // Fire from a copy of the callback in case of reentry into
   1041     // re/set_error_callback().
   1042     // TODO(shess): <http://crbug.com/254584>
   1043     ErrorCallback(error_callback_).Run(err, stmt);
   1044     return err;
   1045   }
   1046 
   1047   // The default handling is to assert on debug and to ignore on release.
   1048   if (!ShouldIgnoreSqliteError(err))
   1049     DLOG(FATAL) << GetErrorMessage();
   1050   return err;
   1051 }
   1052 
   1053 bool Connection::FullIntegrityCheck(std::vector<std::string>* messages) {
   1054   return IntegrityCheckHelper("PRAGMA integrity_check", messages);
   1055 }
   1056 
   1057 bool Connection::QuickIntegrityCheck() {
   1058   std::vector<std::string> messages;
   1059   if (!IntegrityCheckHelper("PRAGMA quick_check", &messages))
   1060     return false;
   1061   return messages.size() == 1 && messages[0] == "ok";
   1062 }
   1063 
   1064 // TODO(shess): Allow specifying maximum results (default 100 lines).
   1065 bool Connection::IntegrityCheckHelper(
   1066     const char* pragma_sql,
   1067     std::vector<std::string>* messages) {
   1068   messages->clear();
   1069 
   1070   // This has the side effect of setting SQLITE_RecoveryMode, which
   1071   // allows SQLite to process through certain cases of corruption.
   1072   // Failing to set this pragma probably means that the database is
   1073   // beyond recovery.
   1074   const char kWritableSchema[] = "PRAGMA writable_schema = ON";
   1075   if (!Execute(kWritableSchema))
   1076     return false;
   1077 
   1078   bool ret = false;
   1079   {
   1080     sql::Statement stmt(GetUniqueStatement(pragma_sql));
   1081 
   1082     // The pragma appears to return all results (up to 100 by default)
   1083     // as a single string.  This doesn't appear to be an API contract,
   1084     // it could return separate lines, so loop _and_ split.
   1085     while (stmt.Step()) {
   1086       std::string result(stmt.ColumnString(0));
   1087       base::SplitString(result, '\n', messages);
   1088     }
   1089     ret = stmt.Succeeded();
   1090   }
   1091 
   1092   // Best effort to put things back as they were before.
   1093   const char kNoWritableSchema[] = "PRAGMA writable_schema = OFF";
   1094   ignore_result(Execute(kNoWritableSchema));
   1095 
   1096   return ret;
   1097 }
   1098 
   1099 }  // namespace sql
   1100