Merge IDBTransactionBackendInterface and IDBTransactionBackendImpl
[WebKit-https.git] / Source / WebCore / Modules / indexeddb / leveldb / IDBLevelDBCoding.h
1 /*
2  * Copyright (C) 2011 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
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 AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef IDBLevelDBCoding_h
27 #define IDBLevelDBCoding_h
28
29 #if ENABLE(INDEXED_DATABASE) && USE(LEVELDB)
30
31 #include <wtf/RefPtr.h>
32 #include <wtf/Vector.h>
33 #include <wtf/text/WTFString.h>
34
35 namespace WebCore {
36
37 class IDBKey;
38 class IDBKeyPath;
39 class LevelDBSlice;
40
41 namespace IDBLevelDBCoding {
42
43 const unsigned char MinimumIndexId = 30;
44
45 // As most of the IDBKeys and encoded values are short, we initialize some Vectors with a default inline buffer size
46 // to reduce the memory re-allocations when the Vectors are appended.
47 static const size_t DefaultInlineBufferSize = 32;
48
49 Vector<char> encodeByte(unsigned char);
50 const char* decodeByte(const char* p, const char* limit, unsigned char& foundChar);
51 Vector<char> maxIDBKey();
52 Vector<char> minIDBKey();
53 Vector<char> encodeBool(bool);
54 bool decodeBool(const char* begin, const char* end);
55 Vector<char> encodeInt(int64_t);
56 inline Vector<char> encodeIntSafely(int64_t nParam, int64_t max)
57 {
58     ASSERT_UNUSED(max, nParam <= max);
59     return encodeInt(nParam);
60 }
61 int64_t decodeInt(const char* begin, const char* end);
62 Vector<char> encodeVarInt(int64_t);
63 const char* decodeVarInt(const char* p, const char* limit, int64_t& foundInt);
64 Vector<char> encodeString(const String&);
65 String decodeString(const char* p, const char* end);
66 Vector<char> encodeStringWithLength(const String&);
67 const char* decodeStringWithLength(const char* p, const char* limit, String& foundString);
68 int compareEncodedStringsWithLength(const char*& p, const char* limitP, const char*& q, const char* limitQ, bool& ok);
69 Vector<char> encodeDouble(double);
70 const char* decodeDouble(const char* p, const char* limit, double*);
71 void encodeIDBKey(const IDBKey&, Vector<char, DefaultInlineBufferSize>& into);
72 Vector<char> encodeIDBKey(const IDBKey&);
73 const char* decodeIDBKey(const char* p, const char* limit, RefPtr<IDBKey>& foundKey);
74 const char* extractEncodedIDBKey(const char* start, const char* limit, Vector<char>* result);
75 int compareEncodedIDBKeys(const Vector<char>&, const Vector<char>&, bool& ok);
76 Vector<char> encodeIDBKeyPath(const IDBKeyPath&);
77 IDBKeyPath decodeIDBKeyPath(const char*, const char*);
78
79 int compare(const LevelDBSlice&, const LevelDBSlice&, bool indexKeys = false);
80
81 class KeyPrefix {
82 public:
83     KeyPrefix();
84     explicit KeyPrefix(int64_t databaseId);
85     KeyPrefix(int64_t databaseId, int64_t objectStoreId);
86     KeyPrefix(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
87     static KeyPrefix createWithSpecialIndex(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
88
89     static const char* decode(const char* start, const char* limit, KeyPrefix* result);
90     Vector<char> encode() const;
91     static Vector<char> encodeEmpty();
92     int compare(const KeyPrefix& other) const;
93
94     enum Type {
95         GlobalMetaData,
96         DatabaseMetaData,
97         ObjectStoreData,
98         ExistsEntry,
99         IndexData,
100         InvalidType
101     };
102
103     static const size_t kMaxDatabaseIdSizeBits = 3;
104     static const size_t kMaxObjectStoreIdSizeBits = 3;
105     static const size_t kMaxIndexIdSizeBits = 2;
106
107     static const size_t kMaxDatabaseIdSizeBytes = 1ULL << kMaxDatabaseIdSizeBits; // 8
108     static const size_t kMaxObjectStoreIdSizeBytes = 1ULL << kMaxObjectStoreIdSizeBits; // 8
109     static const size_t kMaxIndexIdSizeBytes = 1ULL << kMaxIndexIdSizeBits; // 4
110
111     static const size_t kMaxDatabaseIdBits = kMaxDatabaseIdSizeBytes * 8 - 1; // 63
112     static const size_t kMaxObjectStoreIdBits = kMaxObjectStoreIdSizeBytes * 8 - 1; // 63
113     static const size_t kMaxIndexIdBits = kMaxIndexIdSizeBytes * 8 - 1; // 31
114
115     static const int64_t kMaxDatabaseId = (1ULL << kMaxDatabaseIdBits) - 1; // max signed int64_t
116     static const int64_t kMaxObjectStoreId = (1ULL << kMaxObjectStoreIdBits) - 1; // max signed int64_t
117     static const int64_t kMaxIndexId = (1ULL << kMaxIndexIdBits) - 1; // max signed int32_t
118
119     static bool isValidDatabaseId(int64_t databaseId);
120     static bool isValidObjectStoreId(int64_t indexId);
121     static bool isValidIndexId(int64_t indexId);
122     static bool validIds(int64_t databaseId, int64_t objectStoreId, int64_t indexId)
123     {
124         return isValidDatabaseId(databaseId) && isValidObjectStoreId(objectStoreId) && isValidIndexId(indexId);
125     }
126     static bool validIds(int64_t databaseId, int64_t objectStoreId)
127     {
128         return isValidDatabaseId(databaseId) && isValidObjectStoreId(objectStoreId);
129     }
130
131     Type type() const;
132
133     int64_t m_databaseId;
134     int64_t m_objectStoreId;
135     int64_t m_indexId;
136
137     static const int64_t InvalidId = -1;
138
139 private:
140     static Vector<char> encodeInternal(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
141     // Special constructor for createWithSpecialIndex()
142     KeyPrefix(Type, int64_t databaseId, int64_t objectStoreId, int64_t indexId);
143 };
144
145 class SchemaVersionKey {
146 public:
147     static Vector<char> encode();
148 };
149
150 class MaxDatabaseIdKey {
151 public:
152     static Vector<char> encode();
153 };
154
155 class DataVersionKey {
156 public:
157     static Vector<char> encode();
158 };
159
160 class DatabaseFreeListKey {
161 public:
162     DatabaseFreeListKey();
163     static const char* decode(const char* start, const char* limit, DatabaseFreeListKey* result);
164     static Vector<char> encode(int64_t databaseId);
165     static Vector<char> encodeMaxKey();
166     int64_t databaseId() const;
167     int compare(const DatabaseFreeListKey& other) const;
168
169 private:
170     int64_t m_databaseId;
171 };
172
173 class DatabaseNameKey {
174 public:
175     static const char* decode(const char* start, const char* limit, DatabaseNameKey* result);
176     static Vector<char> encode(const String& origin, const String& databaseName);
177     static Vector<char> encodeMinKeyForOrigin(const String& origin);
178     static Vector<char> encodeStopKeyForOrigin(const String& origin);
179     String origin() const { return m_origin; }
180     String databaseName() const { return m_databaseName; }
181     int compare(const DatabaseNameKey& other);
182
183 private:
184     String m_origin; // FIXME: Store encoded strings, or just pointers.
185     String m_databaseName;
186 };
187
188 class DatabaseMetaDataKey {
189 public:
190     enum MetaDataType {
191         OriginName = 0,
192         DatabaseName = 1,
193         UserVersion = 2,
194         MaxObjectStoreId = 3,
195         UserIntVersion = 4,
196         MaxSimpleMetaDataType = 5
197     };
198
199     static Vector<char> encode(int64_t databaseId, MetaDataType);
200 };
201
202 class ObjectStoreMetaDataKey {
203 public:
204     enum MetaDataType {
205         Name = 0,
206         KeyPath = 1,
207         AutoIncrement = 2,
208         Evictable = 3,
209         LastVersion = 4,
210         MaxIndexId = 5,
211         HasKeyPath = 6,
212         KeyGeneratorCurrentNumber = 7
213     };
214
215     ObjectStoreMetaDataKey();
216     static const char* decode(const char* start, const char* limit, ObjectStoreMetaDataKey* result);
217     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, unsigned char metaDataType);
218     static Vector<char> encodeMaxKey(int64_t databaseId);
219     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
220     int64_t objectStoreId() const;
221     unsigned char metaDataType() const;
222     int compare(const ObjectStoreMetaDataKey& other);
223
224 private:
225     int64_t m_objectStoreId;
226     unsigned char m_metaDataType;
227 };
228
229 class IndexMetaDataKey {
230 public:
231     enum MetaDataType {
232         Name = 0,
233         Unique = 1,
234         KeyPath = 2,
235         MultiEntry = 3
236     };
237
238     IndexMetaDataKey();
239     static const char* decode(const char* start, const char* limit, IndexMetaDataKey* result);
240     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId, unsigned char metaDataType);
241     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
242     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
243     int compare(const IndexMetaDataKey& other);
244     int64_t indexId() const;
245     unsigned char metaDataType() const { return m_metaDataType; }
246
247 private:
248     int64_t m_objectStoreId;
249     int64_t m_indexId;
250     unsigned char m_metaDataType;
251 };
252
253 class ObjectStoreFreeListKey {
254 public:
255     ObjectStoreFreeListKey();
256     static const char* decode(const char* start, const char* limit, ObjectStoreFreeListKey* result);
257     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId);
258     static Vector<char> encodeMaxKey(int64_t databaseId);
259     int64_t objectStoreId() const;
260     int compare(const ObjectStoreFreeListKey& other);
261
262 private:
263     int64_t m_objectStoreId;
264 };
265
266 class IndexFreeListKey {
267 public:
268     IndexFreeListKey();
269     static const char* decode(const char* start, const char* limit, IndexFreeListKey* result);
270     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
271     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
272     int compare(const IndexFreeListKey& other);
273     int64_t objectStoreId() const;
274     int64_t indexId() const;
275
276 private:
277     int64_t m_objectStoreId;
278     int64_t m_indexId;
279 };
280
281 class ObjectStoreNamesKey {
282 public:
283     // FIXME: We never use this to look up object store ids, because a mapping
284     // is kept in the IDBDatabaseBackendImpl. Can the mapping become unreliable?
285     // Can we remove this?
286     static const char* decode(const char* start, const char* limit, ObjectStoreNamesKey* result);
287     static Vector<char> encode(int64_t databaseId, const String& objectStoreName);
288     int compare(const ObjectStoreNamesKey& other);
289     String objectStoreName() const { return m_objectStoreName; }
290
291 private:
292     String m_objectStoreName; // FIXME: Store the encoded string, or just pointers to it.
293 };
294
295 class IndexNamesKey {
296 public:
297     IndexNamesKey();
298     // FIXME: We never use this to look up index ids, because a mapping
299     // is kept at a higher level.
300     static const char* decode(const char* start, const char* limit, IndexNamesKey* result);
301     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const String& indexName);
302     int compare(const IndexNamesKey& other);
303     String indexName() const { return m_indexName; }
304
305 private:
306     int64_t m_objectStoreId;
307     String m_indexName;
308 };
309
310 class ObjectStoreDataKey {
311 public:
312     static const char* decode(const char* start, const char* end, ObjectStoreDataKey* result);
313     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const Vector<char> encodedUserKey);
314     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const IDBKey& userKey);
315     int compare(const ObjectStoreDataKey& other, bool& ok);
316     PassRefPtr<IDBKey> userKey() const;
317     static const int64_t SpecialIndexNumber;
318
319 private:
320     Vector<char> m_encodedUserKey;
321 };
322
323 class ExistsEntryKey {
324 public:
325     static const char* decode(const char* start, const char* end, ExistsEntryKey* result);
326     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const Vector<char>& encodedKey);
327     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const IDBKey& userKey);
328     int compare(const ExistsEntryKey& other, bool& ok);
329     PassRefPtr<IDBKey> userKey() const;
330
331     static const int64_t SpecialIndexNumber;
332
333 private:
334     Vector<char> m_encodedUserKey;
335 };
336
337 class IndexDataKey {
338 public:
339     IndexDataKey();
340     static const char* decode(const char* start, const char* limit, IndexDataKey* result);
341     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const Vector<char>& encodedUserKey, const Vector<char>& encodedPrimaryKey, int64_t sequenceNumber = 0);
342     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKey& userKey);
343     static Vector<char> encodeMinKey(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
344     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
345     int compare(const IndexDataKey& other, bool ignoreDuplicates, bool& ok);
346     int64_t databaseId() const;
347     int64_t objectStoreId() const;
348     int64_t indexId() const;
349     PassRefPtr<IDBKey> userKey() const;
350     PassRefPtr<IDBKey> primaryKey() const;
351
352 private:
353     int64_t m_databaseId;
354     int64_t m_objectStoreId;
355     int64_t m_indexId;
356     Vector<char> m_encodedUserKey;
357     Vector<char> m_encodedPrimaryKey;
358     int64_t m_sequenceNumber;
359 };
360
361 } // namespace IDBLevelDBCoding
362
363 } // namespace WebCore
364
365 #endif // ENABLE(INDEXED_DATABASE) && USE(LEVELDB)
366
367 #endif // IDBLevelDBCoding_h