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

Unified Diff: chrome/common/sqlite_utils.h

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/chrome_common.gypi ('k') | chrome/common/sqlite_utils.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/common/sqlite_utils.h
diff --git a/chrome/common/sqlite_utils.h b/chrome/common/sqlite_utils.h
deleted file mode 100644
index 965f0818bd2fcd612807f2ba37a8f4d88f5a735b..0000000000000000000000000000000000000000
--- a/chrome/common/sqlite_utils.h
+++ /dev/null
@@ -1,400 +0,0 @@
-// 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 CHROME_COMMON_SQLITE_UTILS_H_
-#define CHROME_COMMON_SQLITE_UTILS_H_
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/string16.h"
-#include "base/utf_string_conversions.h"
-#include "third_party/sqlite/sqlite3.h"
-
-// forward declarations of classes defined here
-class FilePath;
-class SQLTransaction;
-class SQLNestedTransaction;
-class SQLNestedTransactionSite;
-class scoped_sqlite3_stmt_ptr;
-class SQLStatement;
-
-//------------------------------------------------------------------------------
-// Interface to be implemented by objects that can handle exceptional sqlite
-// conditions. This way client code can focus on handling normal condtions.
-//------------------------------------------------------------------------------
-class SQLErrorHandler {
- public:
- virtual ~SQLErrorHandler() {}
- // Handle a sqlite error. |error| is the return code an of sqlite operation
- // which is considered an error. This handler is free to try repair, notify
- // someone or even break into the debugger depending on the situation.
- virtual int HandleError(int error, sqlite3* db) = 0;
- // Returns the last value of |error| passed to HandleError.
- virtual int GetLastError() const = 0;
-};
-
-//------------------------------------------------------------------------------
-// The factory interface is used to create the different error handling
-// strategies for debug, release and for diagnostic mode.
-//------------------------------------------------------------------------------
-class SQLErrorHandlerFactory {
- public:
- virtual ~SQLErrorHandlerFactory() {}
- virtual SQLErrorHandler* Make() = 0;
-};
-
-//------------------------------------------------------------------------------
-// A wrapper for sqlite transactions that rollsback when the wrapper
-// goes out of scope if the caller has not already called Commit or Rollback.
-// Note: the constructor does NOT Begin a transaction.
-//------------------------------------------------------------------------------
-class SQLTransaction {
- public:
- explicit SQLTransaction(sqlite3* db);
- virtual ~SQLTransaction();
-
- int Begin() {
- // By default, we BEGIN IMMEDIATE to establish file locks at the
- // onset of a transaction. This avoids SQLITE_BUSY errors, without
- // waiting for the busy timeout period, which can occur when BEGIN
- // DEFERRED is used.
- return BeginImmediate();
- }
-
- int BeginExclusive() {
- return BeginCommand("BEGIN EXCLUSIVE");
- }
-
- int BeginImmediate() {
- return BeginCommand("BEGIN IMMEDIATE");
- }
-
- int BeginDeferred() {
- return BeginCommand("BEGIN DEFERRED");
- }
-
- int Commit() {
- return EndCommand("COMMIT");
- }
-
- int Rollback() {
- return EndCommand("ROLLBACK");
- }
-
- bool HasBegun() {
- return began_;
- }
-
- protected:
- virtual int BeginCommand(const char* command);
- virtual int EndCommand(const char* command);
-
- sqlite3* db_;
- bool began_;
- DISALLOW_COPY_AND_ASSIGN(SQLTransaction);
-};
-
-
-//------------------------------------------------------------------------------
-// A class for use with SQLNestedTransaction.
-//------------------------------------------------------------------------------
-class SQLNestedTransactionSite {
- protected:
- SQLNestedTransactionSite() : db_(NULL), top_transaction_(NULL) {}
- virtual ~SQLNestedTransactionSite();
-
- // The following virtual methods provide notification of true transaction
- // boundaries as they are crossed by a top nested transaction.
- // Intended to be overriden (See WebCacheDB)
- // SQLNestedTransaction calls these after the underlying database
- // operation has been performed.
-
- virtual void OnBegin() {}
- virtual void OnCommit() {}
- virtual void OnRollback() {}
-
- // Returns the sqlite3 database connection associated with this site
- // Used by SQLNestedTransaction
- sqlite3* GetSqlite3DB() { return db_; }
-
- // Returns the current top nested transaction associated with this site
- // Used by SQLNestedTransaction
- SQLNestedTransaction* GetTopTransaction() {
- return top_transaction_;
- }
-
- // Sets or clears the top nested transaction associated with this site
- // Used by SQLNestedTransaction
- void SetTopTransaction(SQLNestedTransaction* top);
-
- sqlite3* db_;
- SQLNestedTransaction* top_transaction_;
- friend class SQLNestedTransaction;
-};
-
-//------------------------------------------------------------------------------
-// SQLite does not support nested transactions. This class provides a gross
-// approximation of nested transactions.
-//
-// Really there is only one transaction, the top transaction.
-//
-// A nested transaction commits with respect to the top transaction.
-// That is, even though the nested transaction commits, the permanence of its
-// effects depends on the top transaction committing. If the top
-// transaction rollsback, the results of the nested transaction are backed out.
-// If any nested transaction aborts, the top transaction ultimately rollsback
-// as well.
-//
-// Note: If a nested transaction is open for a particular db connection, an
-// attempt to open a non-nested transaction (class SQLTransaction) will fail.
-// And vice versa.
-//
-// TODO(michaeln): demonstrate usage here
-// TODO(michaeln): safegaurds to prevent mis-use
-//------------------------------------------------------------------------------
-class SQLNestedTransaction : public SQLTransaction {
- public:
- explicit SQLNestedTransaction(SQLNestedTransactionSite* site);
- virtual ~SQLNestedTransaction();
-
- protected:
- virtual int BeginCommand(const char* command);
- virtual int EndCommand(const char* command);
-
- private:
- bool needs_rollback_;
- SQLNestedTransactionSite* site_;
- DISALLOW_COPY_AND_ASSIGN(SQLNestedTransaction);
-};
-
-//------------------------------------------------------------------------------
-// A scoped sqlite statement that finalizes when it goes out of scope.
-//------------------------------------------------------------------------------
-class scoped_sqlite3_stmt_ptr {
- public:
- ~scoped_sqlite3_stmt_ptr() {
- finalize();
- }
-
- scoped_sqlite3_stmt_ptr() : stmt_(NULL) {
- }
-
- explicit scoped_sqlite3_stmt_ptr(sqlite3_stmt* stmt)
- : stmt_(stmt) {
- }
-
- sqlite3_stmt* get() const {
- return stmt_;
- }
-
- void set(sqlite3_stmt* stmt) {
- finalize();
- stmt_ = stmt;
- }
-
- sqlite3_stmt* release() {
- sqlite3_stmt* tmp = stmt_;
- stmt_ = NULL;
- return tmp;
- }
-
- // It is not safe to call sqlite3_finalize twice on the same stmt.
- // Sqlite3's sqlite3_finalize() function should not be called directly
- // without calling the release method. If sqlite3_finalize() must be
- // called directly, the following usage is advised:
- // scoped_sqlite3_stmt_ptr stmt;
- // ... do something with stmt ...
- // sqlite3_finalize(stmt.release());
- int finalize() {
- int err = sqlite3_finalize(stmt_);
- stmt_ = NULL;
- return err;
- }
-
- protected:
- sqlite3_stmt* stmt_;
-
- private:
- DISALLOW_COPY_AND_ASSIGN(scoped_sqlite3_stmt_ptr);
-};
-
-//------------------------------------------------------------------------------
-// A scoped sqlite statement with convenient C++ wrappers for sqlite3 APIs.
-//------------------------------------------------------------------------------
-class SQLStatement : public scoped_sqlite3_stmt_ptr {
- public:
- SQLStatement() {}
-
- int prepare(sqlite3* db, const char* sql) {
- return prepare(db, sql, -1);
- }
-
- int prepare(sqlite3* db, const char* sql, int sql_len);
-
- int step();
- int reset();
- sqlite_int64 last_insert_rowid();
- int changes();
- sqlite3* db_handle();
-
- //
- // Parameter binding helpers (NOTE: index is 0-based)
- //
-
- int bind_parameter_count();
-
- typedef void (*Function)(void*);
-
- int bind_blob(int index, std::vector<unsigned char>* blob);
- int bind_blob(int index, const void* value, int value_len);
- int bind_blob(int index, const void* value, int value_len, Function dtor);
- int bind_double(int index, double value);
- int bind_bool(int index, bool value);
- int bind_int(int index, int value);
- int bind_int64(int index, sqlite_int64 value);
- int bind_null(int index);
-
- int bind_string(int index, const std::string& value) {
- // don't use c_str so it doesn't have to fix up the null terminator
- // (sqlite just uses the length)
- return bind_text(index, value.data(),
- static_cast<int>(value.length()), SQLITE_TRANSIENT);
- }
-
- int bind_string16(int index, const string16& value) {
- // don't use c_str so it doesn't have to fix up the null terminator
- // (sqlite just uses the length)
- std::string value_utf8(UTF16ToUTF8(value));
- return bind_text(index, value_utf8.data(),
- static_cast<int>(value_utf8.length()), SQLITE_TRANSIENT);
- }
-
- int bind_wstring(int index, const std::wstring& value) {
- // don't use c_str so it doesn't have to fix up the null terminator
- // (sqlite just uses the length)
- std::string value_utf8(WideToUTF8(value));
- return bind_text(index, value_utf8.data(),
- static_cast<int>(value_utf8.length()), SQLITE_TRANSIENT);
- }
-
- int bind_text(int index, const char* value) {
- return bind_text(index, value, -1, SQLITE_TRANSIENT);
- }
-
- // value_len is number of characters or may be negative
- // a for null-terminated value string
- int bind_text(int index, const char* value, int value_len) {
- return bind_text(index, value, value_len, SQLITE_TRANSIENT);
- }
-
- // value_len is number of characters or may be negative
- // a for null-terminated value string
- int bind_text(int index, const char* value, int value_len,
- Function dtor);
-
- int bind_text16(int index, const char16* value) {
- return bind_text16(index, value, -1, SQLITE_TRANSIENT);
- }
-
- // value_len is number of characters or may be negative
- // a for null-terminated value string
- int bind_text16(int index, const char16* value, int value_len) {
- return bind_text16(index, value, value_len, SQLITE_TRANSIENT);
- }
-
- // value_len is number of characters or may be negative
- // a for null-terminated value string
- int bind_text16(int index, const char16* value, int value_len,
- Function dtor);
-
- int bind_value(int index, const sqlite3_value* value);
-
- //
- // Column helpers (NOTE: index is 0-based)
- //
-
- int column_count();
- int column_type(int index);
- const void* column_blob(int index);
- bool column_blob_as_vector(int index, std::vector<unsigned char>* blob);
- bool column_blob_as_string(int index, std::string* blob);
- int column_bytes(int index);
- int column_bytes16(int index);
- double column_double(int index);
- bool column_bool(int index);
- int column_int(int index);
- sqlite_int64 column_int64(int index);
- const char* column_text(int index);
- bool column_string(int index, std::string* str);
- std::string column_string(int index);
- const char16* column_text16(int index);
- bool column_string16(int index, string16* str);
- string16 column_string16(int index);
- bool column_wstring(int index, std::wstring* str);
- std::wstring column_wstring(int index);
-
- private:
- DISALLOW_COPY_AND_ASSIGN(SQLStatement);
-};
-
-namespace sqlite_utils {
-
-//------------------------------------------------------------------------------
-// A scoped sqlite database that closes when it goes out of scope.
-//------------------------------------------------------------------------------
-class DBClose {
- public:
- inline void operator()(sqlite3* x) const {
- sqlite3_close(x);
- }
-};
-
-typedef scoped_ptr_malloc<sqlite3, DBClose> scoped_sqlite_db_ptr;
-
-// Opens the DB in the file pointed to by |filepath|. This method forces the
-// database to be in UTF-8 mode on all platforms. See
-// http://www.sqlite.org/capi3ref.html#sqlite3_open for an explanation of the
-// return value.
-int OpenSqliteDb(const FilePath& filepath, sqlite3** database);
-
-// Returns true if there is a table with the given name in the database.
-// For the version where a database name is specified, it may be NULL or the
-// empty string if no database name is necessary.
-bool DoesSqliteTableExist(sqlite3* db,
- const char* db_name,
- const char* table_name);
-inline bool DoesSqliteTableExist(sqlite3* db, const char* table_name) {
- return DoesSqliteTableExist(db, NULL, table_name);
-}
-
-// Test whether a table has a column matching the provided name and type.
-// Returns true if the column exist and false otherwise. There are two
-// versions, one that takes a database name, the other that doesn't. The
-// database name can be NULL or empty if no name is desired.
-//
-// Column type is optional, it can be NULL or empty. If specified, we the
-// function will check that the column is of the correct type (case-sensetive).
-bool DoesSqliteColumnExist(sqlite3* db,
- const char* datbase_name,
- const char* table_name,
- const char* column_name,
- const char* column_type);
-inline bool DoesSqliteColumnExist(sqlite3* db,
- const char* table_name,
- const char* column_name,
- const char* column_type) {
- return DoesSqliteColumnExist(db, NULL, table_name, column_name, column_type);
-}
-
-// Test whether a table has one or more rows. Returns true if the table
-// has one or more rows and false if the table is empty or doesn't exist.
-bool DoesSqliteTableHaveRow(sqlite3* db, const char* table_name);
-
-} // namespace sqlite_utils
-
-#endif // CHROME_COMMON_SQLITE_UTILS_H_
« no previous file with comments | « chrome/chrome_common.gypi ('k') | chrome/common/sqlite_utils.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698