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