小组成员:姚凯文(kevinyao0901),姜嘉琪
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

198 lines
6.8 KiB

  1. // Copyright (c) 2011 The LevelDB 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. See the AUTHORS file for names of contributors.
  4. #ifndef STORAGE_LEVELDB_INCLUDE_OPTIONS_H_
  5. #define STORAGE_LEVELDB_INCLUDE_OPTIONS_H_
  6. #include <stddef.h>
  7. namespace leveldb {
  8. class Cache;
  9. class Comparator;
  10. class Env;
  11. class Snapshot;
  12. class WritableFile;
  13. // DB contents are stored in a set of blocks, each of which holds a
  14. // sequence of key,value pairs. Each block may be compressed before
  15. // being stored in a file. The following enum describes which
  16. // compression method (if any) is used to compress a block.
  17. enum CompressionType {
  18. // NOTE: do not change the values of existing entries, as these are
  19. // part of the persistent format on disk.
  20. kNoCompression = 0x0,
  21. kSnappyCompression = 0x1,
  22. };
  23. // Options to control the behavior of a database (passed to DB::Open)
  24. struct Options {
  25. // -------------------
  26. // Parameters that affect behavior
  27. // Comparator used to define the order of keys in the table.
  28. // Default: a comparator that uses lexicographic byte-wise ordering
  29. //
  30. // REQUIRES: The client must ensure that the comparator supplied
  31. // here has the same name and orders keys *exactly* the same as the
  32. // comparator provided to previous open calls on the same DB.
  33. const Comparator* comparator;
  34. // If true, the database will be created if it is missing.
  35. // Default: false
  36. bool create_if_missing;
  37. // If true, an error is raised if the database already exists.
  38. // Default: false
  39. bool error_if_exists;
  40. // If true, the implementation will do aggressive checking of the
  41. // data it is processing and will stop early if it detects any
  42. // errors. This may have unforeseen ramifications: for example, a
  43. // corruption of one DB entry may cause a large number of entries to
  44. // become unreadable or for the entire DB to become unopenable.
  45. // Default: false
  46. bool paranoid_checks;
  47. // Use the specified object to interact with the environment,
  48. // e.g. to read/write files, schedule background work, etc.
  49. // Default: Env::Default()
  50. Env* env;
  51. // Any internal progress/error information generated by the db will
  52. // be to written to info_log if it is non-NULL, or to a file stored
  53. // in the same directory as the DB contents if info_log is NULL.
  54. // Default: NULL
  55. WritableFile* info_log;
  56. // -------------------
  57. // Parameters that affect performance
  58. // Amount of data to build up in memory (backed by an unsorted log
  59. // on disk) before converting to a sorted on-disk file.
  60. //
  61. // Larger values increase performance, especially during bulk loads.
  62. // Up to two write buffers may be held in memory at the same time,
  63. // so you may wish to adjust this parameter to control memory usage.
  64. //
  65. // Default: 4MB
  66. size_t write_buffer_size;
  67. // Number of open files that can be used by the DB. You may need to
  68. // increase this if your database has a large working set (budget
  69. // one open file per 2MB of working set).
  70. //
  71. // Default: 1000
  72. int max_open_files;
  73. // Control over blocks (user data is stored in a set of blocks, and
  74. // a block is the unit of reading from disk).
  75. // If non-NULL, use the specified cache for blocks.
  76. // If NULL, leveldb will automatically create and use an 8MB internal cache.
  77. // Default: NULL
  78. Cache* block_cache;
  79. // Approximate size of user data packed per block. Note that the
  80. // block size specified here corresponds to uncompressed data. The
  81. // actual size of the unit read from disk may be smaller if
  82. // compression is enabled. This parameter can be changed dynamically.
  83. //
  84. // Default: 4K
  85. size_t block_size;
  86. // Number of keys between restart points for delta encoding of keys.
  87. // This parameter can be changed dynamically. Most clients should
  88. // leave this parameter alone.
  89. //
  90. // Default: 16
  91. int block_restart_interval;
  92. // Compress blocks using the specified compression algorithm. This
  93. // parameter can be changed dynamically.
  94. //
  95. // Default: kSnappyCompression, which gives lightweight but fast
  96. // compression.
  97. //
  98. // Typical speeds of kSnappyCompression on an Intel(R) Core(TM)2 2.4GHz:
  99. // ~200-500MB/s compression
  100. // ~400-800MB/s decompression
  101. // Note that these speeds are significantly faster than most
  102. // persistent storage speeds, and therefore it is typically never
  103. // worth switching to kNoCompression. Even if the input data is
  104. // incompressible, the kSnappyCompression implementation will
  105. // efficiently detect that and will switch to uncompressed mode.
  106. CompressionType compression;
  107. // Create an Options object with default values for all fields.
  108. Options();
  109. };
  110. // Options that control read operations
  111. struct ReadOptions {
  112. // If true, all data read from underlying storage will be
  113. // verified against corresponding checksums.
  114. // Default: false
  115. bool verify_checksums;
  116. // Should the data read for this iteration be cached in memory?
  117. // Callers may wish to set this field to false for bulk scans.
  118. // Default: true
  119. bool fill_cache;
  120. // If "snapshot" is non-NULL, read as of the supplied snapshot
  121. // (which must belong to the DB that is being read and which must
  122. // not have been released). If "snapshot" is NULL, use an impliicit
  123. // snapshot of the state at the beginning of this read operation.
  124. // Default: NULL
  125. const Snapshot* snapshot;
  126. ReadOptions()
  127. : verify_checksums(false),
  128. fill_cache(true),
  129. snapshot(NULL) {
  130. }
  131. };
  132. // Options that control write operations
  133. struct WriteOptions {
  134. // If true, the write will be flushed from the operating system
  135. // buffer cache (by calling WritableFile::Sync()) before the write
  136. // is considered complete. If this flag is true, writes will be
  137. // slower.
  138. //
  139. // If this flag is false, and the machine crashes, some recent
  140. // writes may be lost. Note that if it is just the process that
  141. // crashes (i.e., the machine does not reboot), no writes will be
  142. // lost even if sync==false.
  143. //
  144. // In other words, a DB write with sync==false has similar
  145. // crash semantics as the "write()" system call. A DB write
  146. // with sync==true has similar crash semantics to a "write()"
  147. // system call followed by "fsync()".
  148. //
  149. // Default: false
  150. bool sync;
  151. // If "post_write_snapshot" is non-NULL, and the write succeeds,
  152. // *post_write_snapshot will be modified to point to a snapshot of
  153. // the DB state immediately after this write. The caller must call
  154. // DB::ReleaseSnapshot(*post_write_snapshotsnapshot) when the
  155. // snapshot is no longer needed.
  156. //
  157. // If "post_write_snapshot" is non-NULL, and the write fails,
  158. // *post_write_snapshot will be set to NULL.
  159. //
  160. // Default: NULL
  161. const Snapshot** post_write_snapshot;
  162. WriteOptions()
  163. : sync(false),
  164. post_write_snapshot(NULL) {
  165. }
  166. };
  167. }
  168. #endif // STORAGE_LEVELDB_INCLUDE_OPTIONS_H_