[sql] Allow storing mmap status in a VIEW instead of meta table.

sql/connection.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef SQL_CONNECTION_H_
 #define SQL_CONNECTION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <map>
@@ skipping 132 matching lines @@
   //
   // This must be called before Open() to have an effect.
   void set_exclusive_locking() { exclusive_locking_ = true; }
 
   // Call to cause Open() to restrict access permissions of the
   // database file to only the owner.
   // TODO(shess): Currently only supported on OS_POSIX, is a noop on
   // other platforms.
   void set_restrict_to_user() { restrict_to_user_ = true; }
 
+  // Call to use alternative status-tracking for mmap.  Usually this is tracked
+  // in the meta table, but some databases have no meta table.
+  // TODO(shess): Maybe just have all databases use the alt option?
+  void set_mmap_alt_status() { mmap_alt_status_ = true; }
+
   // Call to opt out of memory-mapped file I/O.
   void set_mmap_disabled() { mmap_disabled_ = true; }
 
   // Set an error-handling callback.  On errors, the error number (and
   // statement, if available) will be passed to the callback.
   //
   // If no callback is set, the default action is to crash in debug
   // mode or return failure in release mode.
   typedef base::Callback<void(int, Statement*)> ErrorCallback;
   void set_error_callback(const ErrorCallback& callback) {
@@ skipping 49 matching lines @@
     EVENT_MMAP_META_MISSING,         // No meta table present.
     EVENT_MMAP_META_FAILURE_READ,    // Failed reading meta table.
     EVENT_MMAP_META_FAILURE_UPDATE,  // Failed updating meta table.
     EVENT_MMAP_VFS_FAILURE,          // Failed to access VFS.
     EVENT_MMAP_FAILED,               // Failure from past run.
     EVENT_MMAP_FAILED_NEW,           // Read error in this run.
     EVENT_MMAP_SUCCESS_NEW,          // Read to EOF in this run.
     EVENT_MMAP_SUCCESS_PARTIAL,      // Read but did not reach EOF.
     EVENT_MMAP_SUCCESS_NO_PROGRESS,  // Read quota exhausted.
 
+    EVENT_MMAP_STATUS_FAILURE_READ,  // Failure reading MmapStatus view.
+    EVENT_MMAP_STATUS_FAILURE_UPDATE,// Failure updating MmapStatus view.
+
     // Leave this at the end.
     // TODO(shess): |EVENT_MAX| causes compile fail on Windows.
     EVENT_MAX_VALUE
   };
   void RecordEvent(Events event, size_t count);
   void RecordOneEvent(Events event) {
     RecordEvent(event, 1);
   }
 
   // Run "PRAGMA integrity_check" and post each line of
@@ skipping 204 matching lines @@
 
   // Returns a non-cached statement for the given SQL. Use this for SQL that
   // is only executed once or only rarely (there is overhead associated with
   // keeping a statement cached).
   //
   // See GetCachedStatement above for examples and error information.
   scoped_refptr<StatementRef> GetUniqueStatement(const char* sql);
 
   // Info querying -------------------------------------------------------------
 
-  // Returns true if the given table (or index) exists.  Instead of
-  // test-then-create, callers should almost always prefer "CREATE TABLE IF NOT
-  // EXISTS" or "CREATE INDEX IF NOT EXISTS".
+  // Returns true if the given structure exists.  Instead of test-then-create,
+  // callers should almost always prefer the "IF NOT EXISTS" version of the
+  // CREATE statement.
+  bool DoesIndexExist(const char* index_name) const;
   bool DoesTableExist(const char* table_name) const;
-  bool DoesIndexExist(const char* index_name) const;
+  bool DoesViewExist(const char* table_name) const;
 
   // Returns true if a column with the given name exists in the given table.
   bool DoesColumnExist(const char* table_name, const char* column_name) const;
 
   // Returns sqlite's internal ID for the last inserted row. Valid only
   // immediately after an insert.
   int64_t GetLastInsertRowId() const;
 
   // Returns sqlite's count of the number of rows modified by the last
   // statement executed. Will be 0 if no statement has executed or the database
@@ skipping 40 matching lines @@
   // Statement accesses StatementRef which we don't want to expose to everybody
   // (they should go through Statement).
   friend class Statement;
 
   friend class test::ScopedCommitHook;
   friend class test::ScopedScalarFunction;
   friend class test::ScopedMockTimeSource;
 
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, CollectDiagnosticInfo);
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, GetAppropriateMmapSize);
+  FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, GetAppropriateMmapSizeAltStatus);
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, OnMemoryDump);
   FRIEND_TEST_ALL_PREFIXES(SQLConnectionTest, RegisterIntentToUpload);
 
   // Internal initialize function used by both Init and InitInMemory. The file
   // name is always 8 bits since we want to use the 8-bit version of
   // sqlite3_open. The string can also be sqlite's special ":memory:" string.
   //
   // |retry_flag| controls retrying the open if the error callback
   // addressed errors using RazeAndClose().
   enum Retry {
     NO_RETRY = 0,
     RETRY_ON_POISON
   };
   bool OpenInternal(const std::string& file_name, Retry retry_flag);
 
   // Internal close function used by Close() and RazeAndClose().
   // |forced| indicates that orderly-shutdown checks should not apply.
   void CloseInternal(bool forced);
 
   // Check whether the current thread is allowed to make IO calls, but only
   // if database wasn't open in memory. Function is inlined to be a no-op in
   // official build.
   void AssertIOAllowed() const {
     if (!in_memory_)
       base::ThreadRestrictions::AssertIOAllowed();
   }
 
-  // Internal helper for DoesTableExist and DoesIndexExist.
-  bool DoesTableOrIndexExist(const char* name, const char* type) const;
+  // Internal helper for Does*Exist() functions.
+  bool DoesSchemaItemExist(const char* name, const char* type) const;
 
   // Accessors for global error-expecter, for injecting behavior during tests.
   // See test/scoped_error_expecter.h.
   typedef base::Callback<bool(int)> ErrorExpecterCallback;
   static ErrorExpecterCallback* current_expecter_cb_;
   static void SetErrorExpecter(ErrorExpecterCallback* expecter);
   static void ResetErrorExpecter();
 
   // A StatementRef is a refcounted wrapper around a sqlite statement pointer.
   // Refcounting allows us to give these statements out to sql::Statement
@@ skipping 165 matching lines @@
   // Calculates a value appropriate to pass to "PRAGMA mmap_size = ".  So errors
   // can make it unsafe to map a file, so the file is read using regular I/O,
   // with any errors causing 0 (don't map anything) to be returned.  If the
   // entire file is read without error, a large value is returned which will
   // allow the entire file to be mapped in most cases.
   //
   // Results are recorded in the database's meta table for future reference, so
   // the file should only be read through once.
   size_t GetAppropriateMmapSize();
 
+  // Helpers for GetAppropriateMmapSize().
+  bool GetMmapAltStatus(int64_t* status);
+  bool SetMmapAltStatus(int64_t status);
+
   // The actual sqlite database. Will be NULL before Init has been called or if
   // Init resulted in an error.
   sqlite3* db_;
 
   // Parameters we'll configure in sqlite before doing anything else. Zero means
   // use the default value.
   int page_size_;
   int cache_size_;
   bool exclusive_locking_;
   bool restrict_to_user_;
@@ skipping 21 matching lines @@
   // True if database is open with OpenInMemory(), False if database is open
   // with Open().
   bool in_memory_;
 
   // |true| if the connection was closed using RazeAndClose().  Used
   // to enable diagnostics to distinguish calls to never-opened
   // databases (incorrect use of the API) from calls to once-valid
   // databases.
   bool poisoned_;
 
+  // |true| to use alternate storage for tracking mmap status.
+  bool mmap_alt_status_;
+
   // |true| if SQLite memory-mapped I/O is not desired for this connection.
   bool mmap_disabled_;
 
   // |true| if SQLite memory-mapped I/O was enabled for this connection.
   // Used by ReleaseCacheMemoryIfNeeded().
   bool mmap_enabled_;
 
   // Used by ReleaseCacheMemoryIfNeeded() to track if new changes have happened
   // since memory was last released.
   int total_changes_at_last_release_;
@@ skipping 25 matching lines @@
 
   // Stores the dump provider object when db is open.
   std::unique_ptr<ConnectionMemoryDumpProvider> memory_dump_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_