blob: 6ddcc618ef08121988ad677635a16f624974b490 [file] [log] [blame]
// Copyright (c) 2012 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 <stddef.h>
#include <stdint.h>
#include <string>
#include "base/bind.h"
#include "base/files/file_util.h"
#include "base/files/memory_mapped_file.h"
#include "base/files/scoped_temp_dir.h"
#include "sql/connection.h"
#include "sql/statement.h"
#include "sql/test/sql_test_base.h"
#include "sql/test/test_helpers.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/sqlite/sqlite3.h"
#if defined(OS_IOS)
#include "base/ios/ios_util.h"
#endif
#if defined(OS_MACOSX) && !defined(OS_IOS)
#include <CoreFoundation/CoreFoundation.h>
#include <CoreServices/CoreServices.h>
#include "base/mac/mac_util.h"
#include "base/mac/scoped_cftyperef.h"
#endif
// Test that certain features are/are-not enabled in our SQLite.
namespace {
void CaptureErrorCallback(int* error_pointer, std::string* sql_text,
int error, sql::Statement* stmt) {
*error_pointer = error;
const char* text = stmt ? stmt->GetSQLStatement() : NULL;
*sql_text = text ? text : "no statement available";
}
class SQLiteFeaturesTest : public sql::SQLTestBase {
public:
SQLiteFeaturesTest() : error_(SQLITE_OK) {}
void SetUp() override {
SQLTestBase::SetUp();
// The error delegate will set |error_| and |sql_text_| when any sqlite
// statement operation returns an error code.
db().set_error_callback(
base::Bind(&CaptureErrorCallback, &error_, &sql_text_));
}
void TearDown() override {
// If any error happened the original sql statement can be found in
// |sql_text_|.
EXPECT_EQ(SQLITE_OK, error_) << sql_text_;
SQLTestBase::TearDown();
}
int error() { return error_; }
private:
// The error code of the most recent error.
int error_;
// Original statement which has caused the error.
std::string sql_text_;
};
// Do not include fts1 support, it is not useful, and nobody is
// looking at it.
TEST_F(SQLiteFeaturesTest, NoFTS1) {
ASSERT_EQ(SQLITE_ERROR, db().ExecuteAndReturnErrorCode(
"CREATE VIRTUAL TABLE foo USING fts1(x)"));
}
// Do not include fts2 support, it is not useful, and nobody is
// looking at it.
TEST_F(SQLiteFeaturesTest, NoFTS2) {
ASSERT_EQ(SQLITE_ERROR, db().ExecuteAndReturnErrorCode(
"CREATE VIRTUAL TABLE foo USING fts2(x)"));
}
// fts3 used to be used for history files, and may also be used by WebDatabase
// clients.
TEST_F(SQLiteFeaturesTest, FTS3) {
ASSERT_TRUE(db().Execute("CREATE VIRTUAL TABLE foo USING fts3(x)"));
}
#if !defined(USE_SYSTEM_SQLITE)
// Originally history used fts2, which Chromium patched to treat "foo*" as a
// prefix search, though the icu tokenizer would return it as two tokens {"foo",
// "*"}. Test that fts3 works correctly.
TEST_F(SQLiteFeaturesTest, FTS3_Prefix) {
const char kCreateSql[] =
"CREATE VIRTUAL TABLE foo USING fts3(x, tokenize icu)";
ASSERT_TRUE(db().Execute(kCreateSql));
ASSERT_TRUE(db().Execute("INSERT INTO foo (x) VALUES ('test')"));
sql::Statement s(db().GetUniqueStatement(
"SELECT x FROM foo WHERE x MATCH 'te*'"));
ASSERT_TRUE(s.Step());
EXPECT_EQ("test", s.ColumnString(0));
}
#endif
#if !defined(USE_SYSTEM_SQLITE)
// Verify that Chromium's SQLite is compiled with HAVE_USLEEP defined. With
// HAVE_USLEEP, SQLite uses usleep() with millisecond granularity. Otherwise it
// uses sleep() with second granularity.
TEST_F(SQLiteFeaturesTest, UsesUsleep) {
base::TimeTicks before = base::TimeTicks::Now();
sqlite3_sleep(1);
base::TimeDelta delta = base::TimeTicks::Now() - before;
// It is not impossible for this to be over 1000 if things are compiled the
// right way. But it is very unlikely, most platforms seem to be around
// <TBD>.
LOG(ERROR) << "Milliseconds: " << delta.InMilliseconds();
EXPECT_LT(delta.InMilliseconds(), 1000);
}
#endif
// Ensure that our SQLite version has working foreign key support with cascade
// delete support.
TEST_F(SQLiteFeaturesTest, ForeignKeySupport) {
ASSERT_TRUE(db().Execute("PRAGMA foreign_keys=1"));
ASSERT_TRUE(db().Execute("CREATE TABLE parents (id INTEGER PRIMARY KEY)"));
ASSERT_TRUE(db().Execute(
"CREATE TABLE children ("
" id INTEGER PRIMARY KEY,"
" pid INTEGER NOT NULL REFERENCES parents(id) ON DELETE CASCADE)"));
// Inserting without a matching parent should fail with constraint violation.
// Mask off any extended error codes for USE_SYSTEM_SQLITE.
int insertErr = db().ExecuteAndReturnErrorCode(
"INSERT INTO children VALUES (10, 1)");
EXPECT_EQ(SQLITE_CONSTRAINT, (insertErr&0xff));
size_t rows;
EXPECT_TRUE(sql::test::CountTableRows(&db(), "children", &rows));
EXPECT_EQ(0u, rows);
// Inserting with a matching parent should work.
ASSERT_TRUE(db().Execute("INSERT INTO parents VALUES (1)"));
EXPECT_TRUE(db().Execute("INSERT INTO children VALUES (11, 1)"));
EXPECT_TRUE(db().Execute("INSERT INTO children VALUES (12, 1)"));
EXPECT_TRUE(sql::test::CountTableRows(&db(), "children", &rows));
EXPECT_EQ(2u, rows);
// Deleting the parent should cascade, i.e., delete the children as well.
ASSERT_TRUE(db().Execute("DELETE FROM parents"));
EXPECT_TRUE(sql::test::CountTableRows(&db(), "children", &rows));
EXPECT_EQ(0u, rows);
}
#if defined(MOJO_APPTEST_IMPL) || defined(OS_IOS)
// If the platform cannot support SQLite mmap'ed I/O, make sure SQLite isn't
// offering to support it.
TEST_F(SQLiteFeaturesTest, NoMmap) {
#if defined(OS_IOS) && defined(USE_SYSTEM_SQLITE)
if (base::ios::IsRunningOnIOS10OrLater()) {
// iOS 10 added mmap support for sqlite.
return;
}
#endif
// For recent versions of SQLite, SQLITE_MAX_MMAP_SIZE=0 can be used to
// disable mmap support. Alternately, sqlite3_config() could be used. In
// that case, the pragma will run successfully, but the size will always be 0.
//
// The SQLite embedded in older iOS releases predates the addition of mmap
// support. In that case the pragma will run without error, but no results
// are returned when querying the value.
//
// MojoVFS implements a no-op for xFileControl(). PRAGMA mmap_size is
// implemented in terms of SQLITE_FCNTL_MMAP_SIZE. In that case, the pragma
// will succeed but with no effect.
ignore_result(db().Execute("PRAGMA mmap_size = 1048576"));
sql::Statement s(db().GetUniqueStatement("PRAGMA mmap_size"));
ASSERT_TRUE(!s.Step() || !s.ColumnInt64(0));
}
#endif
#if !defined(MOJO_APPTEST_IMPL)
// Verify that OS file writes are reflected in the memory mapping of a
// memory-mapped file. Normally SQLite writes to memory-mapped files using
// memcpy(), which should stay consistent. Our SQLite is slightly patched to
// mmap read only, then write using OS file writes. If the memory-mapped
// version doesn't reflect the OS file writes, SQLite's memory-mapped I/O should
// be disabled on this platform using SQLITE_MAX_MMAP_SIZE=0.
TEST_F(SQLiteFeaturesTest, Mmap) {
#if defined(OS_IOS) && defined(USE_SYSTEM_SQLITE)
if (!base::ios::IsRunningOnIOS10OrLater()) {
// iOS9's sqlite does not support mmap, so this test must be skipped.
return;
}
#endif
// Try to turn on mmap'ed I/O.
ignore_result(db().Execute("PRAGMA mmap_size = 1048576"));
{
sql::Statement s(db().GetUniqueStatement("PRAGMA mmap_size"));
#if !defined(USE_SYSTEM_SQLITE)
// With Chromium's version of SQLite, the setting should always be non-zero.
ASSERT_TRUE(s.Step());
ASSERT_GT(s.ColumnInt64(0), 0);
#else
// With the system SQLite, don't verify underlying mmap functionality if the
// SQLite is too old to support mmap, or if mmap is disabled (see NoMmap
// test). USE_SYSTEM_SQLITE is not bundled into the NoMmap case because
// whether mmap is enabled or not is outside of Chromium's control.
if (!s.Step() || !s.ColumnInt64(0))
return;
#endif
}
db().Close();
const uint32_t kFlags =
base::File::FLAG_OPEN | base::File::FLAG_READ | base::File::FLAG_WRITE;
char buf[4096];
// Create a file with a block of '0', a block of '1', and a block of '2'.
{
base::File f(db_path(), kFlags);
ASSERT_TRUE(f.IsValid());
memset(buf, '0', sizeof(buf));
ASSERT_EQ(f.Write(0*sizeof(buf), buf, sizeof(buf)), (int)sizeof(buf));
memset(buf, '1', sizeof(buf));
ASSERT_EQ(f.Write(1*sizeof(buf), buf, sizeof(buf)), (int)sizeof(buf));
memset(buf, '2', sizeof(buf));
ASSERT_EQ(f.Write(2*sizeof(buf), buf, sizeof(buf)), (int)sizeof(buf));
}
// mmap the file and verify that everything looks right.
{
base::MemoryMappedFile m;
ASSERT_TRUE(m.Initialize(db_path()));
memset(buf, '0', sizeof(buf));
ASSERT_EQ(0, memcmp(buf, m.data() + 0*sizeof(buf), sizeof(buf)));
memset(buf, '1', sizeof(buf));
ASSERT_EQ(0, memcmp(buf, m.data() + 1*sizeof(buf), sizeof(buf)));
memset(buf, '2', sizeof(buf));
ASSERT_EQ(0, memcmp(buf, m.data() + 2*sizeof(buf), sizeof(buf)));
// Scribble some '3' into the first page of the file, and verify that it
// looks the same in the memory mapping.
{
base::File f(db_path(), kFlags);
ASSERT_TRUE(f.IsValid());
memset(buf, '3', sizeof(buf));
ASSERT_EQ(f.Write(0*sizeof(buf), buf, sizeof(buf)), (int)sizeof(buf));
}
ASSERT_EQ(0, memcmp(buf, m.data() + 0*sizeof(buf), sizeof(buf)));
// Repeat with a single '4' in case page-sized blocks are different.
const size_t kOffset = 1*sizeof(buf) + 123;
ASSERT_NE('4', m.data()[kOffset]);
{
base::File f(db_path(), kFlags);
ASSERT_TRUE(f.IsValid());
buf[0] = '4';
ASSERT_EQ(f.Write(kOffset, buf, 1), 1);
}
ASSERT_EQ('4', m.data()[kOffset]);
}
}
#endif
// Verify that http://crbug.com/248608 is fixed. In this bug, the
// compiled regular expression is effectively cached with the prepared
// statement, causing errors if the regular expression is rebound.
TEST_F(SQLiteFeaturesTest, CachedRegexp) {
ASSERT_TRUE(db().Execute("CREATE TABLE r (id INTEGER UNIQUE, x TEXT)"));
ASSERT_TRUE(db().Execute("INSERT INTO r VALUES (1, 'this is a test')"));
ASSERT_TRUE(db().Execute("INSERT INTO r VALUES (2, 'that was a test')"));
ASSERT_TRUE(db().Execute("INSERT INTO r VALUES (3, 'this is a stickup')"));
ASSERT_TRUE(db().Execute("INSERT INTO r VALUES (4, 'that sucks')"));
const char* kSimpleSql = "SELECT SUM(id) FROM r WHERE x REGEXP ?";
sql::Statement s(db().GetCachedStatement(SQL_FROM_HERE, kSimpleSql));
s.BindString(0, "this.*");
ASSERT_TRUE(s.Step());
EXPECT_EQ(4, s.ColumnInt(0));
s.Reset(true);
s.BindString(0, "that.*");
ASSERT_TRUE(s.Step());
EXPECT_EQ(6, s.ColumnInt(0));
s.Reset(true);
s.BindString(0, ".*test");
ASSERT_TRUE(s.Step());
EXPECT_EQ(3, s.ColumnInt(0));
s.Reset(true);
s.BindString(0, ".* s[a-z]+");
ASSERT_TRUE(s.Step());
EXPECT_EQ(7, s.ColumnInt(0));
}
#if defined(OS_MACOSX) && !defined(OS_IOS)
base::ScopedCFTypeRef<CFURLRef> CFURLRefForPath(const base::FilePath& path){
base::ScopedCFTypeRef<CFStringRef> urlString(
CFStringCreateWithFileSystemRepresentation(
kCFAllocatorDefault, path.value().c_str()));
base::ScopedCFTypeRef<CFURLRef> url(
CFURLCreateWithFileSystemPath(kCFAllocatorDefault, urlString,
kCFURLPOSIXPathStyle, FALSE));
return url;
}
// If a database file is marked to be excluded from Time Machine, verify that
// journal files are also excluded.
// TODO(shess): Disabled because CSBackupSetItemExcluded() does not work on the
// bots, though it's fine on dev machines. See <http://crbug.com/410350>.
TEST_F(SQLiteFeaturesTest, DISABLED_TimeMachine) {
ASSERT_TRUE(db().Execute("CREATE TABLE t (id INTEGER PRIMARY KEY)"));
db().Close();
base::FilePath journal(db_path().value() + FILE_PATH_LITERAL("-journal"));
ASSERT_TRUE(GetPathExists(db_path()));
ASSERT_TRUE(GetPathExists(journal));
base::ScopedCFTypeRef<CFURLRef> dbURL(CFURLRefForPath(db_path()));
base::ScopedCFTypeRef<CFURLRef> journalURL(CFURLRefForPath(journal));
// Not excluded to start.
EXPECT_FALSE(CSBackupIsItemExcluded(dbURL, NULL));
EXPECT_FALSE(CSBackupIsItemExcluded(journalURL, NULL));
// Exclude the main database file.
EXPECT_TRUE(base::mac::SetFileBackupExclusion(db_path()));
Boolean excluded_by_path = FALSE;
EXPECT_TRUE(CSBackupIsItemExcluded(dbURL, &excluded_by_path));
EXPECT_FALSE(excluded_by_path);
EXPECT_FALSE(CSBackupIsItemExcluded(journalURL, NULL));
EXPECT_TRUE(db().Open(db_path()));
ASSERT_TRUE(db().Execute("INSERT INTO t VALUES (1)"));
EXPECT_TRUE(CSBackupIsItemExcluded(dbURL, &excluded_by_path));
EXPECT_FALSE(excluded_by_path);
EXPECT_TRUE(CSBackupIsItemExcluded(journalURL, &excluded_by_path));
EXPECT_FALSE(excluded_by_path);
// TODO(shess): In WAL mode this will touch -wal and -shm files. -shm files
// could be always excluded.
}
#endif
} // namespace