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
15namespace {
16
17size_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.
26bool 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.
35bool 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.
47unsigned 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.
57void 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
66namespace sql {
67namespace test {
68
69bool 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
112bool 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
176size_t CountSQLTables(sql::Connection* db) {
177  return CountSQLItemsOfType(db, "table");
178}
179
180size_t CountSQLIndices(sql::Connection* db) {
181  return CountSQLItemsOfType(db, "index");
182}
183
184size_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
205bool 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
219bool 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
241std::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