Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(587)

Unified Diff: chrome/common/sqlite_utils.cc

Issue 7550059: Move sqlite_utils.* to sync/util/ directory. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 9 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/common/sqlite_utils.h ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/common/sqlite_utils.cc
diff --git a/chrome/common/sqlite_utils.cc b/chrome/common/sqlite_utils.cc
deleted file mode 100644
index fdbd79b4175efb7eaea036e792d32cb7966eb675..0000000000000000000000000000000000000000
--- a/chrome/common/sqlite_utils.cc
+++ /dev/null
@@ -1,510 +0,0 @@
-// Copyright (c) 2010 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 "chrome/common/sqlite_utils.h"
-
-#include <list>
-
-#include "base/file_path.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/stl_util.h"
-#include "base/string16.h"
-#include "base/synchronization/lock.h"
-
-// The vanilla error handler implements the common fucntionality for all the
-// error handlers. Specialized error handlers are expected to only override
-// the Handler() function.
-class VanillaSQLErrorHandler : public SQLErrorHandler {
- public:
- VanillaSQLErrorHandler() : error_(SQLITE_OK) {
- }
- virtual int GetLastError() const {
- return error_;
- }
- protected:
- int error_;
-};
-
-class DebugSQLErrorHandler: public VanillaSQLErrorHandler {
- public:
- virtual int HandleError(int error, sqlite3* db) {
- error_ = error;
- NOTREACHED() << "sqlite error " << error
- << " db " << static_cast<void*>(db);
- return error;
- }
-};
-
-class ReleaseSQLErrorHandler : public VanillaSQLErrorHandler {
- public:
- virtual int HandleError(int error, sqlite3* db) {
- error_ = error;
- // Used to have a CHECK here. Got lots of crashes.
- return error;
- }
-};
-
-// The default error handler factory is also in charge of managing the
-// lifetime of the error objects. This object is multi-thread safe.
-class DefaultSQLErrorHandlerFactory : public SQLErrorHandlerFactory {
- public:
- ~DefaultSQLErrorHandlerFactory() {
- STLDeleteContainerPointers(errors_.begin(), errors_.end());
- }
-
- virtual SQLErrorHandler* Make() {
- SQLErrorHandler* handler;
-#ifndef NDEBUG
- handler = new DebugSQLErrorHandler;
-#else
- handler = new ReleaseSQLErrorHandler;
-#endif // NDEBUG
- AddHandler(handler);
- return handler;
- }
-
- private:
- void AddHandler(SQLErrorHandler* handler) {
- base::AutoLock lock(lock_);
- errors_.push_back(handler);
- }
-
- typedef std::list<SQLErrorHandler*> ErrorList;
- ErrorList errors_;
- base::Lock lock_;
-};
-
-static base::LazyInstance<DefaultSQLErrorHandlerFactory>
- g_default_sql_error_handler_factory(base::LINKER_INITIALIZED);
-
-SQLErrorHandlerFactory* GetErrorHandlerFactory() {
- // TODO(cpu): Testing needs to override the error handler.
- // Destruction of DefaultSQLErrorHandlerFactory handled by at_exit manager.
- return g_default_sql_error_handler_factory.Pointer();
-}
-
-namespace sqlite_utils {
-
-int OpenSqliteDb(const FilePath& filepath, sqlite3** database) {
-#if defined(OS_WIN)
- // We want the default encoding to always be UTF-8, so we use the
- // 8-bit version of open().
- return sqlite3_open(WideToUTF8(filepath.value()).c_str(), database);
-#elif defined(OS_POSIX)
- return sqlite3_open(filepath.value().c_str(), database);
-#endif
-}
-
-bool DoesSqliteTableExist(sqlite3* db,
- const char* db_name,
- const char* table_name) {
- // sqlite doesn't allow binding parameters as table names, so we have to
- // manually construct the sql
- std::string sql("SELECT name FROM ");
- if (db_name && db_name[0]) {
- sql.append(db_name);
- sql.push_back('.');
- }
- sql.append("sqlite_master WHERE type='table' AND name=?");
-
- SQLStatement statement;
- if (statement.prepare(db, sql.c_str()) != SQLITE_OK)
- return false;
-
- if (statement.bind_text(0, table_name) != SQLITE_OK)
- return false;
-
- // we only care about if this matched a row, not the actual data
- return sqlite3_step(statement.get()) == SQLITE_ROW;
-}
-
-bool DoesSqliteColumnExist(sqlite3* db,
- const char* database_name,
- const char* table_name,
- const char* column_name,
- const char* column_type) {
- SQLStatement s;
- std::string sql;
- sql.append("PRAGMA ");
- if (database_name && database_name[0]) {
- // optional database name specified
- sql.append(database_name);
- sql.push_back('.');
- }
- sql.append("TABLE_INFO(");
- sql.append(table_name);
- sql.append(")");
-
- if (s.prepare(db, sql.c_str()) != SQLITE_OK)
- return false;
-
- while (s.step() == SQLITE_ROW) {
- if (!s.column_string(1).compare(column_name)) {
- if (column_type && column_type[0])
- return !s.column_string(2).compare(column_type);
- return true;
- }
- }
- return false;
-}
-
-bool DoesSqliteTableHaveRow(sqlite3* db, const char* table_name) {
- SQLStatement s;
- std::string b;
- b.append("SELECT * FROM ");
- b.append(table_name);
-
- if (s.prepare(db, b.c_str()) != SQLITE_OK)
- return false;
-
- return s.step() == SQLITE_ROW;
-}
-
-} // namespace sqlite_utils
-
-SQLTransaction::SQLTransaction(sqlite3* db) : db_(db), began_(false) {
-}
-
-SQLTransaction::~SQLTransaction() {
- if (began_) {
- Rollback();
- }
-}
-
-int SQLTransaction::BeginCommand(const char* command) {
- int rv = SQLITE_ERROR;
- if (!began_ && db_) {
- rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
- began_ = (rv == SQLITE_OK);
- }
- return rv;
-}
-
-int SQLTransaction::EndCommand(const char* command) {
- int rv = SQLITE_ERROR;
- if (began_ && db_) {
- rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
- began_ = (rv != SQLITE_OK);
- }
- return rv;
-}
-
-SQLNestedTransactionSite::~SQLNestedTransactionSite() {
- DCHECK(!top_transaction_);
-}
-
-void SQLNestedTransactionSite::SetTopTransaction(SQLNestedTransaction* top) {
- DCHECK(!top || !top_transaction_);
- top_transaction_ = top;
-}
-
-SQLNestedTransaction::SQLNestedTransaction(SQLNestedTransactionSite* site)
- : SQLTransaction(site->GetSqlite3DB()),
- needs_rollback_(false),
- site_(site) {
- DCHECK(site);
- if (site->GetTopTransaction() == NULL) {
- site->SetTopTransaction(this);
- }
-}
-
-SQLNestedTransaction::~SQLNestedTransaction() {
- if (began_) {
- Rollback();
- }
- if (site_->GetTopTransaction() == this) {
- site_->SetTopTransaction(NULL);
- }
-}
-
-int SQLNestedTransaction::BeginCommand(const char* command) {
- DCHECK(db_);
- DCHECK(site_ && site_->GetTopTransaction());
- if (!db_ || began_) {
- return SQLITE_ERROR;
- }
- if (site_->GetTopTransaction() == this) {
- int rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
- began_ = (rv == SQLITE_OK);
- if (began_) {
- site_->OnBegin();
- }
- return rv;
- } else {
- if (site_->GetTopTransaction()->needs_rollback_) {
- return SQLITE_ERROR;
- }
- began_ = true;
- return SQLITE_OK;
- }
-}
-
-int SQLNestedTransaction::EndCommand(const char* command) {
- DCHECK(db_);
- DCHECK(site_ && site_->GetTopTransaction());
- if (!db_ || !began_) {
- return SQLITE_ERROR;
- }
- if (site_->GetTopTransaction() == this) {
- if (needs_rollback_) {
- sqlite3_exec(db_, "ROLLBACK", NULL, NULL, NULL);
- began_ = false; // reset so we don't try to rollback or call
- // OnRollback() again
- site_->OnRollback();
- return SQLITE_ERROR;
- } else {
- int rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
- began_ = (rv != SQLITE_OK);
- if (strcmp(command, "ROLLBACK") == 0) {
- began_ = false; // reset so we don't try to rollbck or call
- // OnRollback() again
- site_->OnRollback();
- } else {
- DCHECK(strcmp(command, "COMMIT") == 0);
- if (rv == SQLITE_OK) {
- site_->OnCommit();
- }
- }
- return rv;
- }
- } else {
- if (strcmp(command, "ROLLBACK") == 0) {
- site_->GetTopTransaction()->needs_rollback_ = true;
- }
- began_ = false;
- return SQLITE_OK;
- }
-}
-
-int SQLStatement::prepare(sqlite3* db, const char* sql, int sql_len) {
- DCHECK(!stmt_);
- int rv = sqlite3_prepare_v2(db, sql, sql_len, &stmt_, NULL);
- if (rv != SQLITE_OK) {
- SQLErrorHandler* error_handler = GetErrorHandlerFactory()->Make();
- return error_handler->HandleError(rv, db);
- }
- return rv;
-}
-
-int SQLStatement::step() {
- DCHECK(stmt_);
- int status = sqlite3_step(stmt_);
- if ((status == SQLITE_ROW) || (status == SQLITE_DONE))
- return status;
- // We got a problem.
- SQLErrorHandler* error_handler = GetErrorHandlerFactory()->Make();
- return error_handler->HandleError(status, db_handle());
-}
-
-int SQLStatement::reset() {
- DCHECK(stmt_);
- return sqlite3_reset(stmt_);
-}
-
-sqlite_int64 SQLStatement::last_insert_rowid() {
- DCHECK(stmt_);
- return sqlite3_last_insert_rowid(db_handle());
-}
-
-int SQLStatement::changes() {
- DCHECK(stmt_);
- return sqlite3_changes(db_handle());
-}
-
-sqlite3* SQLStatement::db_handle() {
- DCHECK(stmt_);
- return sqlite3_db_handle(stmt_);
-}
-
-int SQLStatement::bind_parameter_count() {
- DCHECK(stmt_);
- return sqlite3_bind_parameter_count(stmt_);
-}
-
-int SQLStatement::bind_blob(int index, std::vector<unsigned char>* blob) {
- if (blob) {
- const void* value = blob->empty() ? NULL : &(*blob)[0];
- int len = static_cast<int>(blob->size());
- return bind_blob(index, value, len);
- } else {
- return bind_null(index);
- }
-}
-
-int SQLStatement::bind_blob(int index, const void* value, int value_len) {
- return bind_blob(index, value, value_len, SQLITE_TRANSIENT);
-}
-
-int SQLStatement::bind_blob(int index, const void* value, int value_len,
- Function dtor) {
- DCHECK(stmt_);
- return sqlite3_bind_blob(stmt_, index + 1, value, value_len, dtor);
-}
-
-int SQLStatement::bind_double(int index, double value) {
- DCHECK(stmt_);
- return sqlite3_bind_double(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_bool(int index, bool value) {
- DCHECK(stmt_);
- return sqlite3_bind_int(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_int(int index, int value) {
- DCHECK(stmt_);
- return sqlite3_bind_int(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_int64(int index, sqlite_int64 value) {
- DCHECK(stmt_);
- return sqlite3_bind_int64(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_null(int index) {
- DCHECK(stmt_);
- return sqlite3_bind_null(stmt_, index + 1);
-}
-
-int SQLStatement::bind_text(int index, const char* value, int value_len,
- Function dtor) {
- DCHECK(stmt_);
- return sqlite3_bind_text(stmt_, index + 1, value, value_len, dtor);
-}
-
-int SQLStatement::bind_text16(int index, const char16* value, int value_len,
- Function dtor) {
- DCHECK(stmt_);
- value_len *= sizeof(char16);
- return sqlite3_bind_text16(stmt_, index + 1, value, value_len, dtor);
-}
-
-int SQLStatement::bind_value(int index, const sqlite3_value* value) {
- DCHECK(stmt_);
- return sqlite3_bind_value(stmt_, index + 1, value);
-}
-
-int SQLStatement::column_count() {
- DCHECK(stmt_);
- return sqlite3_column_count(stmt_);
-}
-
-int SQLStatement::column_type(int index) {
- DCHECK(stmt_);
- return sqlite3_column_type(stmt_, index);
-}
-
-const void* SQLStatement::column_blob(int index) {
- DCHECK(stmt_);
- return sqlite3_column_blob(stmt_, index);
-}
-
-bool SQLStatement::column_blob_as_vector(int index,
- std::vector<unsigned char>* blob) {
- DCHECK(stmt_);
- const void* p = column_blob(index);
- size_t len = column_bytes(index);
- blob->resize(len);
- if (blob->size() != len) {
- return false;
- }
- if (len > 0)
- memcpy(&(blob->front()), p, len);
- return true;
-}
-
-bool SQLStatement::column_blob_as_string(int index, std::string* blob) {
- DCHECK(stmt_);
- const void* p = column_blob(index);
- size_t len = column_bytes(index);
- blob->resize(len);
- if (blob->size() != len) {
- return false;
- }
- blob->assign(reinterpret_cast<const char*>(p), len);
- return true;
-}
-
-int SQLStatement::column_bytes(int index) {
- DCHECK(stmt_);
- return sqlite3_column_bytes(stmt_, index);
-}
-
-int SQLStatement::column_bytes16(int index) {
- DCHECK(stmt_);
- return sqlite3_column_bytes16(stmt_, index);
-}
-
-double SQLStatement::column_double(int index) {
- DCHECK(stmt_);
- return sqlite3_column_double(stmt_, index);
-}
-
-bool SQLStatement::column_bool(int index) {
- DCHECK(stmt_);
- return sqlite3_column_int(stmt_, index) ? true : false;
-}
-
-int SQLStatement::column_int(int index) {
- DCHECK(stmt_);
- return sqlite3_column_int(stmt_, index);
-}
-
-sqlite_int64 SQLStatement::column_int64(int index) {
- DCHECK(stmt_);
- return sqlite3_column_int64(stmt_, index);
-}
-
-const char* SQLStatement::column_text(int index) {
- DCHECK(stmt_);
- return reinterpret_cast<const char*>(sqlite3_column_text(stmt_, index));
-}
-
-bool SQLStatement::column_string(int index, std::string* str) {
- DCHECK(stmt_);
- DCHECK(str);
- const char* s = column_text(index);
- str->assign(s ? s : std::string());
- return s != NULL;
-}
-
-std::string SQLStatement::column_string(int index) {
- std::string str;
- column_string(index, &str);
- return str;
-}
-
-const char16* SQLStatement::column_text16(int index) {
- DCHECK(stmt_);
- return static_cast<const char16*>(sqlite3_column_text16(stmt_, index));
-}
-
-bool SQLStatement::column_string16(int index, string16* str) {
- DCHECK(stmt_);
- DCHECK(str);
- const char* s = column_text(index);
- str->assign(s ? UTF8ToUTF16(s) : string16());
- return (s != NULL);
-}
-
-string16 SQLStatement::column_string16(int index) {
- string16 str;
- column_string16(index, &str);
- return str;
-}
-
-bool SQLStatement::column_wstring(int index, std::wstring* str) {
- DCHECK(stmt_);
- DCHECK(str);
- const char* s = column_text(index);
- str->assign(s ? UTF8ToWide(s) : std::wstring());
- return (s != NULL);
-}
-
-std::wstring SQLStatement::column_wstring(int index) {
- std::wstring wstr;
- column_wstring(index, &wstr);
- return wstr;
-}
« no previous file with comments | « chrome/common/sqlite_utils.h ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698