src/sql/connection.cc

   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@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 (file_util::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@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 (file_util::GetPosixFilePermissions(file_path, &mode)) {
 885       mode &= file_util::FILE_PERMISSION_USER_MASK;
 886       file_util::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       file_util::SetPosixFilePermissions(journal_path, mode);
 895       file_util::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 // TODO(shess): Allow specifying integrity_check versus quick_check.
1054 // TODO(shess): Allow specifying maximum results (default 100 lines).
1055 bool Connection::IntegrityCheck(std::vector<std::string>* messages) {
1056   messages->clear();
1057
1058   // This has the side effect of setting SQLITE_RecoveryMode, which
1059   // allows SQLite to process through certain cases of corruption.
1060   // Failing to set this pragma probably means that the database is
1061   // beyond recovery.
1062   const char kWritableSchema[] = "PRAGMA writable_schema = ON";
1063   if (!Execute(kWritableSchema))
1064     return false;
1065
1066   bool ret = false;
1067   {
1068     const char kSql[] = "PRAGMA integrity_check";
1069     sql::Statement stmt(GetUniqueStatement(kSql));
1070
1071     // The pragma appears to return all results (up to 100 by default)
1072     // as a single string.  This doesn't appear to be an API contract,
1073     // it could return separate lines, so loop _and_ split.
1074     while (stmt.Step()) {
1075       std::string result(stmt.ColumnString(0));
1076       base::SplitString(result, '\n', messages);
1077     }
1078     ret = stmt.Succeeded();
1079   }
1080
1081   // Best effort to put things back as they were before.
1082   const char kNoWritableSchema[] = "PRAGMA writable_schema = OFF";
1083   ignore_result(Execute(kNoWritableSchema));
1084
1085   return ret;
1086 }
1087
1088 }  // namespace sql