[sql] WARN_UNUSED_RESULT on Execute().

sql/connection.h

 // Copyright (c) 2011 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_
 #pragma once
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
+#include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/time.h"
 #include "sql/sql_export.h"
 
 class FilePath;
 struct sqlite3;
 struct sqlite3_stmt;
 
 namespace sql {
 
@@ skipping 118 matching lines @@
   // before calling Open(). If not set, the default is to ignore errors on
   // release and assert on debug builds.
   void set_error_delegate(ErrorDelegate* delegate) {
     error_delegate_ = delegate;
   }
 
   // Initialization ------------------------------------------------------------
 
   // Initializes the SQL connection for the given file, returning true if the
   // file could be opened. You can call this or OpenInMemory.
-  bool Open(const FilePath& path);
+  bool Open(const FilePath& path) WARN_UNUSED_RESULT;
 
   // Initializes the SQL connection for a temporary in-memory database. There
   // will be no associated file on disk, and the initial database will be
   // empty. You can call this or Open.
-  bool OpenInMemory();
+  bool OpenInMemory() WARN_UNUSED_RESULT;
 
   // Returns trie if the database has been successfully opened.
   bool is_open() const { return !!db_; }
 
   // Closes the database. This is automatically performed on destruction for
   // you, but this allows you to close the database early. You must not call
   // any other functions after closing it. It is permissable to call Close on
   // an uninitialized or already-closed database.
   void Close();
 
@@ skipping 29 matching lines @@
 
   // Returns the current transaction nesting, which will be 0 if there are
   // no open transactions.
   int transaction_nesting() const { return transaction_nesting_; }
 
   // Statements ----------------------------------------------------------------
 
   // Executes the given SQL string, returning true on success. This is
   // normally used for simple, 1-off statements that don't take any bound
   // parameters and don't return any data (e.g. CREATE TABLE).
+  //
   // This will DCHECK if the |sql| contains errors.
-  bool Execute(const char* sql);
+  //
+  // Do not use ignore_result() to ignore all errors.  Use
+  // ExecuteAndReturnErrorCode() and ignore only specific errors.
+  bool Execute(const char* sql) WARN_UNUSED_RESULT;
 
   // Like Execute(), but returns the error code given by SQLite.
-  int ExecuteAndReturnErrorCode(const char* sql);
+  int ExecuteAndReturnErrorCode(const char* sql) WARN_UNUSED_RESULT;
 
   // Returns true if we have a statement with the given identifier already
   // cached. This is normally not necessary to call, but can be useful if the
   // caller has to dynamically build up SQL to avoid doing so if it's already
   // cached.
   bool HasCachedStatement(const StatementID& id) const;
 
   // Returns a statement for the given SQL using the statement cache. It can
   // take a nontrivial amount of work to parse and compile a statement, so
   // keeping commonly-used ones around for future use is important for
@@ skipping 131 matching lines @@
   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);
+  bool ExecuteWithTimeout(const char* sql, base::TimeDelta ms_timeout)
+      WARN_UNUSED_RESULT;
 
   // 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_;
@@ skipping 21 matching lines @@
   // This object handles errors resulting from all forms of executing sqlite
   // commands or statements. It can be null which means default handling.
   scoped_refptr<ErrorDelegate> error_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(Connection);
 };
 
 }  // namespace sql
 
 #endif  // SQL_CONNECTION_H_