Database usage adjustment for .../history

chrome/browser/history/text_database.cc

 // 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.
 
 #include <limits>
 #include <set>
 #include <string>
 
 #include "chrome/browser/history/text_database.h"
 
@@ skipping 198 matching lines @@
                                const std::string& url,
                                const std::string& title,
                                const std::string& contents) {
   sql::Transaction committer(&db_);
   if (!committer.Begin())
     return false;
 
   // Add to the pages table.
   sql::Statement add_to_pages(db_.GetCachedStatement(SQL_FROM_HERE,
       "INSERT INTO pages (url, title, body) VALUES (?,?,?)"));
-  if (!add_to_pages) {
-    NOTREACHED() << db_.GetErrorMessage();
-    return false;
-  }
   add_to_pages.BindString(0, url);
   add_to_pages.BindString(1, title);
   add_to_pages.BindString(2, contents);
-  if (!add_to_pages.Run()) {
-    NOTREACHED() << db_.GetErrorMessage();
+  if (!add_to_pages.Run())
     return false;
-  }
 
   int64 rowid = db_.GetLastInsertRowId();
 
   // Add to the info table with the same rowid.
   sql::Statement add_to_info(db_.GetCachedStatement(SQL_FROM_HERE,
       "INSERT INTO info (rowid, time) VALUES (?,?)"));
-  if (!add_to_info) {
-    NOTREACHED() << db_.GetErrorMessage();
-    return false;
-  }
   add_to_info.BindInt64(0, rowid);
   add_to_info.BindInt64(1, time.ToInternalValue());
-  if (!add_to_info.Run()) {
-    NOTREACHED() << db_.GetErrorMessage();
+
+  if (!add_to_info.Run())
     return false;
-  }
 
   return committer.Commit();
 }
 
 void TextDatabase::DeletePageData(base::Time time, const std::string& url) {
   // First get all rows that match. Selecing on time (which has an index) allows
   // us to avoid brute-force searches on the full-text-index table (there will
   // generally be only one match per time).
   sql::Statement select_ids(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT info.rowid "
       "FROM info JOIN pages ON info.rowid = pages.rowid "
       "WHERE info.time=? AND pages.url=?"));
-  if (!select_ids)
-    return;
   select_ids.BindInt64(0, time.ToInternalValue());
   select_ids.BindString(1, url);
+
   std::set<int64> rows_to_delete;
   while (select_ids.Step())
     rows_to_delete.insert(select_ids.ColumnInt64(0));
 
   // Delete from the pages table.
   sql::Statement delete_page(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM pages WHERE rowid=?"));
-  if (!delete_page)
-    return;
+
   for (std::set<int64>::const_iterator i = rows_to_delete.begin();
        i != rows_to_delete.end(); ++i) {
     delete_page.BindInt64(0, *i);
-    if (!delete_page.Run()) {
-      NOTREACHED();
+    if (!delete_page.Run())
       return;
-    }
     delete_page.Reset();
   }
 
   // Delete from the info table.
   sql::Statement delete_info(db_.GetCachedStatement(SQL_FROM_HERE,
       "DELETE FROM info WHERE rowid=?"));
-  if (!delete_info)
-    return;
+
   for (std::set<int64>::const_iterator i = rows_to_delete.begin();
        i != rows_to_delete.end(); ++i) {
     delete_info.BindInt64(0, *i);
-    if (!delete_info.Run()) {
-      NOTREACHED();
+    if (!delete_info.Run())
       return;
-    }
     delete_info.Reset();
   }
 }
 
 void TextDatabase::Optimize() {
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE,
       "SELECT OPTIMIZE(pages) FROM pages LIMIT 1"));
-  if (!statement)
-    return;
   statement.Run();
 }
 
 void TextDatabase::GetTextMatches(const std::string& query,
                                   const QueryOptions& options,
                                   std::vector<Match>* results,
                                   URLSet* found_urls,
                                   base::Time* first_time_searched) {
   *first_time_searched = options.begin_time;
 
   // TODO(mrossetti): Remove the non-body_only alternative and move the string
   // into the statement construction when we switch to body_only permanently.
   std::string sql = "SELECT url, title, time, offsets(pages), body FROM pages "
                     " LEFT OUTER JOIN info ON pages.rowid = info.rowid WHERE ";
   sql += options.body_only ? "body " : "pages ";
   sql += "MATCH ? AND time >= ? AND time < ? ORDER BY time DESC LIMIT ?";
   sql::Statement statement(db_.GetCachedStatement(SQL_FROM_HERE, sql.c_str()));
-  if (!statement)
-    return;
 
   // When their values indicate "unspecified", saturate the numbers to the max
   // or min to get the correct result.
   int64 effective_begin_time = options.begin_time.is_null() ?
       0 : options.begin_time.ToInternalValue();
   int64 effective_end_time = options.end_time.is_null() ?
       std::numeric_limits<int64>::max() : options.end_time.ToInternalValue();
   int effective_max_count = options.max_count ?
       options.max_count : std::numeric_limits<int>::max();
 
@@ skipping 47 matching lines @@
   } else {
     // Since we got the results in order, we know the last item is the last
     // time we considered.
     *first_time_searched = results->back().time;
   }
 
   statement.Reset();
 }
 
 }  // namespace history