c329273bef0abbe73d0d3a7d2ef9e9264d2f127b
[WebKit-https.git] / Source / WebCore / platform / sql / SQLiteDatabase.h
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2007 Justin Haygood (jhaygood@reaktix.com)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #ifndef SQLiteDatabase_h
28 #define SQLiteDatabase_h
29
30 #include "PlatformString.h"
31 #include <wtf/Threading.h>
32
33 #if COMPILER(MSVC)
34 #pragma warning(disable: 4800)
35 #endif
36
37 struct sqlite3;
38
39 namespace WebCore {
40
41 class DatabaseAuthorizer;
42 class SQLiteStatement;
43 class SQLiteTransaction;
44
45 extern const int SQLResultDone;
46 extern const int SQLResultError;
47 extern const int SQLResultOk;
48 extern const int SQLResultRow;
49 extern const int SQLResultSchema;
50 extern const int SQLResultFull;
51 extern const int SQLResultInterrupt;
52
53 class SQLiteDatabase : public Noncopyable {
54     friend class SQLiteTransaction;
55 public:
56     SQLiteDatabase();
57     ~SQLiteDatabase();
58
59     bool open(const String& filename, bool forWebSQLDatabase = false);
60     bool isOpen() const { return m_db; }
61     void close();
62     void interrupt();
63     bool isInterrupted();
64
65     bool executeCommand(const String&);
66     bool returnsAtLeastOneResult(const String&);
67     
68     bool tableExists(const String&);
69     void clearAllTables();
70     void runVacuumCommand();
71     void runIncrementalVacuumCommand();
72     
73     bool transactionInProgress() const { return m_transactionInProgress; }
74     
75     int64_t lastInsertRowID();
76     int lastChanges();
77
78     void setBusyTimeout(int ms);
79     void setBusyHandler(int(*)(void*, int));
80     
81     void setFullsync(bool);
82     
83     // Gets/sets the maximum size in bytes
84     // Depending on per-database attributes, the size will only be settable in units that are the page size of the database, which is established at creation
85     // These chunks will never be anything other than 512, 1024, 2048, 4096, 8192, 16384, or 32768 bytes in size.
86     // setMaximumSize() will round the size down to the next smallest chunk if the passed size doesn't align.
87     int64_t maximumSize();
88     void setMaximumSize(int64_t);
89     
90     // Gets the number of unused bytes in the database file.
91     int64_t freeSpaceSize();
92     int64_t totalSize();
93
94     // The SQLite SYNCHRONOUS pragma can be either FULL, NORMAL, or OFF
95     // FULL - Any writing calls to the DB block until the data is actually on the disk surface
96     // NORMAL - SQLite pauses at some critical moments when writing, but much less than FULL
97     // OFF - Calls return immediately after the data has been passed to disk
98     enum SynchronousPragma { SyncOff = 0, SyncNormal = 1, SyncFull = 2 };
99     void setSynchronous(SynchronousPragma);
100     
101     int lastError();
102     const char* lastErrorMsg();
103     
104     sqlite3* sqlite3Handle() const {
105         ASSERT(m_sharable || currentThread() == m_openingThread);
106         return m_db;
107     }
108     
109     void setAuthorizer(PassRefPtr<DatabaseAuthorizer>);
110
111     Mutex& databaseMutex() { return m_lockingMutex; }
112     bool isAutoCommitOn() const;
113
114     // The SQLite AUTO_VACUUM pragma can be either NONE, FULL, or INCREMENTAL.
115     // NONE - SQLite does not do any vacuuming
116     // FULL - SQLite moves all empty pages to the end of the DB file and truncates
117     //        the file to remove those pages after every transaction. This option
118     //        requires SQLite to store additional information about each page in
119     //        the database file.
120     // INCREMENTAL - SQLite stores extra information for each page in the database
121     //               file, but removes the empty pages only when PRAGMA INCREMANTAL_VACUUM
122     //               is called.
123     enum AutoVacuumPragma { AutoVacuumNone = 0, AutoVacuumFull = 1, AutoVacuumIncremental = 2 };
124     bool turnOnIncrementalAutoVacuum();
125
126     // Set this flag to allow access from multiple threads.  Not all multi-threaded accesses are safe!
127     // See http://www.sqlite.org/cvstrac/wiki?p=MultiThreading for more info.
128 #ifndef NDEBUG
129     void disableThreadingChecks();
130 #else
131     void disableThreadingChecks() {}
132 #endif
133
134 private:
135     static int authorizerFunction(void*, int, const char*, const char*, const char*, const char*);
136
137     void enableAuthorizer(bool enable);
138     
139     int pageSize();
140     
141     sqlite3* m_db;
142     int m_pageSize;
143     
144     bool m_transactionInProgress;
145     bool m_sharable;
146     
147     Mutex m_authorizerLock;
148     RefPtr<DatabaseAuthorizer> m_authorizer;
149
150     Mutex m_lockingMutex;
151     ThreadIdentifier m_openingThread;
152
153     Mutex m_databaseClosingMutex;
154     bool m_interrupted;
155 }; // class SQLiteDatabase
156
157 } // namespace WebCore
158
159 #endif