1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
// 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/test/test_helpers.h"
#include <string>
#include "base/file_util.h"
#include "sql/connection.h"
#include "sql/statement.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
size_t CountSQLItemsOfType(sql::Connection* db, const char* type) {
const char kTypeSQL[] = "SELECT COUNT(*) FROM sqlite_master WHERE type = ?";
sql::Statement s(db->GetUniqueStatement(kTypeSQL));
s.BindCString(0, type);
EXPECT_TRUE(s.Step());
return s.ColumnInt(0);
}
// Helper for reading a number from the SQLite header.
// See net/base/big_endian.h.
unsigned ReadBigEndian(unsigned char* buf, size_t bytes) {
unsigned r = buf[0];
for (size_t i = 1; i < bytes; i++) {
r <<= 8;
r |= buf[i];
}
return r;
}
// Helper for writing a number to the SQLite header.
void WriteBigEndian(unsigned val, unsigned char* buf, size_t bytes) {
for (size_t i = 0; i < bytes; i++) {
buf[bytes - i - 1] = (val & 0xFF);
val >>= 8;
}
}
} // namespace
namespace sql {
namespace test {
bool CorruptSizeInHeader(const base::FilePath& db_path) {
// See http://www.sqlite.org/fileformat.html#database_header
const size_t kHeaderSize = 100;
const size_t kPageSizeOffset = 16;
const size_t kFileChangeCountOffset = 24;
const size_t kPageCountOffset = 28;
const size_t kVersionValidForOffset = 92; // duplicate kFileChangeCountOffset
unsigned char header[kHeaderSize];
file_util::ScopedFILE file(file_util::OpenFile(db_path, "rb+"));
if (!file.get())
return false;
if (0 != fseek(file.get(), 0, SEEK_SET))
return false;
if (1u != fread(header, sizeof(header), 1, file.get()))
return false;
int64 db_size = 0;
if (!file_util::GetFileSize(db_path, &db_size))
return false;
const unsigned page_size = ReadBigEndian(header + kPageSizeOffset, 2);
// One larger than the expected size.
const unsigned page_count = (db_size + page_size) / page_size;
WriteBigEndian(page_count, header + kPageCountOffset, 4);
// Update change count so outstanding readers know the info changed.
// Both spots must match for the page count to be considered valid.
unsigned change_count = ReadBigEndian(header + kFileChangeCountOffset, 4);
WriteBigEndian(change_count + 1, header + kFileChangeCountOffset, 4);
WriteBigEndian(change_count + 1, header + kVersionValidForOffset, 4);
if (0 != fseek(file.get(), 0, SEEK_SET))
return false;
if (1u != fwrite(header, sizeof(header), 1, file.get()))
return false;
return true;
}
size_t CountSQLTables(sql::Connection* db) {
return CountSQLItemsOfType(db, "table");
}
size_t CountSQLIndices(sql::Connection* db) {
return CountSQLItemsOfType(db, "index");
}
size_t CountTableColumns(sql::Connection* db, const char* table) {
// TODO(shess): sql::Connection::QuoteForSQL() would make sense.
std::string quoted_table;
{
const char kQuoteSQL[] = "SELECT quote(?)";
sql::Statement s(db->GetUniqueStatement(kQuoteSQL));
s.BindCString(0, table);
EXPECT_TRUE(s.Step());
quoted_table = s.ColumnString(0);
}
std::string sql = "PRAGMA table_info(" + quoted_table + ")";
sql::Statement s(db->GetUniqueStatement(sql.c_str()));
size_t rows = 0;
while (s.Step()) {
++rows;
}
EXPECT_TRUE(s.Succeeded());
return rows;
}
bool CountTableRows(sql::Connection* db, const char* table, size_t* count) {
// TODO(shess): Table should probably be quoted with [] or "". See
// http://www.sqlite.org/lang_keywords.html . Meanwhile, odd names
// will throw an error.
std::string sql = "SELECT COUNT(*) FROM ";
sql += table;
sql::Statement s(db->GetUniqueStatement(sql.c_str()));
if (!s.Step())
return false;
*count = s.ColumnInt64(0);
return true;
}
bool CreateDatabaseFromSQL(const base::FilePath& db_path,
const base::FilePath& sql_path) {
if (base::PathExists(db_path) || !base::PathExists(sql_path))
return false;
std::string sql;
if (!base::ReadFileToString(sql_path, &sql))
return false;
sql::Connection db;
if (!db.Open(db_path))
return false;
// TODO(shess): Android defaults to auto_vacuum mode.
// Unfortunately, this makes certain kinds of tests which manipulate
// the raw database hard/impossible to write.
// http://crbug.com/307303 is for exploring this test issue.
ignore_result(db.Execute("PRAGMA auto_vacuum = 0"));
return db.Execute(sql.c_str());
}
std::string IntegrityCheck(sql::Connection* db) {
sql::Statement statement(db->GetUniqueStatement("PRAGMA integrity_check"));
// SQLite should always return a row of data.
EXPECT_TRUE(statement.Step());
return statement.ColumnString(0);
}
} // namespace test
} // namespace sql
|
