Revert 235492 "[sql] Recover Favicons v5 databases, with more re..."

trunk/src/sql/recovery.cc

 // Copyright 2013 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/recovery.h"
 
 #include "base/files/file_path.h"
-#include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/metrics/sparse_histogram.h"
-#include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
 #include "sql/connection.h"
-#include "sql/statement.h"
 #include "third_party/sqlite/sqlite3.h"
 
 namespace sql {
 
 // static
 bool Recovery::FullRecoverySupported() {
   // TODO(shess): See comment in Init().
 #if defined(USE_SYSTEM_SQLITE)
   return false;
 #else
@@ skipping 205 matching lines @@
 
   recover_db_.Close();
   if (raze == RAZE_AND_POISON) {
     db_->RazeAndClose();
   } else if (raze == POISON) {
     db_->Poison();
   }
   db_ = NULL;
 }
 
-bool Recovery::AutoRecoverTable(const char* table_name,
-                                size_t extend_columns,
-                                size_t* rows_recovered) {
-  // Query the info for the recovered table in database [main].
-  std::string query(
-      base::StringPrintf("PRAGMA main.table_info(%s)", table_name));
-  Statement s(db()->GetUniqueStatement(query.c_str()));
-
-  // The columns of the recover virtual table.
-  std::vector<std::string> create_column_decls;
-
-  // The columns to select from the recover virtual table when copying
-  // to the recovered table.
-  std::vector<std::string> insert_columns;
-
-  // If PRIMARY KEY is a single INTEGER column, then it is an alias
-  // for ROWID.  The primary key can be compound, so this can only be
-  // determined after processing all column data and tracking what is
-  // seen.  |pk_column_count| counts the columns in the primary key.
-  // |rowid_decl| stores the ROWID version of the last INTEGER column
-  // seen, which is at |rowid_ofs| in |create_column_decls|.
-  size_t pk_column_count = 0;
-  size_t rowid_ofs;  // Only valid if rowid_decl is set.
-  std::string rowid_decl;  // ROWID version of column |rowid_ofs|.
-
-  while (s.Step()) {
-    const std::string column_name(s.ColumnString(1));
-    const std::string column_type(s.ColumnString(2));
-    const bool not_null = s.ColumnBool(3);
-    const int default_type = s.ColumnType(4);
-    const bool default_is_null = (default_type == COLUMN_TYPE_NULL);
-    const int pk_column = s.ColumnInt(5);
-
-    if (pk_column > 0) {
-      // TODO(shess): http://www.sqlite.org/pragma.html#pragma_table_info
-      // documents column 5 as the index of the column in the primary key
-      // (zero for not in primary key).  I find that it is always 1 for
-      // columns in the primary key.  Since this code is very dependent on
-      // that pragma, review if the implementation changes.
-      DCHECK_EQ(pk_column, 1);
-      ++pk_column_count;
-    }
-
-    // Construct column declaration as "name type [optional constraint]".
-    std::string column_decl = column_name;
-
-    // SQLite's affinity detection is documented at:
-    // http://www.sqlite.org/datatype3.html#affname
-    // The gist of it is that CHAR, TEXT, and INT use substring matches.
-    if (column_type.find("INT") != std::string::npos) {
-      if (pk_column == 1) {
-        rowid_ofs = create_column_decls.size();
-        rowid_decl = column_name + " ROWID";
-      }
-      column_decl += " INTEGER";
-    } else if (column_type.find("CHAR") != std::string::npos ||
-               column_type.find("TEXT") != std::string::npos) {
-      column_decl += " TEXT";
-    } else if (column_type == "BLOB") {
-      column_decl += " BLOB";
-    } else {
-      // TODO(shess): AFAICT, there remain:
-      // - contains("CLOB") -> TEXT
-      // - contains("REAL") -> REAL
-      // - contains("FLOA") -> REAL
-      // - contains("DOUB") -> REAL
-      // - other -> "NUMERIC"
-      // Just code those in as they come up.
-      NOTREACHED() << " Unsupported type " << column_type;
-      return false;
-    }
-
-    // If column has constraint "NOT NULL", then inserting NULL into
-    // that column will fail.  If the column has a non-NULL DEFAULT
-    // specified, the INSERT will handle it (see below).  If the
-    // DEFAULT is also NULL, the row must be filtered out.
-    // TODO(shess): The above scenario applies to INSERT OR REPLACE,
-    // whereas INSERT OR IGNORE drops such rows.
-    // http://www.sqlite.org/lang_conflict.html
-    if (not_null && default_is_null)
-      column_decl += " NOT NULL";
-
-    create_column_decls.push_back(column_decl);
-
-    // Per the NOTE in the header file, convert NULL values to the
-    // DEFAULT.  All columns could be IFNULL(column_name,default), but
-    // the NULL case would require special handling either way.
-    if (default_is_null) {
-      insert_columns.push_back(column_name);
-    } else {
-      // The default value appears to be pre-quoted, as if it is
-      // literally from the sqlite_master CREATE statement.
-      std::string default_value = s.ColumnString(4);
-      insert_columns.push_back(base::StringPrintf(
-          "IFNULL(%s,%s)", column_name.c_str(), default_value.c_str()));
-    }
-  }
-
-  // Receiving no column information implies that the table doesn't exist.
-  if (create_column_decls.empty())
-    return false;
-
-  // If the PRIMARY KEY was a single INTEGER column, convert it to ROWID.
-  if (pk_column_count == 1 && !rowid_decl.empty())
-    create_column_decls[rowid_ofs] = rowid_decl;
-
-  // Additional columns accept anything.
-  // TODO(shess): ignoreN isn't well namespaced.  But it will fail to
-  // execute in case of conflicts.
-  for (size_t i = 0; i < extend_columns; ++i) {
-    create_column_decls.push_back(
-        base::StringPrintf("ignore%" PRIuS " ANY", i));
-  }
-
-  std::string recover_create(base::StringPrintf(
-      "CREATE VIRTUAL TABLE temp.recover_%s USING recover(corrupt.%s, %s)",
-      table_name,
-      table_name,
-      JoinString(create_column_decls, ',').c_str()));
-
-  std::string recover_insert(base::StringPrintf(
-      "INSERT OR REPLACE INTO main.%s SELECT %s FROM temp.recover_%s",
-      table_name,
-      JoinString(insert_columns, ',').c_str(),
-      table_name));
-
-  std::string recover_drop(base::StringPrintf(
-      "DROP TABLE temp.recover_%s", table_name));
-
-  if (!db()->Execute(recover_create.c_str()))
-    return false;
-
-  if (!db()->Execute(recover_insert.c_str())) {
-    ignore_result(db()->Execute(recover_drop.c_str()));
-    return false;
-  }
-
-  *rows_recovered = db()->GetLastChangeCount();
-
-  // TODO(shess): Is leaving the recover table around a breaker?
-  return db()->Execute(recover_drop.c_str());
-}
-
-bool Recovery::SetupMeta() {
-  const char kCreateSql[] =
-      "CREATE VIRTUAL TABLE temp.recover_meta USING recover"
-      "("
-      "corrupt.meta,"
-      "key TEXT NOT NULL,"
-      "value ANY"  // Whatever is stored.
-      ")";
-  return db()->Execute(kCreateSql);
-}
-
-bool Recovery::GetMetaVersionNumber(int* version) {
-  DCHECK(version);
-  // TODO(shess): DCHECK(db()->DoesTableExist("temp.recover_meta"));
-  // Unfortunately, DoesTableExist() queries sqlite_master, not
-  // sqlite_temp_master.
-
-  const char kVersionSql[] =
-      "SELECT value FROM temp.recover_meta WHERE key = 'version'";
-  sql::Statement recovery_version(db()->GetUniqueStatement(kVersionSql));
-  if (!recovery_version.Step())
-    return false;
-
-  *version = recovery_version.ColumnInt(0);
-  return true;
-}
-
 }  // namespace sql