Put debugging assertions into sql::Statement.

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>
@@ skipping 186 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);
 
+  // Like Execute(), but returns the error code given by SQLite.
+  int ExecuteAndReturnErrorCode(const char* sql);
+
   // 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
   // performance.
   //
-  // The SQL may have an error, so the caller must check validity of the
-  // statement before using it.
+  // If the |sql| has an error, an invalid, inert StatementRef is returned (and
+  // the code will crash in debug). The caller must deal with this eventuality,
+  // either by checking validity of the |sql| before calling, by correctly
+  // handling the return of an inert statement, or both.
   //
   // The StatementID and the SQL must always correspond to one-another. The
   // ID is the lookup into the cache, so crazy things will happen if you use
   // different SQL with the same ID.
   //
   // You will normally use the SQL_FROM_HERE macro to generate a statement
   // ID associated with the current line of code. This gives uniqueness without
   // you having to manage unique names. See StatementID above for more.
   //
   // Example:
   //   sql::Statement stmt(connection_.GetCachedStatement(
   //       SQL_FROM_HERE, "SELECT * FROM foo"));
   //   if (!stmt)
   //     return false;  // Error creating statement.
   scoped_refptr<StatementRef> GetCachedStatement(const StatementID& id,
                                                  const char* sql);
 
+  // Used to check a |sql| statement for syntactic validity. If the statement is
+  // valid SQL, returns true.
+  bool IsSQLValid(const char* sql);
+
   // 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 exists.
@@ skipping 18 matching lines @@
 
   // Returns the errno associated with GetErrorCode().  See
   // SQLITE_LAST_ERRNO in SQLite documentation.
   int GetLastErrno() const;
 
   // Returns a pointer to a statically allocated string associated with the
   // last sqlite operation.
   const char* GetErrorMessage() const;
 
  private:
-  // Statement access StatementRef which we don't want to expose to erverybody
+  // 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);
 
   // A StatementRef is a refcounted wrapper around a sqlite statement pointer.
   // Refcounting allows us to give these statements out to sql::Statement
@@ skipping 91 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_