1581fbbbfd79f2fd67ded0f3a2b58ac194a05fde
[WebKit-https.git] / Source / WebCore / storage / 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)
30 #if USE(LEVELDB)
31
32 #include <wtf/RefPtr.h>
33 #include <wtf/Vector.h>
34 #include <wtf/text/WTFString.h>
35
36 namespace WebCore {
37
38 class IDBKey;
39 class LevelDBSlice;
40
41 namespace IDBLevelDBCoding {
42
43 const unsigned char kMinimumIndexId = 30;
44
45 Vector<char> encodeByte(unsigned char);
46 Vector<char> maxIDBKey();
47 Vector<char> minIDBKey();
48 Vector<char> encodeInt(int64_t);
49 int64_t decodeInt(const char* begin, const char* end);
50 Vector<char> encodeVarInt(int64_t);
51 const char* decodeVarInt(const char *p, const char* limit, int64_t& foundInt);
52 Vector<char> encodeString(const String&);
53 String decodeString(const char* p, const char* end);
54 Vector<char> encodeStringWithLength(const String&);
55 const char* decodeStringWithLength(const char* p, const char* limit, String& foundString);
56 int compareEncodedStringsWithLength(const char*& p, const char* limitP, const char*& q, const char* limitQ);
57 Vector<char> encodeDouble(double);
58 const char* decodeDouble(const char* p, const char* limit, double*);
59 void encodeIDBKey(const IDBKey&, Vector<char>& into);
60 Vector<char> encodeIDBKey(const IDBKey&);
61 const char* decodeIDBKey(const char* p, const char* limit, RefPtr<IDBKey>& foundKey);
62 const char* extractEncodedIDBKey(const char* start, const char* limit, Vector<char>* result);
63 int compareEncodedIDBKeys(const Vector<char>&, const Vector<char>&);
64
65 int compare(const LevelDBSlice&, const LevelDBSlice&, bool indexKeys = false);
66
67 class KeyPrefix {
68 public:
69     KeyPrefix();
70     KeyPrefix(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
71
72     static const char* decode(const char* start, const char* limit, KeyPrefix* result);
73     Vector<char> encode() const;
74     int compare(const KeyPrefix& other) const;
75
76     enum Type {
77         kGlobalMetaData,
78         kDatabaseMetaData,
79         kObjectStoreData,
80         kExistsEntry,
81         kIndexData,
82         kInvalidType
83     };
84
85     Type type() const;
86
87     int64_t m_databaseId;
88     int64_t m_objectStoreId;
89     int64_t m_indexId;
90
91     static const int64_t kInvalidId = -1;
92 };
93
94 class SchemaVersionKey {
95 public:
96     static Vector<char> encode();
97 };
98
99 class MaxDatabaseIdKey {
100 public:
101     static Vector<char> encode();
102 };
103
104 class DatabaseFreeListKey {
105 public:
106     DatabaseFreeListKey();
107     static const char* decode(const char* start, const char* limit, DatabaseFreeListKey* result);
108     static Vector<char> encode(int64_t databaseId);
109     static Vector<char> encodeMaxKey();
110     int64_t databaseId() const;
111     int compare(const DatabaseFreeListKey& other) const;
112
113 private:
114     int64_t m_databaseId;
115 };
116
117 class DatabaseNameKey {
118 public:
119     static const char* decode(const char* start, const char* limit, DatabaseNameKey* result);
120     static Vector<char> encode(const String& origin, const String& databaseName);
121     static Vector<char> encodeMinKeyForOrigin(const String& origin);
122     static Vector<char> encodeStopKeyForOrigin(const String& origin);
123     String origin() const { return m_origin; }
124     String databaseName() const { return m_databaseName; }
125     int compare(const DatabaseNameKey& other);
126
127 private:
128     String m_origin; // FIXME: Store encoded strings, or just pointers.
129     String m_databaseName;
130 };
131
132 class DatabaseMetaDataKey {
133 public:
134     enum MetaDataType {
135         kOriginName = 0,
136         kDatabaseName = 1,
137         kUserVersion = 2,
138         kMaxObjectStoreId = 3
139     };
140
141     static Vector<char> encode(int64_t databaseId, MetaDataType);
142 };
143
144 class ObjectStoreMetaDataKey {
145 public:
146     ObjectStoreMetaDataKey();
147     static const char* decode(const char* start, const char* limit, ObjectStoreMetaDataKey* result);
148     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t metaDataType);
149     static Vector<char> encodeMaxKey(int64_t databaseId);
150     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
151     int64_t objectStoreId() const;
152     int64_t metaDataType() const;
153     int compare(const ObjectStoreMetaDataKey& other);
154
155 private:
156     int64_t m_objectStoreId;
157     int64_t m_metaDataType; // FIXME: Make this a byte.
158 };
159
160 class IndexMetaDataKey {
161 public:
162     IndexMetaDataKey();
163     static const char* decode(const char* start, const char* limit, IndexMetaDataKey* result);
164     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId, unsigned char metaDataType);
165     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
166     int compare(const IndexMetaDataKey& other);
167     int64_t indexId() const;
168     unsigned char metaDataType() const { return m_metaDataType; }
169
170 private:
171     int64_t m_objectStoreId;
172     int64_t m_indexId;
173     unsigned char m_metaDataType;
174 };
175
176 class ObjectStoreFreeListKey {
177 public:
178     ObjectStoreFreeListKey();
179     static const char* decode(const char* start, const char* limit, ObjectStoreFreeListKey* result);
180     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId);
181     static Vector<char> encodeMaxKey(int64_t databaseId);
182     int64_t objectStoreId() const;
183     int compare(const ObjectStoreFreeListKey& other);
184
185 private:
186     int64_t m_objectStoreId;
187 };
188
189 class IndexFreeListKey {
190 public:
191     IndexFreeListKey();
192     static const char* decode(const char* start, const char* limit, IndexFreeListKey* result);
193     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId);
194     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
195     int compare(const IndexFreeListKey& other);
196     int64_t objectStoreId() const;
197     int64_t indexId() const;
198
199 private:
200     int64_t m_objectStoreId;
201     int64_t m_indexId;
202 };
203
204 class ObjectStoreNamesKey {
205 public:
206     // FIXME: We never use this to look up object store ids, because a mapping
207     // is kept in the IDBDatabaseBackendImpl. Can the mapping become unreliable?
208     // Can we remove this?
209     static const char* decode(const char* start, const char* limit, ObjectStoreNamesKey* result);
210     static Vector<char> encode(int64_t databaseId, const String& objectStoreName);
211     int compare(const ObjectStoreNamesKey& other);
212     String objectStoreName() const { return m_objectStoreName; }
213
214 private:
215     String m_objectStoreName; // FIXME: Store the encoded string, or just pointers to it.
216 };
217
218 class IndexNamesKey {
219 public:
220     IndexNamesKey();
221     // FIXME: We never use this to look up index ids, because a mapping
222     // is kept at a higher level.
223     static const char* decode(const char* start, const char* limit, IndexNamesKey* result);
224     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const String& indexName);
225     int compare(const IndexNamesKey& other);
226     String indexName() const { return m_indexName; }
227
228 private:
229     int64_t m_objectStoreId;
230     String m_indexName;
231 };
232
233 class ObjectStoreDataKey {
234 public:
235     static const char* decode(const char* start, const char* end, ObjectStoreDataKey* result);
236     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const Vector<char> encodedUserKey);
237     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const IDBKey& userKey);
238     int compare(const ObjectStoreDataKey& other);
239     PassRefPtr<IDBKey> userKey() const;
240     static const int64_t kSpecialIndexNumber;
241
242 private:
243     Vector<char> m_encodedUserKey;
244 };
245
246 class ExistsEntryKey {
247 public:
248     static const char* decode(const char* start, const char* end, ExistsEntryKey* result);
249     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const Vector<char>& encodedKey);
250     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, const IDBKey& userKey);
251     int compare(const ExistsEntryKey& other);
252     PassRefPtr<IDBKey> userKey() const;
253
254     static const int64_t kSpecialIndexNumber;
255
256 private:
257     Vector<char> m_encodedUserKey;
258 };
259
260 class IndexDataKey {
261 public:
262     IndexDataKey();
263     static const char* decode(const char* start, const char* limit, IndexDataKey* result);
264     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const Vector<char>& encodedUserKey, int64_t sequenceNumber);
265     static Vector<char> encode(int64_t databaseId, int64_t objectStoreId, int64_t indexId, const IDBKey& userKey, int64_t sequenceNumber);
266     static Vector<char> encodeMaxKey(int64_t databaseId, int64_t objectStoreId);
267     int compare(const IndexDataKey& other, bool ignoreSequenceNumber);
268     int64_t databaseId() const;
269     int64_t objectStoreId() const;
270     int64_t indexId() const;
271     PassRefPtr<IDBKey> userKey() const;
272
273 private:
274     int64_t m_databaseId;
275     int64_t m_objectStoreId;
276     int64_t m_indexId;
277     Vector<char> m_encodedUserKey;
278     int64_t m_sequenceNumber;
279 };
280
281 } // namespace IDBLevelDBCoding
282
283 } // namespace WebCore
284
285 #endif // USE(LEVELDB)
286 #endif // ENABLE(INDEXED_DATABASE)
287
288 #endif // IDBLevelDBCoding_h