[sql] Change DoesStuffExist() to work with ScopedErrorIgnorer.

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/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 706 matching lines @@
     const char* sql) {
   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.

[maniscalco, 2015/04/08 22:40:27]

I'm thinking about this comment and the one in GetUntrackedStatement below. 
Does it make sense to expand it to something like:

// This is evidence of a syntax error in the incoming SQL or database
corruption.

?

[Scott Hess - ex-Googler, 2015/04/08 22:49:20]

Maybe, it depends.  Corruption can cause almost any problem you can imagine, so
I've generally not made a stink about noting potential problems.  The reason I
mentioned it below is because the code at that point will work fine without the
additional check in a Release build, and will never be reached in a Debug build.
 Since the syntax is broadly correct, it should only ever fire in the corruption
case.

I think :-).

[maniscalco, 2015/04/09 15:11:08]

That makes sense to me.

-    DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
+    DLOG_IF(FATAL, !ShouldIgnoreSqliteError(rc))

[maniscalco, 2015/04/09 20:40:52]

I just realized that ShouldIgnoreSqliteError is not a pure function since it
calls ScopedErrorIgnorer::ShouldIgnore which modifies the underlying
errors_ignored_ set.

In Debug builds, the second argument to DLOG_IF (ShouldIgnoreSqliteError) will
be evaluated as expected.

However, in Release builds, DLOG_IF is replaced with EAT_STREAM_PARAMETERS and
so the second argument won't be evaluated, which means that rc will never be
added to the errors_ignored_ set in Release builds.

WDYT about pulling the call to ShouldIgnoreSqliteError out of the DLOG_IF?  I'm
thinking it would look something like this:

    const bool should_ignore = ShouldIgnoreSqliteError(rc);
    ALLOW_UNUSED_LOCAL(should_ignore);
    DLOG_IF(FATAL, !should_ignore) << "SQL compile error " << GetErrorMessage();

[Scott Hess - ex-Googler, 2015/04/09 20:46:30]

At this site, OnSqliteError() should call ShouldIgnoreSqliteError().  But it
does look like the form in that code is maybe usable here:
  if (!ShouldIgnoreSqliteError(err))
    DLOG(FATAL) << "SQL compile error " << GetErrorMessage();

The other case won't have that backup.  I can make a CL, but just for my info,
are you seeing this actually fail, or just hypothetical?

+        << "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);
 }
 
 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.
-    DLOG(FATAL) << "SQL compile error " << GetErrorMessage();
+    DLOG_IF(FATAL, !ShouldIgnoreSqliteError(rc))
+        << "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 =
       "SELECT type, name, tbl_name, sql "
@@ skipping 33 matching lines @@
 bool Connection::DoesTableExist(const char* table_name) const {
   return DoesTableOrIndexExist(table_name, "table");
 }
 
 bool Connection::DoesIndexExist(const char* index_name) const {
   return DoesTableOrIndexExist(index_name, "index");
 }
 
 bool Connection::DoesTableOrIndexExist(
     const char* name, const char* type) const {
-  const char* kSql = "SELECT name FROM sqlite_master WHERE type=? AND name=?";
+  const char* kSql =
+      "SELECT name FROM sqlite_master WHERE type=? AND name=? COLLATE NOCASE";
   Statement statement(GetUntrackedStatement(kSql));
+
+  // This can happen if the database is corrupt and the error is being ignored
+  // for testing purposes.
+  if (!statement.is_valid())
+    return false;
+
   statement.BindString(0, type);
   statement.BindString(1, name);
 
   return statement.Step();  // Table exists if any row was returned.
 }
 
 bool Connection::DoesColumnExist(const char* table_name,
                                  const char* column_name) const {
   std::string sql("PRAGMA TABLE_INFO(");
   sql.append(table_name);
   sql.append(")");
 
   Statement statement(GetUntrackedStatement(sql.c_str()));
+
+  // This can happen if the database is corrupt and the error is being ignored
+  // for testing purposes.
+  if (!statement.is_valid())
+    return false;
+
   while (statement.Step()) {
-    if (!statement.ColumnString(1).compare(column_name))
+    if (!base::strcasecmp(statement.ColumnString(1).c_str(), column_name))
       return true;
   }
   return false;
 }
 
 int64 Connection::GetLastInsertRowId() const {
   if (!db_) {
     DLOG_IF(FATAL, !poisoned_) << "Illegal use of connection without a db";
     return 0;
   }
@@ skipping 288 matching lines @@
   }
 
   // Best effort to put things back as they were before.
   const char kNoWritableSchema[] = "PRAGMA writable_schema = OFF";
   ignore_result(Execute(kNoWritableSchema));
 
   return ret;
 }
 
 }  // namespace sql