Implement sql::Connection::RazeAndClose().

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 <map>
 #include <set>
 #include <string>
@@ skipping 200 matching lines @@
   //
   // NOTE(shess): For Android, SQLITE_DEFAULT_AUTOVACUUM is set to 1,
   // so Raze() sets auto_vacuum to 1.
   //
   // TODO(shess): Raze() needs a connection so cannot clear SQLITE_NOTADB.
   // TODO(shess): Bake auto_vacuum into Connection's API so it can
   // just pick up the default.
   bool Raze();
   bool RazeWithTimout(base::TimeDelta timeout);
 
+  // Breaks all outstanding transactions (as initiated by
+  // BeginTransaction()), calls Raze() to destroy the database, then
+  // closes the database.  After this is called, any operations

[pkotwicz, 2013/01/31 19:22:00]

Nit: 1 space instead of 2. You seem to have two spaces after the period in all
of your comments?

[Scott Hess - ex-Googler, 2013/02/05 01:20:25]

I bet I have tens of thousands of instances of this, because I've always put two
spaces after the period.

+  // against the connections (or statements prepared by the
+  // connection) should fail safely.
+  //
+  // The value from Raze() is returned, with Close() called in all
+  // cases.
+  bool RazeAndClose();
+
   // Transactions --------------------------------------------------------------
 
   // Transaction management. We maintain a virtual transaction stack to emulate
   // nested transactions since sqlite can't do nested transactions. The
   // limitation is you can't roll back a sub transaction: if any transaction
   // fails, all transactions open will also be rolled back. Any nested
   // transactions after one has rolled back will return fail for Begin(). If
   // Begin() fails, you must not call Commit or Rollback().
   //
   // Normally you should use sql::Transaction to manage a transaction, which
@@ skipping 100 matching lines @@
  private:
   // Statement accesses StatementRef which we don't want to expose to everybody
   // (they should go through Statement).
   friend class Statement;
 
   // 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.
   bool OpenInternal(const std::string& file_name);
 
+  // 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() {
     if (!in_memory_)
       base::ThreadRestrictions::AssertIOAllowed();
   }
 
   // Internal helper for DoesTableExist and DoesIndexExist.
   bool DoesTableOrIndexExist(const char* name, const char* type) const;
@@ skipping 12 matching lines @@
   class SQL_EXPORT StatementRef : public base::RefCounted<StatementRef> {
    public:
     // Default constructor initializes to an invalid statement.
     StatementRef();
     explicit StatementRef(sqlite3_stmt* stmt);
     StatementRef(Connection* connection, sqlite3_stmt* stmt);
 
     // When true, the statement can be used.
     bool is_valid() const { return !!stmt_; }
 
+    // When true, the statement is either currently valid, or was
+    // previously valid but the connection was forcibly closed.  Used
+    // for diagnostic checks.
+    bool was_valid() const { return was_valid_; }
+
     // If we've not been linked to a connection, this will be NULL.
     // TODO(shess): connection_ can be NULL in case of GetUntrackedStatement(),
     // which prevents Statement::OnError() from forwarding errors.
     Connection* connection() const { return connection_; }
 
     // Returns the sqlite statement if any. If the statement is not active,
     // this will return NULL.
     sqlite3_stmt* stmt() const { return stmt_; }
 
     // Destroys the compiled statement and marks it NULL. The statement will
-    // no longer be active.
-    void Close();
+    // no longer be active.  |forced| is used to indicate if orderly-shutdown
+    // checks should apply (see Connection::RazeAndClose()).
+    void Close(bool forced);
 
     // Check whether the current thread is allowed to make IO calls, but only
     // if database wasn't open in memory.
     void AssertIOAllowed() { if (connection_) connection_->AssertIOAllowed(); }
 
    private:
     friend class base::RefCounted<StatementRef>;
 
     ~StatementRef();
 
     Connection* connection_;
     sqlite3_stmt* stmt_;
+    bool was_valid_;
 
     DISALLOW_COPY_AND_ASSIGN(StatementRef);
   };
   friend class StatementRef;
 
   // Executes a rollback statement, ignoring all transaction state. Used
   // internally in the transaction management code.
   void DoRollback();
 
   // Called by a StatementRef when it's being created or destroyed. See
   // open_statements_ below.
   void StatementRefCreated(StatementRef* ref);
   void StatementRefDeleted(StatementRef* ref);
 
-  // Frees all cached statements from statement_cache_.
-  void ClearCache();
-
   // Called by Statement objects when an sqlite function returns an error.
   // The return value is the error code reflected back to client code.
   int OnSqliteError(int err, Statement* stmt);
 
   // Like |Execute()|, but retries if the database is locked.
   bool ExecuteWithTimeout(const char* sql, base::TimeDelta ms_timeout)
       WARN_UNUSED_RESULT;
 
   // Internal helper for const functions.  Like GetUniqueStatement(),
   // except the statement is not entered into open_statements_,
@@ skipping 30 matching lines @@
 
   // True if any of the currently nested transactions have been rolled back.
   // When we get to the outermost transaction, this will determine if we do
   // a rollback instead of a commit.
   bool needs_rollback_;
 
   // 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_;
+
   // This object handles errors resulting from all forms of executing sqlite
   // commands or statements. It can be null which means default handling.
   scoped_ptr<ErrorDelegate> error_delegate_;
 
   // Auxiliary error-code histogram.
   std::string error_histogram_name_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_