[sqlite] iOS running recover virtual table.

sql/recovery_unittest.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 <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 154 matching lines @@
   }
   EXPECT_FALSE(db().is_open());
   ASSERT_TRUE(Reopen());
   EXPECT_TRUE(db().is_open());
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   ASSERT_EQ("This is a test",
             ExecuteWithResults(&db(), kXSql, "|", "\n"));
 }
 
-// The recovery virtual table is only supported for Chromium's SQLite.
-#if !defined(USE_SYSTEM_SQLITE)
-
 // Test operation of the virtual table used by sql::Recovery.
 TEST_F(SQLRecoveryTest, VirtualTable) {
   const char kCreateSql[] = "CREATE TABLE x (t TEXT)";
   ASSERT_TRUE(db().Execute(kCreateSql));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('This is a test')"));
   ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('That was a test')"));
 
   // Successfully recover the database.
   {
     scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
@@ skipping 21 matching lines @@
   // Since the database was not corrupt, the entire schema and all
   // data should be recovered.
   ASSERT_TRUE(Reopen());
   ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
 
   const char* kXSql = "SELECT * FROM x ORDER BY 1";
   ASSERT_EQ("That was a test\nThis is a test",
             ExecuteWithResults(&db(), kXSql, "|", "\n"));
 }
 
+// Virtual table works with page sizes other than the default, with
+// sql::Recovery maintaining page size.
+TEST_F(SQLRecoveryTest, VirtualTablePageSize) {
+  const char kCreateSql[] = "CREATE TABLE x (t TEXT)";
+  ASSERT_TRUE(db().Execute(kCreateSql));
+  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('This is a test')"));
+  ASSERT_TRUE(db().Execute("INSERT INTO x VALUES ('That was a test')"));
+
+  // The default page size is the greater of SQLITE_DEFAULT_PAGE_SIZE and
+  // xSectorSize() returned from the vfs.
+  db().set_page_size(1024);
+  ASSERT_TRUE(Reopen());
+  ASSERT_TRUE(db().Execute("VACUUM"));
+
+  // Reset the page size.
+  ASSERT_EQ("1024", ExecuteWithResults(&db(), "PRAGMA page_size", "|", "\n"));
+  db().set_page_size(4096);
+  ASSERT_TRUE(Reopen());
+  ASSERT_TRUE(db().Execute("VACUUM"));
+  ASSERT_EQ("4096", ExecuteWithResults(&db(), "PRAGMA page_size", "|", "\n"));
+
+  // Successfully recover the database.
+  {
+    scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
+
+    // Tables to recover original DB, now at [corrupt].
+    const char kRecoveryCreateSql[] =
+        "CREATE VIRTUAL TABLE temp.recover_x using recover("
+        "  corrupt.x,"
+        "  t TEXT STRICT"
+        ")";
+    ASSERT_TRUE(recovery->db()->Execute(kRecoveryCreateSql));
+
+    // Re-create the original schema.
+    ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
+
+    // Copy the data from the recovery tables to the new database.
+    const char kRecoveryCopySql[] =
+        "INSERT INTO x SELECT t FROM recover_x";
+    ASSERT_TRUE(recovery->db()->Execute(kRecoveryCopySql));
+
+    // Successfully recovered.
+    ASSERT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
+  }
+
+  // Since the database was not corrupt, the entire schema and all
+  // data should be recovered.
+  ASSERT_TRUE(Reopen());
+  ASSERT_EQ("CREATE TABLE x (t TEXT)", GetSchema(&db()));
+  ASSERT_EQ("4096", ExecuteWithResults(&db(), "PRAGMA page_size", "|", "\n"));
+
+  const char* kXSql = "SELECT * FROM x ORDER BY 1";
+  ASSERT_EQ("That was a test\nThis is a test",
+            ExecuteWithResults(&db(), kXSql, "|", "\n"));
+}
+
 void RecoveryCallback(sql::Connection* db, const base::FilePath& db_path,
                       const char* create_table, const char* create_index,
                       int* record_error, int error, sql::Statement* stmt) {
   *record_error = error;
 
   // Clear the error callback to prevent reentrancy.
   db->reset_error_callback();
 
   scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(db, db_path);
   ASSERT_TRUE(recovery.get());
@@ skipping 478 matching lines @@
   ASSERT_TRUE(Reopen());
   ASSERT_EQ(expected_schema, GetSchema(&db()));
   ASSERT_EQ(expected_data, ExecuteWithResults(&db(), kXSql, "|", "\n"));
 }
 
 // Recover a golden file where an interior page has been manually modified so
 // that the number of cells is greater than will fit on a single page.  This
 // case happened in <http://crbug.com/387868>.
 TEST_F(SQLRecoveryTest, Bug387868) {
   base::FilePath golden_path;
-  ASSERT_TRUE(PathService::Get(sql::test::DIR_TEST_DATA, &golden_path));
+  ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &golden_path));
+  golden_path = golden_path.AppendASCII("sql");
+  golden_path = golden_path.AppendASCII("test");
+  golden_path = golden_path.AppendASCII("data");
   golden_path = golden_path.AppendASCII("recovery_387868");
   db().Close();
   ASSERT_TRUE(base::CopyFile(golden_path, db_path()));
   ASSERT_TRUE(Reopen());
 
   {
     scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
     ASSERT_TRUE(recovery.get());
 
     // Create the new version of the table.
     const char kCreateSql[] =
         "CREATE TABLE x (id INTEGER PRIMARY KEY, t0 TEXT)";
     ASSERT_TRUE(recovery->db()->Execute(kCreateSql));
 
     size_t rows = 0;
     EXPECT_TRUE(recovery->AutoRecoverTable("x", &rows));
     EXPECT_EQ(43u, rows);
 
     // Successfully recovered.
     EXPECT_TRUE(sql::Recovery::Recovered(std::move(recovery)));
   }
 }
-#endif  // !defined(USE_SYSTEM_SQLITE)
 
 // Memory-mapped I/O interacts poorly with I/O errors.  Make sure the recovery
 // database doesn't accidentally enable it.
 TEST_F(SQLRecoveryTest, NoMmap) {
   scoped_ptr<sql::Recovery> recovery = sql::Recovery::Begin(&db(), db_path());
   ASSERT_TRUE(recovery.get());
 
   // In the current implementation, the PRAGMA successfully runs with no result
   // rows.  Running with a single result of |0| is also acceptable.
   sql::Statement s(recovery->db()->GetUniqueStatement("PRAGMA mmap_size"));
   EXPECT_TRUE(!s.Step() || !s.ColumnInt64(0));
 }
 
 }  // namespace