src/content/browser/indexed_db/indexed_db_leveldb_coding.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
   6 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/logging.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/strings/string16.h"
  15 #include "base/strings/string_piece.h"
  16 #include "content/common/indexed_db/indexed_db_key.h"
  17 #include "content/common/indexed_db/indexed_db_key_path.h"
  18
  19 namespace content {
  20
  21 CONTENT_EXPORT extern const unsigned char kMinimumIndexId;
  22
  23 CONTENT_EXPORT std::string MaxIDBKey();
  24 CONTENT_EXPORT std::string MinIDBKey();
  25
  26 CONTENT_EXPORT void EncodeByte(unsigned char value, std::string* into);
  27 CONTENT_EXPORT void EncodeBool(bool value, std::string* into);
  28 CONTENT_EXPORT void EncodeInt(int64 value, std::string* into);
  29 CONTENT_EXPORT void EncodeVarInt(int64 value, std::string* into);
  30 CONTENT_EXPORT void EncodeString(const string16& value, std::string* into);
  31 CONTENT_EXPORT void EncodeStringWithLength(const string16& value,
  32                                            std::string* into);
  33 CONTENT_EXPORT void EncodeDouble(double value, std::string* into);
  34 CONTENT_EXPORT void EncodeIDBKey(const IndexedDBKey& value, std::string* into);
  35 CONTENT_EXPORT void EncodeIDBKeyPath(const IndexedDBKeyPath& value,
  36                                      std::string* into);
  37
  38 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeByte(base::StringPiece* slice,
  39                                                   unsigned char* value);
  40 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeBool(base::StringPiece* slice,
  41                                                   bool* value);
  42 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeInt(base::StringPiece* slice,
  43                                                  int64* value);
  44 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeVarInt(base::StringPiece* slice,
  45                                                     int64* value);
  46 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeString(base::StringPiece* slice,
  47                                                     string16* value);
  48 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeStringWithLength(
  49     base::StringPiece* slice,
  50     string16* value);
  51 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeDouble(base::StringPiece* slice,
  52                                                     double* value);
  53 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeIDBKey(
  54     base::StringPiece* slice,
  55     scoped_ptr<IndexedDBKey>* value);
  56 CONTENT_EXPORT WARN_UNUSED_RESULT bool DecodeIDBKeyPath(
  57     base::StringPiece* slice,
  58     IndexedDBKeyPath* value);
  59
  60 CONTENT_EXPORT int CompareEncodedStringsWithLength(base::StringPiece* slice1,
  61                                                    base::StringPiece* slice2,
  62                                                    bool* ok);
  63
  64 CONTENT_EXPORT WARN_UNUSED_RESULT bool ExtractEncodedIDBKey(
  65     base::StringPiece* slice,
  66     std::string* result);
  67
  68 CONTENT_EXPORT int CompareEncodedIDBKeys(const std::string& a,
  69                                          const std::string& b,
  70                                          bool* ok);
  71
  72 CONTENT_EXPORT int Compare(const base::StringPiece& a,
  73                            const base::StringPiece& b,
  74                            bool index_keys);
  75
  76 class KeyPrefix {
  77  public:
  78   KeyPrefix();
  79   explicit KeyPrefix(int64 database_id);
  80   KeyPrefix(int64 database_id, int64 object_store_id);
  81   KeyPrefix(int64 database_id, int64 object_store_id, int64 index_id);
  82   static KeyPrefix CreateWithSpecialIndex(int64 database_id,
  83                                           int64 object_store_id,
  84                                           int64 index_id);
  85
  86   static bool Decode(base::StringPiece* slice, KeyPrefix* result);
  87   std::string Encode() const;
  88   static std::string EncodeEmpty();
  89   int Compare(const KeyPrefix& other) const;
  90
  91   enum Type {
  92     GLOBAL_METADATA,
  93     DATABASE_METADATA,
  94     OBJECT_STORE_DATA,
  95     EXISTS_ENTRY,
  96     INDEX_DATA,
  97     INVALID_TYPE
  98   };
  99
 100   static const size_t kMaxDatabaseIdSizeBits = 3;
 101   static const size_t kMaxObjectStoreIdSizeBits = 3;
 102   static const size_t kMaxIndexIdSizeBits = 2;
 103
 104   static const size_t kMaxDatabaseIdSizeBytes =
 105       1ULL << kMaxDatabaseIdSizeBits;  // 8
 106   static const size_t kMaxObjectStoreIdSizeBytes =
 107       1ULL << kMaxObjectStoreIdSizeBits;                                   // 8
 108   static const size_t kMaxIndexIdSizeBytes = 1ULL << kMaxIndexIdSizeBits;  // 4
 109
 110   static const size_t kMaxDatabaseIdBits =
 111       kMaxDatabaseIdSizeBytes * 8 - 1;  // 63
 112   static const size_t kMaxObjectStoreIdBits =
 113       kMaxObjectStoreIdSizeBytes * 8 - 1;                              // 63
 114   static const size_t kMaxIndexIdBits = kMaxIndexIdSizeBytes * 8 - 1;  // 31
 115
 116   static const int64 kMaxDatabaseId =
 117       (1ULL << kMaxDatabaseIdBits) - 1;  // max signed int64
 118   static const int64 kMaxObjectStoreId =
 119       (1ULL << kMaxObjectStoreIdBits) - 1;  // max signed int64
 120   static const int64 kMaxIndexId =
 121       (1ULL << kMaxIndexIdBits) - 1;  // max signed int32
 122
 123   static bool IsValidDatabaseId(int64 database_id);
 124   static bool IsValidObjectStoreId(int64 index_id);
 125   static bool IsValidIndexId(int64 index_id);
 126   static bool ValidIds(int64 database_id,
 127                        int64 object_store_id,
 128                        int64 index_id) {
 129     return IsValidDatabaseId(database_id) &&
 130            IsValidObjectStoreId(object_store_id) && IsValidIndexId(index_id);
 131   }
 132   static bool ValidIds(int64 database_id, int64 object_store_id) {
 133     return IsValidDatabaseId(database_id) &&
 134            IsValidObjectStoreId(object_store_id);
 135   }
 136
 137   Type type() const;
 138
 139   int64 database_id_;
 140   int64 object_store_id_;
 141   int64 index_id_;
 142
 143   static const int64 kInvalidId = -1;
 144
 145  private:
 146   static std::string EncodeInternal(int64 database_id,
 147                                     int64 object_store_id,
 148                                     int64 index_id);
 149   // Special constructor for CreateWithSpecialIndex()
 150   KeyPrefix(enum Type,
 151             int64 database_id,
 152             int64 object_store_id,
 153             int64 index_id);
 154 };
 155
 156 class SchemaVersionKey {
 157  public:
 158   CONTENT_EXPORT static std::string Encode();
 159 };
 160
 161 class MaxDatabaseIdKey {
 162  public:
 163   CONTENT_EXPORT static std::string Encode();
 164 };
 165
 166 class DataVersionKey {
 167  public:
 168   static std::string Encode();
 169 };
 170
 171 class DatabaseFreeListKey {
 172  public:
 173   DatabaseFreeListKey();
 174   static bool Decode(base::StringPiece* slice, DatabaseFreeListKey* result);
 175   CONTENT_EXPORT static std::string Encode(int64 database_id);
 176   static CONTENT_EXPORT std::string EncodeMaxKey();
 177   int64 DatabaseId() const;
 178   int Compare(const DatabaseFreeListKey& other) const;
 179
 180  private:
 181   int64 database_id_;
 182 };
 183
 184 class DatabaseNameKey {
 185  public:
 186   static bool Decode(base::StringPiece* slice, DatabaseNameKey* result);
 187   CONTENT_EXPORT static std::string Encode(const std::string& origin_identifier,
 188                                            const string16& database_name);
 189   static std::string EncodeMinKeyForOrigin(
 190       const std::string& origin_identifier);
 191   static std::string EncodeStopKeyForOrigin(
 192       const std::string& origin_identifier);
 193   string16 origin() const { return origin_; }
 194   string16 database_name() const { return database_name_; }
 195   int Compare(const DatabaseNameKey& other);
 196
 197  private:
 198   string16 origin_;  // TODO(jsbell): Store encoded strings, or just pointers.
 199   string16 database_name_;
 200 };
 201
 202 class DatabaseMetaDataKey {
 203  public:
 204   enum MetaDataType {
 205     ORIGIN_NAME = 0,
 206     DATABASE_NAME = 1,
 207     USER_VERSION = 2,
 208     MAX_OBJECT_STORE_ID = 3,
 209     USER_INT_VERSION = 4,
 210     MAX_SIMPLE_METADATA_TYPE = 5
 211   };
 212
 213   CONTENT_EXPORT static std::string Encode(int64 database_id,
 214                                            MetaDataType type);
 215 };
 216
 217 class ObjectStoreMetaDataKey {
 218  public:
 219   enum MetaDataType {
 220     NAME = 0,
 221     KEY_PATH = 1,
 222     AUTO_INCREMENT = 2,
 223     EVICTABLE = 3,
 224     LAST_VERSION = 4,
 225     MAX_INDEX_ID = 5,
 226     HAS_KEY_PATH = 6,
 227     KEY_GENERATOR_CURRENT_NUMBER = 7
 228   };
 229
 230   ObjectStoreMetaDataKey();
 231   static bool Decode(base::StringPiece* slice, ObjectStoreMetaDataKey* result);
 232   CONTENT_EXPORT static std::string Encode(int64 database_id,
 233                                            int64 object_store_id,
 234                                            unsigned char meta_data_type);
 235   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id);
 236   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id,
 237                                                  int64 object_store_id);
 238   int64 ObjectStoreId() const;
 239   unsigned char MetaDataType() const;
 240   int Compare(const ObjectStoreMetaDataKey& other);
 241
 242  private:
 243   int64 object_store_id_;
 244   unsigned char meta_data_type_;
 245 };
 246
 247 class IndexMetaDataKey {
 248  public:
 249   enum MetaDataType {
 250     NAME = 0,
 251     UNIQUE = 1,
 252     KEY_PATH = 2,
 253     MULTI_ENTRY = 3
 254   };
 255
 256   IndexMetaDataKey();
 257   static bool Decode(base::StringPiece* slice, IndexMetaDataKey* result);
 258   CONTENT_EXPORT static std::string Encode(int64 database_id,
 259                                            int64 object_store_id,
 260                                            int64 index_id,
 261                                            unsigned char meta_data_type);
 262   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id,
 263                                                  int64 object_store_id);
 264   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id,
 265                                                  int64 object_store_id,
 266                                                  int64 index_id);
 267   int Compare(const IndexMetaDataKey& other);
 268   int64 IndexId() const;
 269   unsigned char meta_data_type() const { return meta_data_type_; }
 270
 271  private:
 272   int64 object_store_id_;
 273   int64 index_id_;
 274   unsigned char meta_data_type_;
 275 };
 276
 277 class ObjectStoreFreeListKey {
 278  public:
 279   ObjectStoreFreeListKey();
 280   static bool Decode(base::StringPiece* slice, ObjectStoreFreeListKey* result);
 281   CONTENT_EXPORT static std::string Encode(int64 database_id,
 282                                            int64 object_store_id);
 283   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id);
 284   int64 ObjectStoreId() const;
 285   int Compare(const ObjectStoreFreeListKey& other);
 286
 287  private:
 288   int64 object_store_id_;
 289 };
 290
 291 class IndexFreeListKey {
 292  public:
 293   IndexFreeListKey();
 294   static bool Decode(base::StringPiece* slice, IndexFreeListKey* result);
 295   CONTENT_EXPORT static std::string Encode(int64 database_id,
 296                                            int64 object_store_id,
 297                                            int64 index_id);
 298   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id,
 299                                                  int64 object_store_id);
 300   int Compare(const IndexFreeListKey& other);
 301   int64 ObjectStoreId() const;
 302   int64 IndexId() const;
 303
 304  private:
 305   int64 object_store_id_;
 306   int64 index_id_;
 307 };
 308
 309 class ObjectStoreNamesKey {
 310  public:
 311   // TODO(jsbell): We never use this to look up object store ids,
 312   // because a mapping is kept in the IndexedDBDatabase. Can the
 313   // mapping become unreliable?  Can we remove this?
 314   static bool Decode(base::StringPiece* slice, ObjectStoreNamesKey* result);
 315   CONTENT_EXPORT static std::string Encode(int64 database_id,
 316                                            const string16& object_store_name);
 317   int Compare(const ObjectStoreNamesKey& other);
 318   string16 object_store_name() const { return object_store_name_; }
 319
 320  private:
 321   // TODO(jsbell): Store the encoded string, or just pointers to it.
 322   string16 object_store_name_;
 323 };
 324
 325 class IndexNamesKey {
 326  public:
 327   IndexNamesKey();
 328   // TODO(jsbell): We never use this to look up index ids, because a mapping
 329   // is kept at a higher level.
 330   static bool Decode(base::StringPiece* slice, IndexNamesKey* result);
 331   CONTENT_EXPORT static std::string Encode(int64 database_id,
 332                                            int64 object_store_id,
 333                                            const string16& index_name);
 334   int Compare(const IndexNamesKey& other);
 335   string16 index_name() const { return index_name_; }
 336
 337  private:
 338   int64 object_store_id_;
 339   string16 index_name_;
 340 };
 341
 342 class ObjectStoreDataKey {
 343  public:
 344   static bool Decode(base::StringPiece* slice, ObjectStoreDataKey* result);
 345   CONTENT_EXPORT static std::string Encode(int64 database_id,
 346                                            int64 object_store_id,
 347                                            const std::string encoded_user_key);
 348   static std::string Encode(int64 database_id,
 349                             int64 object_store_id,
 350                             const IndexedDBKey& user_key);
 351   int Compare(const ObjectStoreDataKey& other, bool* ok);
 352   scoped_ptr<IndexedDBKey> user_key() const;
 353   static const int64 kSpecialIndexNumber;
 354   ObjectStoreDataKey();
 355   ~ObjectStoreDataKey();
 356
 357  private:
 358   std::string encoded_user_key_;
 359 };
 360
 361 class ExistsEntryKey {
 362  public:
 363   ExistsEntryKey();
 364   ~ExistsEntryKey();
 365
 366   static bool Decode(base::StringPiece* slice, ExistsEntryKey* result);
 367   CONTENT_EXPORT static std::string Encode(int64 database_id,
 368                                            int64 object_store_id,
 369                                            const std::string& encoded_key);
 370   static std::string Encode(int64 database_id,
 371                             int64 object_store_id,
 372                             const IndexedDBKey& user_key);
 373   int Compare(const ExistsEntryKey& other, bool* ok);
 374   scoped_ptr<IndexedDBKey> user_key() const;
 375
 376   static const int64 kSpecialIndexNumber;
 377
 378  private:
 379   std::string encoded_user_key_;
 380   DISALLOW_COPY_AND_ASSIGN(ExistsEntryKey);
 381 };
 382
 383 class IndexDataKey {
 384  public:
 385   IndexDataKey();
 386   ~IndexDataKey();
 387   static bool Decode(base::StringPiece* slice, IndexDataKey* result);
 388   CONTENT_EXPORT static std::string Encode(
 389       int64 database_id,
 390       int64 object_store_id,
 391       int64 index_id,
 392       const std::string& encoded_user_key,
 393       const std::string& encoded_primary_key,
 394       int64 sequence_number);
 395   static std::string Encode(int64 database_id,
 396                             int64 object_store_id,
 397                             int64 index_id,
 398                             const IndexedDBKey& user_key);
 399   static std::string EncodeMinKey(int64 database_id,
 400                                   int64 object_store_id,
 401                                   int64 index_id);
 402   CONTENT_EXPORT static std::string EncodeMaxKey(int64 database_id,
 403                                                  int64 object_store_id,
 404                                                  int64 index_id);
 405   int Compare(const IndexDataKey& other,
 406               bool only_compare_index_keys,
 407               bool* ok);
 408   int64 DatabaseId() const;
 409   int64 ObjectStoreId() const;
 410   int64 IndexId() const;
 411   scoped_ptr<IndexedDBKey> user_key() const;
 412   scoped_ptr<IndexedDBKey> primary_key() const;
 413
 414  private:
 415   int64 database_id_;
 416   int64 object_store_id_;
 417   int64 index_id_;
 418   std::string encoded_user_key_;
 419   std::string encoded_primary_key_;
 420   int64 sequence_number_;
 421
 422   DISALLOW_COPY_AND_ASSIGN(IndexDataKey);
 423 };
 424
 425 }  // namespace content
 426
 427 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_