[sql] Differentiate compile errors from regular errors.

sql/connection.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sql/connection.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/debug/dump_without_crashing.h"
@@ skipping 214 matching lines @@
 // static
 Connection::ErrorIgnorerCallback* Connection::current_ignorer_cb_ = NULL;
 
 // static
 bool Connection::ShouldIgnoreSqliteError(int error) {
   if (!current_ignorer_cb_)
     return false;
   return current_ignorer_cb_->Run(error);
 }
 
+// static
+bool Connection::ShouldIgnoreSqliteCompileError(int error) {
+  // Put this first in case tests need to see that the check happened.
+  if (ShouldIgnoreSqliteError(error))
+    return true;
+
+  // Trim extended error codes.
+  int basic_error = error & 0xff;
+
+  // These errors relate more to the runtime context of the system than to
+  // errors with a SQL statement or with the schema, so they aren't generally
+  // interesting to flag.  This list is not comprehensive.
+  return basic_error == SQLITE_BUSY ||
+      basic_error == SQLITE_NOTADB ||
+      basic_error == SQLITE_CORRUPT;
+}
+
 bool Connection::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                               base::trace_event::ProcessMemoryDump* pmd) {
   if (args.level_of_detail ==
           base::trace_event::MemoryDumpLevelOfDetail::LIGHT ||
       !db_) {
     return true;
   }
 
   // The high water mark is not tracked for the following usages.
   int cache_size, dummy_int;
@@ skipping 1087 matching lines @@
   AssertIOAllowed();
 
   // Return inactive statement.
   if (!db_)
     return new StatementRef(NULL, NULL, poisoned_);
 
   sqlite3_stmt* stmt = NULL;
   int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
   if (rc != SQLITE_OK) {
     // This is evidence of a syntax error in the incoming SQL.
-    if (!ShouldIgnoreSqliteError(rc))
+    if (!ShouldIgnoreSqliteCompileError(rc))
       DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
 
     // It could also be database corruption.
     OnSqliteError(rc, NULL, sql);
     return new StatementRef(NULL, NULL, false);
   }
   return new StatementRef(this, stmt, true);
 }
 
+// TODO(shess): Unify this with GetUniqueStatement().  The only difference that
+// seems legitimate is not passing |this| to StatementRef.
 scoped_refptr<Connection::StatementRef> Connection::GetUntrackedStatement(
     const char* sql) const {
   // Return inactive statement.
   if (!db_)
     return new StatementRef(NULL, NULL, poisoned_);
 
   sqlite3_stmt* stmt = NULL;
   int rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, NULL);
   if (rc != SQLITE_OK) {
     // This is evidence of a syntax error in the incoming SQL.
-    if (!ShouldIgnoreSqliteError(rc))
+    if (!ShouldIgnoreSqliteCompileError(rc))
       DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
     return new StatementRef(NULL, NULL, false);
   }
   return new StatementRef(NULL, stmt, true);
 }
 
 std::string Connection::GetSchema() const {
   // The ORDER BY should not be necessary, but relying on organic
   // order for something like this is questionable.
   const char* kSql =
@@ skipping 386 matching lines @@
 
 int Connection::OnSqliteError(int err, sql::Statement *stmt, const char* sql) {
   UMA_HISTOGRAM_SPARSE_SLOWLY("Sqlite.Error", err);
   AddTaggedHistogram("Sqlite.Error", err);
 
   // Always log the error.
   if (!sql && stmt)
     sql = stmt->GetSQLStatement();
   if (!sql)
     sql = "-- unknown";
-  LOG(ERROR) << histogram_tag_ << " sqlite error " << err
+
+  std::string id = histogram_tag_;
+  if (id.empty())
+    id = DbPath().BaseName().AsUTF8Unsafe();
+  LOG(ERROR) << id << " sqlite error " << err
              << ", errno " << GetLastErrno()
              << ": " << GetErrorMessage()
              << ", sql: " << sql;
 
   if (!error_callback_.is_null()) {
     // Fire from a copy of the callback in case of reentry into
     // re/set_error_callback().
     // TODO(shess): <http://crbug.com/254584>
     ErrorCallback(error_callback_).Run(err, stmt);
     return err;
@@ skipping 50 matching lines @@
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 base::TimeTicks TimeSource::Now() {
   return base::TimeTicks::Now();
 }
 
 }  // namespace sql