15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Copyright (c) 2012 The Chromium Authors. All rights reserved. 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Use of this source code is governed by a BSD-style license that can be 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// found in the LICENSE file. 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifndef SQL_CONNECTION_H_ 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define SQL_CONNECTION_H_ 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <map> 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <set> 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <string> 1190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include <vector> 125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/basictypes.h" 1490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles)#include "base/callback.h" 155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/compiler_specific.h" 165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/memory/ref_counted.h" 175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/memory/scoped_ptr.h" 185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "base/threading/thread_restrictions.h" 19eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch#include "base/time/time.h" 205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "sql/sql_export.h" 215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)struct sqlite3; 235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)struct sqlite3_stmt; 245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 252a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)namespace base { 262a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)class FilePath; 272a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)} 282a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace sql { 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 31ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdochclass Recovery; 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class Statement; 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// Uniquely identifies a statement. There are two modes of operation: 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// - In the most common mode, you will use the source file and line number to 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// identify your statement. This is a convienient way to get uniqueness for 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// a statement that is only used in one place. Use the SQL_FROM_HERE macro 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// to generate a StatementID. 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// - In the "custom" mode you may use the statement from different places or 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// need to manage it yourself for whatever reason. In this case, you should 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// make up your own unique name and pass it to the StatementID. This name 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// must be a static string, since this object only deals with pointers and 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// assumes the underlying string doesn't change or get deleted. 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This object is copyable and assignable using the compiler-generated 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// operator= and copy constructor. 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class StatementID { 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Creates a uniquely named statement with the given file ane line number. 525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Normally you will use SQL_FROM_HERE instead of calling yourself. 535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StatementID(const char* file, int line) 545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : number_(line), 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) str_(file) { 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Creates a uniquely named statement with the given user-defined name. 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit StatementID(const char* unique_name) 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : number_(-1), 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) str_(unique_name) { 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This constructor is unimplemented and will generate a linker error if 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // called. It is intended to try to catch people dynamically generating 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // a statement name that will be deallocated and will cause a crash later. 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // All strings must be static and unchanging! 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) explicit StatementID(const std::string& dont_ever_do_this); 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // We need this to insert into our map. 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool operator<(const StatementID& other) const; 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int number_; 755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char* str_; 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#define SQL_FROM_HERE sql::StatementID(__FILE__, __LINE__) 795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class Connection; 815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class SQL_EXPORT Connection { 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) class StatementRef; // Forward declaration, see real one below. 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The database is opened by calling Open[InMemory](). Any uncommitted 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // transactions will be rolled back when this object is deleted. 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Connection(); 905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ~Connection(); 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Pre-init configuration ---------------------------------------------------- 935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Sets the page size that will be used when creating a new database. This 955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // must be called before Init(), and will only have an effect on new 965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // databases. 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // From sqlite.org: "The page size must be a power of two greater than or 995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // equal to 512 and less than or equal to SQLITE_MAX_PAGE_SIZE. The maximum 1005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // value for SQLITE_MAX_PAGE_SIZE is 32768." 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void set_page_size(int page_size) { page_size_ = page_size; } 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Sets the number of pages that will be cached in memory by sqlite. The 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // total cache size in bytes will be page_size * cache_size. This must be 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // called before Open() to have an effect. 1065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void set_cache_size(int cache_size) { cache_size_ = cache_size; } 1075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Call to put the database in exclusive locking mode. There is no "back to 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // normal" flag because of some additional requirements sqlite puts on this 110e5d81f57cb97b3b6b7fccc9c5610d21eb81db09dBen Murdoch // transaction (requires another access to the DB) and because we don't 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // actually need it. 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Exclusive mode means that the database is not unlocked at the end of each 1145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // transaction, which means there may be less time spent initializing the 1155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // next transaction because it doesn't have to re-aquire locks. 1165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 1175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This must be called before Open() to have an effect. 1185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void set_exclusive_locking() { exclusive_locking_ = true; } 1195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1209ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // Call to cause Open() to restrict access permissions of the 1219ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // database file to only the owner. 1229ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // TODO(shess): Currently only supported on OS_POSIX, is a noop on 1239ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch // other platforms. 1249ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch void set_restrict_to_user() { restrict_to_user_ = true; } 1259ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch 12690dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Set an error-handling callback. On errors, the error number (and 12790dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // statement, if available) will be passed to the callback. 12890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // 12990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // If no callback is set, the default action is to crash in debug 13090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // mode or return failure in release mode. 13190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) typedef base::Callback<void(int, Statement*)> ErrorCallback; 13290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) void set_error_callback(const ErrorCallback& callback) { 13390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) error_callback_ = callback; 13490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) } 1357dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool has_error_callback() const { 1367dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch return !error_callback_.is_null(); 1377dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch } 13890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) void reset_error_callback() { 13990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) error_callback_.Reset(); 14090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) } 14190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 14290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Set this tag to enable additional connection-type histogramming 14390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // for SQLite error codes and database version numbers. 14490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) void set_histogram_tag(const std::string& tag) { 14590dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) histogram_tag_ = tag; 1462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 1472a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 14890dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Record a sparse UMA histogram sample under 14990dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // |name|+"."+|histogram_tag_|. If |histogram_tag_| is empty, no 15090dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // histogram is recorded. 15190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) void AddTaggedHistogram(const std::string& name, size_t sample) const; 15290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 1535d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Run "PRAGMA integrity_check" and post each line of 1545d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // results into |messages|. Returns the success of running the 1555d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // statement - per the SQLite documentation, if no errors are found the 1565d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // call should succeed, and a single value "ok" should be in messages. 1575d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) bool FullIntegrityCheck(std::vector<std::string>* messages); 1585d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) 1595d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Runs "PRAGMA quick_check" and, unlike the FullIntegrityCheck method, 1605d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // interprets the results returning true if the the statement executes 1615d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // without error and results in a single "ok" value. 1625d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) bool QuickIntegrityCheck() WARN_UNUSED_RESULT; 16390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 1645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Initialization ------------------------------------------------------------ 1655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Initializes the SQL connection for the given file, returning true if the 1675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // file could be opened. You can call this or OpenInMemory. 1682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool Open(const base::FilePath& path) WARN_UNUSED_RESULT; 1695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Initializes the SQL connection for a temporary in-memory database. There 1715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // will be no associated file on disk, and the initial database will be 1725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // empty. You can call this or Open. 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool OpenInMemory() WARN_UNUSED_RESULT; 1745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 175ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Create a temporary on-disk database. The database will be 176ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // deleted after close. This kind of database is similar to 177ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // OpenInMemory() for small databases, but can page to disk if the 178ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // database becomes large. 179ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch bool OpenTemporary() WARN_UNUSED_RESULT; 180ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 1812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Returns true if the database has been successfully opened. 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool is_open() const { return !!db_; } 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Closes the database. This is automatically performed on destruction for 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // you, but this allows you to close the database early. You must not call 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // any other functions after closing it. It is permissable to call Close on 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // an uninitialized or already-closed database. 1885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void Close(); 1895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1905d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // Reads the first <cache-size>*<page-size> bytes of the file to prime the 1915d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // filesystem cache. This can be more efficient than faulting pages 1925d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // individually. Since this involves blocking I/O, it should only be used if 1935d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // the caller will immediately read a substantial amount of data from the 1945d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // database. 1955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 1965d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // TODO(shess): Design a set of histograms or an experiment to inform this 1975d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // decision. Preloading should almost always improve later performance 1985d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // numbers for this database simply because it pulls operations forward, but 1995d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // if the data isn't actually used soon then preloading just slows down 2005d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) // everything else. 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void Preload(); 2025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 203ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Try to trim the cache memory used by the database. If |aggressively| is 204ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // true, this function will try to free all of the cache memory it can. If 205ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // |aggressively| is false, this function will try to cut cache memory 206ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // usage by half. 207ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch void TrimMemory(bool aggressively); 208ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 2095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Raze the database to the ground. This approximates creating a 2105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // fresh database from scratch, within the constraints of SQLite's 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // locking protocol (locks and open handles can make doing this with 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // filesystem operations problematic). Returns true if the database 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // was razed. 2145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // false is returned if the database is locked by some other 2165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // process. RazeWithTimeout() may be used if appropriate. 2175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // NOTE(shess): Raze() will DCHECK in the following situations: 2195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // - database is not open. 2205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // - the connection has a transaction open. 2215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // - a SQLite issue occurs which is structural in nature (like the 2225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // statements used are broken). 2235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Since Raze() is expected to be called in unexpected situations, 2245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // these all return false, since it is unlikely that the caller 2255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // could fix them. 2265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The database's page size is taken from |page_size_|. The 2285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // existing database's |auto_vacuum| setting is lost (the 2295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // possibility of corruption makes it unreliable to pull it from the 2305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // existing database). To re-enable on the empty database requires 2315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // running "PRAGMA auto_vacuum = 1;" then "VACUUM". 2325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // NOTE(shess): For Android, SQLITE_DEFAULT_AUTOVACUUM is set to 1, 2345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // so Raze() sets auto_vacuum to 1. 2355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // TODO(shess): Raze() needs a connection so cannot clear SQLITE_NOTADB. 2375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // TODO(shess): Bake auto_vacuum into Connection's API so it can 2385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // just pick up the default. 2395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool Raze(); 2405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool RazeWithTimout(base::TimeDelta timeout); 2415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2422a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Breaks all outstanding transactions (as initiated by 243ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // BeginTransaction()), closes the SQLite database, and poisons the 244ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // object so that all future operations against the Connection (or 245ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // its Statements) fail safely, without side effects. 2462a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // 247ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // This is intended as an alternative to Close() in error callbacks. 248ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Close() should still be called at some point. 249ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch void Poison(); 250ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 251ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Raze() the database and Poison() the handle. Returns the return 252ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // value from Raze(). 253ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // TODO(shess): Rename to RazeAndPoison(). 2542a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool RazeAndClose(); 2552a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 256eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Delete the underlying database files associated with |path|. 257eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // This should be used on a database which has no existing 258eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // connections. If any other connections are open to the same 259eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // database, this could cause odd results or corruption (for 260eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // instance if a hot journal is deleted but the associated database 261eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // is not). 262eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // 263eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // Returns true if the database file and associated journals no 264eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // longer exist, false otherwise. If the database has never 265eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch // existed, this will return true. 266eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch static bool Delete(const base::FilePath& path); 267eb525c5499e34cc9c4b825d6d9e75bb07cc06aceBen Murdoch 2685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Transactions -------------------------------------------------------------- 2695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Transaction management. We maintain a virtual transaction stack to emulate 2715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // nested transactions since sqlite can't do nested transactions. The 2725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // limitation is you can't roll back a sub transaction: if any transaction 2735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // fails, all transactions open will also be rolled back. Any nested 2745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // transactions after one has rolled back will return fail for Begin(). If 2755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Begin() fails, you must not call Commit or Rollback(). 2765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Normally you should use sql::Transaction to manage a transaction, which 2785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // will scope it to a C++ context. 2795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool BeginTransaction(); 2805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void RollbackTransaction(); 2815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool CommitTransaction(); 2825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 283ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Rollback all outstanding transactions. Use with care, there may 284ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // be scoped transactions on the stack. 285ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch void RollbackAllTransactions(); 286ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 2875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns the current transaction nesting, which will be 0 if there are 2885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // no open transactions. 2895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int transaction_nesting() const { return transaction_nesting_; } 2905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 291ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Attached databases--------------------------------------------------------- 292ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 293ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // SQLite supports attaching multiple database files to a single 294ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // handle. Attach the database in |other_db_path| to the current 295ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // handle under |attachment_point|. |attachment_point| should only 296ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // contain characters from [a-zA-Z0-9_]. 297ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // 298ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // Note that calling attach or detach with an open transaction is an 299ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // error. 300ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch bool AttachDatabase(const base::FilePath& other_db_path, 301ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch const char* attachment_point); 302ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch bool DetachDatabase(const char* attachment_point); 303ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 3045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Statements ---------------------------------------------------------------- 3055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Executes the given SQL string, returning true on success. This is 3075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // normally used for simple, 1-off statements that don't take any bound 3085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // parameters and don't return any data (e.g. CREATE TABLE). 3095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // This will DCHECK if the |sql| contains errors. 3115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Do not use ignore_result() to ignore all errors. Use 3135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // ExecuteAndReturnErrorCode() and ignore only specific errors. 3145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool Execute(const char* sql) WARN_UNUSED_RESULT; 3155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Like Execute(), but returns the error code given by SQLite. 3175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int ExecuteAndReturnErrorCode(const char* sql) WARN_UNUSED_RESULT; 3185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns true if we have a statement with the given identifier already 3205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // cached. This is normally not necessary to call, but can be useful if the 3215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // caller has to dynamically build up SQL to avoid doing so if it's already 3225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // cached. 3235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool HasCachedStatement(const StatementID& id) const; 3245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns a statement for the given SQL using the statement cache. It can 3265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // take a nontrivial amount of work to parse and compile a statement, so 3275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // keeping commonly-used ones around for future use is important for 3285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // performance. 3295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // If the |sql| has an error, an invalid, inert StatementRef is returned (and 3315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // the code will crash in debug). The caller must deal with this eventuality, 3325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // either by checking validity of the |sql| before calling, by correctly 3335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // handling the return of an inert statement, or both. 3345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The StatementID and the SQL must always correspond to one-another. The 3365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // ID is the lookup into the cache, so crazy things will happen if you use 3375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // different SQL with the same ID. 3385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // You will normally use the SQL_FROM_HERE macro to generate a statement 3405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // ID associated with the current line of code. This gives uniqueness without 3415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // you having to manage unique names. See StatementID above for more. 3425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Example: 3445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // sql::Statement stmt(connection_.GetCachedStatement( 3455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // SQL_FROM_HERE, "SELECT * FROM foo")); 3465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // if (!stmt) 3475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // return false; // Error creating statement. 3485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<StatementRef> GetCachedStatement(const StatementID& id, 3495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char* sql); 3505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Used to check a |sql| statement for syntactic validity. If the statement is 3525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // valid SQL, returns true. 3535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool IsSQLValid(const char* sql); 3545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns a non-cached statement for the given SQL. Use this for SQL that 3565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // is only executed once or only rarely (there is overhead associated with 3575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // keeping a statement cached). 3585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 3595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // See GetCachedStatement above for examples and error information. 3605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<StatementRef> GetUniqueStatement(const char* sql); 3615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Info querying ------------------------------------------------------------- 3635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns true if the given table exists. 3655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DoesTableExist(const char* table_name) const; 3665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns true if the given index exists. 3685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DoesIndexExist(const char* index_name) const; 3695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns true if a column with the given name exists in the given table. 3715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DoesColumnExist(const char* table_name, const char* column_name) const; 3725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns sqlite's internal ID for the last inserted row. Valid only 3745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // immediately after an insert. 3755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int64 GetLastInsertRowId() const; 3765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns sqlite's count of the number of rows modified by the last 3785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // statement executed. Will be 0 if no statement has executed or the database 3795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // is closed. 3805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int GetLastChangeCount() const; 3815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Errors -------------------------------------------------------------------- 3835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns the error code associated with the last sqlite operation. 3855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int GetErrorCode() const; 3865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns the errno associated with GetErrorCode(). See 3885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // SQLITE_LAST_ERRNO in SQLite documentation. 3895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int GetLastErrno() const; 3905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns a pointer to a statically allocated string associated with the 3925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // last sqlite operation. 3935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const char* GetErrorMessage() const; 3945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3953551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // Return a reproducible representation of the schema equivalent to 3963551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // running the following statement at a sqlite3 command-line: 3973551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) // SELECT type, name, tbl_name, sql FROM sqlite_master ORDER BY 1, 2, 3, 4; 3983551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) std::string GetSchema() const; 3993551c9c881056c480085172ff9840cab31610854Torne (Richard Coles) 40068043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) // Clients which provide an error_callback don't see the 40168043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) // error-handling at the end of OnSqliteError(). Expose to allow 40268043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) // those clients to work appropriately with ScopedErrorIgnorer in 40368043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) // tests. 40468043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) static bool ShouldIgnoreSqliteError(int error); 40568043e1e95eeb07d5cae7aca370b26518b0867d6Torne (Richard Coles) 4065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 407ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch // For recovery module. 408ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch friend class Recovery; 409ca12bfac764ba476d6cd062bf1dde12cc64c3f40Ben Murdoch 4107d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) // Allow test-support code to set/reset error ignorer. 4117d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) friend class ScopedErrorIgnorer; 4127d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) 4135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Statement accesses StatementRef which we don't want to expose to everybody 4145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // (they should go through Statement). 4155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) friend class Statement; 4165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Internal initialize function used by both Init and InitInMemory. The file 4185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // name is always 8 bits since we want to use the 8-bit version of 4195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // sqlite3_open. The string can also be sqlite's special ":memory:" string. 4207dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // 4217dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // |retry_flag| controls retrying the open if the error callback 4227dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch // addressed errors using RazeAndClose(). 4237dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch enum Retry { 4247dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch NO_RETRY = 0, 4257dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch RETRY_ON_POISON 4267dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch }; 4277dbb3d5cf0c15f500944d211057644d6a2f37371Ben Murdoch bool OpenInternal(const std::string& file_name, Retry retry_flag); 4285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4292a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // Internal close function used by Close() and RazeAndClose(). 4302a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // |forced| indicates that orderly-shutdown checks should not apply. 4312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void CloseInternal(bool forced); 4322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Check whether the current thread is allowed to make IO calls, but only 4345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // if database wasn't open in memory. Function is inlined to be a no-op in 4355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // official build. 4365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void AssertIOAllowed() { 4375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (!in_memory_) 4385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) base::ThreadRestrictions::AssertIOAllowed(); 4395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Internal helper for DoesTableExist and DoesIndexExist. 4425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DoesTableOrIndexExist(const char* name, const char* type) const; 4435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4447d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) // Accessors for global error-ignorer, for injecting behavior during tests. 4457d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) // See test/scoped_error_ignorer.h. 4467d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) typedef base::Callback<bool(int)> ErrorIgnorerCallback; 4477d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) static ErrorIgnorerCallback* current_ignorer_cb_; 4487d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) static void SetErrorIgnorer(ErrorIgnorerCallback* ignorer); 4497d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) static void ResetErrorIgnorer(); 4507d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) 4515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // A StatementRef is a refcounted wrapper around a sqlite statement pointer. 4525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Refcounting allows us to give these statements out to sql::Statement 4535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // objects while also optionally maintaining a cache of compiled statements 4545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // by just keeping a refptr to these objects. 4555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 4565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // A statement ref can be valid, in which case it can be used, or invalid to 4575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // indicate that the statement hasn't been created yet, has an error, or has 4585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // been destroyed. 4595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 4605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The Connection may revoke a StatementRef in some error cases, so callers 4615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // should always check validity before using. 4625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) class SQL_EXPORT StatementRef : public base::RefCounted<StatementRef> { 4635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) public: 4642a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // |connection| is the sql::Connection instance associated with 4652a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // the statement, and is used for tracking outstanding statements 4662a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // and for error handling. Set to NULL for invalid or untracked 4672a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // refs. |stmt| is the actual statement, and should only be NULL 4682a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to create an invalid ref. |was_valid| indicates whether the 4692a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // statement should be considered valid for diagnistic purposes. 4702a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // |was_valid| can be true for NULL |stmt| if the connection has 4712a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // been forcibly closed by an error handler. 4722a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) StatementRef(Connection* connection, sqlite3_stmt* stmt, bool was_valid); 4735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // When true, the statement can be used. 4755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool is_valid() const { return !!stmt_; } 4765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4772a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // When true, the statement is either currently valid, or was 4782a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // previously valid but the connection was forcibly closed. Used 4792a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // for diagnostic checks. 4802a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool was_valid() const { return was_valid_; } 4812a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4822a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // If we've not been linked to a connection, this will be NULL. 4832a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // TODO(shess): connection_ can be NULL in case of GetUntrackedStatement(), 4842a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // which prevents Statement::OnError() from forwarding errors. 4855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Connection* connection() const { return connection_; } 4865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Returns the sqlite statement if any. If the statement is not active, 4885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // this will return NULL. 4895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) sqlite3_stmt* stmt() const { return stmt_; } 4905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Destroys the compiled statement and marks it NULL. The statement will 4922a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // no longer be active. |forced| is used to indicate if orderly-shutdown 4932a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // checks should apply (see Connection::RazeAndClose()). 4942a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void Close(bool forced); 4955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Check whether the current thread is allowed to make IO calls, but only 4975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // if database wasn't open in memory. 4985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void AssertIOAllowed() { if (connection_) connection_->AssertIOAllowed(); } 4995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) private: 5015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) friend class base::RefCounted<StatementRef>; 5025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ~StatementRef(); 5045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Connection* connection_; 5065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) sqlite3_stmt* stmt_; 5072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool was_valid_; 5085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DISALLOW_COPY_AND_ASSIGN(StatementRef); 5105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 5115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) friend class StatementRef; 5125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Executes a rollback statement, ignoring all transaction state. Used 5145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // internally in the transaction management code. 5155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DoRollback(); 5165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Called by a StatementRef when it's being created or destroyed. See 5185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // open_statements_ below. 5195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void StatementRefCreated(StatementRef* ref); 5205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void StatementRefDeleted(StatementRef* ref); 5215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5224e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // Called when a sqlite function returns an error, which is passed 5234e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // as |err|. The return value is the error code to be reflected 5244e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // back to client code. |stmt| is non-NULL if the error relates to 5254e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // an sql::Statement instance. |sql| is non-NULL if the error 5264e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // relates to non-statement sql code (Execute, for instance). Both 5274e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // can be NULL, but both should never be set. 5284e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // NOTE(shess): Originally, the return value was intended to allow 5294e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // error handlers to transparently convert errors into success. 5304e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // Unfortunately, transactions are not generally restartable, so 5314e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) // this did not work out. 5324e180b6a0b4720a9b8e9e959a882386f690f08ffTorne (Richard Coles) int OnSqliteError(int err, Statement* stmt, const char* sql); 5335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Like |Execute()|, but retries if the database is locked. 5355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool ExecuteWithTimeout(const char* sql, base::TimeDelta ms_timeout) 5365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) WARN_UNUSED_RESULT; 5375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Internal helper for const functions. Like GetUniqueStatement(), 5395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // except the statement is not entered into open_statements_, 5405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // allowing this function to be const. Open statements can block 5415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // closing the database, so only use in cases where the last ref is 5425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // released before close could be called (which should always be the 5435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // case for const functions). 5445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) scoped_refptr<StatementRef> GetUntrackedStatement(const char* sql) const; 5455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5465d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) bool IntegrityCheckHelper( 5475d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) const char* pragma_sql, 5485d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) std::vector<std::string>* messages) WARN_UNUSED_RESULT; 5495d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) 5505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // The actual sqlite database. Will be NULL before Init has been called or if 5515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Init resulted in an error. 5525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) sqlite3* db_; 5535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Parameters we'll configure in sqlite before doing anything else. Zero means 5555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // use the default value. 5565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int page_size_; 5575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int cache_size_; 5585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool exclusive_locking_; 5599ab5563a3196760eb381d102cbb2bc0f7abc6a50Ben Murdoch bool restrict_to_user_; 5605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // All cached statements. Keeping a reference to these statements means that 5625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // they'll remain active. 5635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef std::map<StatementID, scoped_refptr<StatementRef> > 5645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedStatementMap; 5655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedStatementMap statement_cache_; 5665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // A list of all StatementRefs we've given out. Each ref must register with 5685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // us when it's created or destroyed. This allows us to potentially close 5695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // any open statements when we encounter an error. 5705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef std::set<StatementRef*> StatementRefSet; 5715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StatementRefSet open_statements_; 5725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Number of currently-nested transactions. 5745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) int transaction_nesting_; 5755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // True if any of the currently nested transactions have been rolled back. 5775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // When we get to the outermost transaction, this will determine if we do 5785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // a rollback instead of a commit. 5795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool needs_rollback_; 5805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // True if database is open with OpenInMemory(), False if database is open 5825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // with Open(). 5835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool in_memory_; 5845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5852a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // |true| if the connection was closed using RazeAndClose(). Used 5862a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // to enable diagnostics to distinguish calls to never-opened 5872a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // databases (incorrect use of the API) from calls to once-valid 5882a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) // databases. 5892a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) bool poisoned_; 5902a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 59190dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) ErrorCallback error_callback_; 59290dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) 59390dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) // Tag for auxiliary histograms. 59490dce4d38c5ff5333bea97d859d4e484e27edf0cTorne (Richard Coles) std::string histogram_tag_; 5952a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 5965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DISALLOW_COPY_AND_ASSIGN(Connection); 5975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)}; 5985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} // namespace sql 6005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#endif // SQL_CONNECTION_H_ 602