1 // Copyright 2013 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/test/test_helpers.h" 6 7 #include <string> 8 9 #include "base/files/file_util.h" 10 #include "base/files/scoped_file.h" 11 #include "sql/connection.h" 12 #include "sql/statement.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 15 namespace { 16 17 size_t CountSQLItemsOfType(sql::Connection* db, const char* type) { 18 const char kTypeSQL[] = "SELECT COUNT(*) FROM sqlite_master WHERE type = ?"; 19 sql::Statement s(db->GetUniqueStatement(kTypeSQL)); 20 s.BindCString(0, type); 21 EXPECT_TRUE(s.Step()); 22 return s.ColumnInt(0); 23 } 24 25 // Get page size for the database. 26 bool GetPageSize(sql::Connection* db, int* page_size) { 27 sql::Statement s(db->GetUniqueStatement("PRAGMA page_size")); 28 if (!s.Step()) 29 return false; 30 *page_size = s.ColumnInt(0); 31 return true; 32 } 33 34 // Get |name|'s root page number in the database. 35 bool GetRootPage(sql::Connection* db, const char* name, int* page_number) { 36 const char kPageSql[] = "SELECT rootpage FROM sqlite_master WHERE name = ?"; 37 sql::Statement s(db->GetUniqueStatement(kPageSql)); 38 s.BindString(0, name); 39 if (!s.Step()) 40 return false; 41 *page_number = s.ColumnInt(0); 42 return true; 43 } 44 45 // Helper for reading a number from the SQLite header. 46 // See base/big_endian.h. 47 unsigned ReadBigEndian(unsigned char* buf, size_t bytes) { 48 unsigned r = buf[0]; 49 for (size_t i = 1; i < bytes; i++) { 50 r <<= 8; 51 r |= buf[i]; 52 } 53 return r; 54 } 55 56 // Helper for writing a number to the SQLite header. 57 void WriteBigEndian(unsigned val, unsigned char* buf, size_t bytes) { 58 for (size_t i = 0; i < bytes; i++) { 59 buf[bytes - i - 1] = (val & 0xFF); 60 val >>= 8; 61 } 62 } 63 64 } // namespace 65 66 namespace sql { 67 namespace test { 68 69 bool CorruptSizeInHeader(const base::FilePath& db_path) { 70 // See http://www.sqlite.org/fileformat.html#database_header 71 const size_t kHeaderSize = 100; 72 const size_t kPageSizeOffset = 16; 73 const size_t kFileChangeCountOffset = 24; 74 const size_t kPageCountOffset = 28; 75 const size_t kVersionValidForOffset = 92; // duplicate kFileChangeCountOffset 76 77 unsigned char header[kHeaderSize]; 78 79 base::ScopedFILE file(base::OpenFile(db_path, "rb+")); 80 if (!file.get()) 81 return false; 82 83 if (0 != fseek(file.get(), 0, SEEK_SET)) 84 return false; 85 if (1u != fread(header, sizeof(header), 1, file.get())) 86 return false; 87 88 int64 db_size = 0; 89 if (!base::GetFileSize(db_path, &db_size)) 90 return false; 91 92 const unsigned page_size = ReadBigEndian(header + kPageSizeOffset, 2); 93 94 // One larger than the expected size. 95 const unsigned page_count = (db_size + page_size) / page_size; 96 WriteBigEndian(page_count, header + kPageCountOffset, 4); 97 98 // Update change count so outstanding readers know the info changed. 99 // Both spots must match for the page count to be considered valid. 100 unsigned change_count = ReadBigEndian(header + kFileChangeCountOffset, 4); 101 WriteBigEndian(change_count + 1, header + kFileChangeCountOffset, 4); 102 WriteBigEndian(change_count + 1, header + kVersionValidForOffset, 4); 103 104 if (0 != fseek(file.get(), 0, SEEK_SET)) 105 return false; 106 if (1u != fwrite(header, sizeof(header), 1, file.get())) 107 return false; 108 109 return true; 110 } 111 112 bool CorruptTableOrIndex(const base::FilePath& db_path, 113 const char* tree_name, 114 const char* update_sql) { 115 sql::Connection db; 116 if (!db.Open(db_path)) 117 return false; 118 119 int page_size = 0; 120 if (!GetPageSize(&db, &page_size)) 121 return false; 122 123 int page_number = 0; 124 if (!GetRootPage(&db, tree_name, &page_number)) 125 return false; 126 127 // SQLite uses 1-based page numbering. 128 const long int page_ofs = (page_number - 1) * page_size; 129 scoped_ptr<char[]> page_buf(new char[page_size]); 130 131 // Get the page into page_buf. 132 base::ScopedFILE file(base::OpenFile(db_path, "rb+")); 133 if (!file.get()) 134 return false; 135 if (0 != fseek(file.get(), page_ofs, SEEK_SET)) 136 return false; 137 if (1u != fread(page_buf.get(), page_size, 1, file.get())) 138 return false; 139 140 // Require the page to be a leaf node. A multilevel tree would be 141 // very hard to restore correctly. 142 if (page_buf[0] != 0xD && page_buf[0] != 0xA) 143 return false; 144 145 // The update has to work, and make changes. 146 if (!db.Execute(update_sql)) 147 return false; 148 if (db.GetLastChangeCount() == 0) 149 return false; 150 151 // Ensure that the database is fully flushed. 152 db.Close(); 153 154 // Check that the stored page actually changed. This catches usage 155 // errors where |update_sql| is not related to |tree_name|. 156 scoped_ptr<char[]> check_page_buf(new char[page_size]); 157 // The on-disk data should have changed. 158 if (0 != fflush(file.get())) 159 return false; 160 if (0 != fseek(file.get(), page_ofs, SEEK_SET)) 161 return false; 162 if (1u != fread(check_page_buf.get(), page_size, 1, file.get())) 163 return false; 164 if (!memcmp(check_page_buf.get(), page_buf.get(), page_size)) 165 return false; 166 167 // Put the original page back. 168 if (0 != fseek(file.get(), page_ofs, SEEK_SET)) 169 return false; 170 if (1u != fwrite(page_buf.get(), page_size, 1, file.get())) 171 return false; 172 173 return true; 174 } 175 176 size_t CountSQLTables(sql::Connection* db) { 177 return CountSQLItemsOfType(db, "table"); 178 } 179 180 size_t CountSQLIndices(sql::Connection* db) { 181 return CountSQLItemsOfType(db, "index"); 182 } 183 184 size_t CountTableColumns(sql::Connection* db, const char* table) { 185 // TODO(shess): sql::Connection::QuoteForSQL() would make sense. 186 std::string quoted_table; 187 { 188 const char kQuoteSQL[] = "SELECT quote(?)"; 189 sql::Statement s(db->GetUniqueStatement(kQuoteSQL)); 190 s.BindCString(0, table); 191 EXPECT_TRUE(s.Step()); 192 quoted_table = s.ColumnString(0); 193 } 194 195 std::string sql = "PRAGMA table_info(" + quoted_table + ")"; 196 sql::Statement s(db->GetUniqueStatement(sql.c_str())); 197 size_t rows = 0; 198 while (s.Step()) { 199 ++rows; 200 } 201 EXPECT_TRUE(s.Succeeded()); 202 return rows; 203 } 204 205 bool CountTableRows(sql::Connection* db, const char* table, size_t* count) { 206 // TODO(shess): Table should probably be quoted with [] or "". See 207 // http://www.sqlite.org/lang_keywords.html . Meanwhile, odd names 208 // will throw an error. 209 std::string sql = "SELECT COUNT(*) FROM "; 210 sql += table; 211 sql::Statement s(db->GetUniqueStatement(sql.c_str())); 212 if (!s.Step()) 213 return false; 214 215 *count = s.ColumnInt64(0); 216 return true; 217 } 218 219 bool CreateDatabaseFromSQL(const base::FilePath& db_path, 220 const base::FilePath& sql_path) { 221 if (base::PathExists(db_path) || !base::PathExists(sql_path)) 222 return false; 223 224 std::string sql; 225 if (!base::ReadFileToString(sql_path, &sql)) 226 return false; 227 228 sql::Connection db; 229 if (!db.Open(db_path)) 230 return false; 231 232 // TODO(shess): Android defaults to auto_vacuum mode. 233 // Unfortunately, this makes certain kinds of tests which manipulate 234 // the raw database hard/impossible to write. 235 // http://crbug.com/307303 is for exploring this test issue. 236 ignore_result(db.Execute("PRAGMA auto_vacuum = 0")); 237 238 return db.Execute(sql.c_str()); 239 } 240 241 std::string IntegrityCheck(sql::Connection* db) { 242 sql::Statement statement(db->GetUniqueStatement("PRAGMA integrity_check")); 243 244 // SQLite should always return a row of data. 245 EXPECT_TRUE(statement.Step()); 246 247 return statement.ColumnString(0); 248 } 249 250 } // namespace test 251 } // namespace sql 252
