Part 2 of removing PlatformString.h, remove PlatformString.h
[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 <wtf/Threading.h>
31 #include <wtf/text/CString.h>
32 #include <wtf/text/WTFString.h>
33
34 #if COMPILER(MSVC)
35 #pragma warning(disable: 4800)
36 #endif
37
38 struct sqlite3;
39
40 namespace WebCore {
41
42 class DatabaseAuthorizer;
43 class SQLiteStatement;
44 class SQLiteTransaction;
45
46 extern const int SQLResultDone;
47 extern const int SQLResultError;
48 extern const int SQLResultOk;
49 extern const int SQLResultRow;
50 extern const int SQLResultSchema;
51 extern const int SQLResultFull;
52 extern const int SQLResultInterrupt;
53
54 class SQLiteDatabase {
55     WTF_MAKE_NONCOPYABLE(SQLiteDatabase);
56     friend class SQLiteTransaction;
57 public:
58     SQLiteDatabase();
59     ~SQLiteDatabase();
60
61     bool open(const String& filename, bool forWebSQLDatabase = false);
62     bool isOpen() const { return m_db; }
63     void close();
64     void interrupt();
65     bool isInterrupted();
66
67     bool executeCommand(const String&);
68     bool returnsAtLeastOneResult(const String&);
69     
70     bool tableExists(const String&);
71     void clearAllTables();
72     int runVacuumCommand();
73     int runIncrementalVacuumCommand();
74     
75     bool transactionInProgress() const { return m_transactionInProgress; }
76     
77     int64_t lastInsertRowID();
78     int lastChanges();
79
80     void setBusyTimeout(int ms);
81     void setBusyHandler(int(*)(void*, int));
82     
83     void setFullsync(bool);
84     
85     // Gets/sets the maximum size in bytes
86     // 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
87     // These chunks will never be anything other than 512, 1024, 2048, 4096, 8192, 16384, or 32768 bytes in size.
88     // setMaximumSize() will round the size down to the next smallest chunk if the passed size doesn't align.
89     int64_t maximumSize();
90     void setMaximumSize(int64_t);
91     
92     // Gets the number of unused bytes in the database file.
93     int64_t freeSpaceSize();
94     int64_t totalSize();
95
96     // The SQLite SYNCHRONOUS pragma can be either FULL, NORMAL, or OFF
97     // FULL - Any writing calls to the DB block until the data is actually on the disk surface
98     // NORMAL - SQLite pauses at some critical moments when writing, but much less than FULL
99     // OFF - Calls return immediately after the data has been passed to disk
100     enum SynchronousPragma { SyncOff = 0, SyncNormal = 1, SyncFull = 2 };
101     void setSynchronous(SynchronousPragma);
102     
103     int lastError();
104     const char* lastErrorMsg();
105     
106     sqlite3* sqlite3Handle() const {
107         ASSERT(m_sharable || currentThread() == m_openingThread || !m_db);
108         return m_db;
109     }
110     
111     void setAuthorizer(PassRefPtr<DatabaseAuthorizer>);
112
113     Mutex& databaseMutex() { return m_lockingMutex; }
114     bool isAutoCommitOn() const;
115
116     // The SQLite AUTO_VACUUM pragma can be either NONE, FULL, or INCREMENTAL.
117     // NONE - SQLite does not do any vacuuming
118     // FULL - SQLite moves all empty pages to the end of the DB file and truncates
119     //        the file to remove those pages after every transaction. This option
120     //        requires SQLite to store additional information about each page in
121     //        the database file.
122     // INCREMENTAL - SQLite stores extra information for each page in the database
123     //               file, but removes the empty pages only when PRAGMA INCREMANTAL_VACUUM
124     //               is called.
125     enum AutoVacuumPragma { AutoVacuumNone = 0, AutoVacuumFull = 1, AutoVacuumIncremental = 2 };
126     bool turnOnIncrementalAutoVacuum();
127
128     // Set this flag to allow access from multiple threads.  Not all multi-threaded accesses are safe!
129     // See http://www.sqlite.org/cvstrac/wiki?p=MultiThreading for more info.
130 #ifndef NDEBUG
131     void disableThreadingChecks();
132 #else
133     void disableThreadingChecks() {}
134 #endif
135
136 private:
137     static int authorizerFunction(void*, int, const char*, const char*, const char*, const char*);
138
139     void enableAuthorizer(bool enable);
140     
141     int pageSize();
142     
143     sqlite3* m_db;
144     int m_pageSize;
145     
146     bool m_transactionInProgress;
147     bool m_sharable;
148     
149     Mutex m_authorizerLock;
150     RefPtr<DatabaseAuthorizer> m_authorizer;
151
152     Mutex m_lockingMutex;
153     ThreadIdentifier m_openingThread;
154
155     Mutex m_databaseClosingMutex;
156     bool m_interrupted;
157
158     int m_openError;
159     CString m_openErrorMessage;
160 };
161
162 } // namespace WebCore
163
164 #endif