diff options
Diffstat (limited to 'src/components/utils/src/sqlite_wrapper')
| -rw-r--r-- | src/components/utils/src/sqlite_wrapper/CMakeLists.txt | 44 | ||||
| -rw-r--r-- | src/components/utils/src/sqlite_wrapper/sql_database.cc | 115 | ||||
| -rw-r--r-- | src/components/utils/src/sqlite_wrapper/sql_error.cc | 150 | ||||
| -rw-r--r-- | src/components/utils/src/sqlite_wrapper/sql_query.cc | 161 |
4 files changed, 470 insertions, 0 deletions
diff --git a/src/components/utils/src/sqlite_wrapper/CMakeLists.txt b/src/components/utils/src/sqlite_wrapper/CMakeLists.txt new file mode 100644 index 0000000000..9a3f3cdd0f --- /dev/null +++ b/src/components/utils/src/sqlite_wrapper/CMakeLists.txt @@ -0,0 +1,44 @@ +# Copyright (c) 2013, Ford Motor Company +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following +# disclaimer in the documentation and/or other materials provided with the +# distribution. +# +# Neither the name of the Ford Motor Company nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +set(target dbms) + +find_package(Sqlite3 REQUIRED) + +include_directories(${COMPONENTS_DIR}/utils/include/utils) + +set(SOURCES + ./sql_database.cc + ./sql_query.cc + ./sql_error.cc +) + +add_library(${target} ${SOURCES}) +target_link_libraries(${target} Utils) diff --git a/src/components/utils/src/sqlite_wrapper/sql_database.cc b/src/components/utils/src/sqlite_wrapper/sql_database.cc new file mode 100644 index 0000000000..bf19275bac --- /dev/null +++ b/src/components/utils/src/sqlite_wrapper/sql_database.cc @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2013, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "sqlite_wrapper/sql_database.h" +#include <sqlite3.h> + +namespace utils { +namespace dbms { + +const std::string SQLDatabase::kInMemory = ":memory:"; +const std::string SQLDatabase::kExtension = ".sqlite"; + +SQLDatabase::SQLDatabase() + : conn_(NULL), databasename_(kInMemory), error_(SQLITE_OK) {} + +SQLDatabase::SQLDatabase(const std::string& db_name) + : conn_(NULL), databasename_(db_name + kExtension), error_(SQLITE_OK) {} + +SQLDatabase::~SQLDatabase() { + Close(); +} + +bool SQLDatabase::Open() { + sync_primitives::AutoLock auto_lock(conn_lock_); + if (conn_) + return true; + error_ = sqlite3_open(databasename_.c_str(), &conn_); + return error_ == SQLITE_OK; +} + +bool SQLDatabase::IsReadWrite() { + const char* schema = "main"; + return sqlite3_db_readonly(conn_, schema) == 0; +} + +void SQLDatabase::Close() { + if (!conn_) { + return; + } + + sync_primitives::AutoLock auto_lock(conn_lock_); + error_ = sqlite3_close(conn_); + if (error_ == SQLITE_OK) { + conn_ = NULL; + } +} + +bool SQLDatabase::BeginTransaction() { + return Exec("BEGIN TRANSACTION"); +} + +bool SQLDatabase::CommitTransaction() { + return Exec("COMMIT TRANSACTION"); +} + +bool SQLDatabase::RollbackTransaction() { + return Exec("ROLLBACK TRANSACTION"); +} + +bool SQLDatabase::Exec(const std::string& query) { + sync_primitives::AutoLock auto_lock(conn_lock_); + error_ = sqlite3_exec(conn_, query.c_str(), NULL, NULL, NULL); + return error_ == SQLITE_OK; +} + +SQLError SQLDatabase::LastError() const { + return SQLError(Error(error_)); +} + +sqlite3* SQLDatabase::conn() const { + return conn_; +} + +void SQLDatabase::set_path(const std::string& path) { + databasename_ = path + databasename_; +} + +std::string SQLDatabase::get_path() const { + return databasename_; +} + +bool SQLDatabase::Backup() { + return true; +} +} // namespace dbms +} // namespace utils diff --git a/src/components/utils/src/sqlite_wrapper/sql_error.cc b/src/components/utils/src/sqlite_wrapper/sql_error.cc new file mode 100644 index 0000000000..9062731a81 --- /dev/null +++ b/src/components/utils/src/sqlite_wrapper/sql_error.cc @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2013, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "sqlite_wrapper/sql_error.h" + +namespace utils { +namespace dbms { + +SQLError::SQLError(Error number, const std::string& text) + : number_(number), text_(text) {} + +Error SQLError::number() const { + return number_; +} + +std::string SQLError::text() const { + if (!text_.empty()) { + return text_; + } + switch (number_) { + case OK: + text_ = "Successful result"; + break; + case ERROR: + text_ = "SQL error or missing database"; + break; + case INTERNAL: + text_ = "Internal logic error in SQLite"; + break; + case PERM: + text_ = "Access permission denied"; + break; + case ABORT: + text_ = "Callback routine requested an abort"; + break; + case BUSY: + text_ = "The database file is locked"; + break; + case LOCKED: + text_ = "A table in the database is locked"; + break; + case NOMEM: + text_ = "A malloc() failed"; + break; + case READONLY: + text_ = "Attempt to write a readonly database"; + break; + case INTERRUPT: + text_ = "Operation terminated by sqlite3_interrupt()"; + break; + case IOERR: + text_ = "Some kind of disk I/O error occurred"; + break; + case CORRUPT: + text_ = "The database disk image is malformed"; + break; + case NOTFOUND: + text_ = "Unknown opcode in sqlite3_file_control()"; + break; + case FULL: + text_ = "Insertion failed because database is full"; + break; + case CANTOPEN: + text_ = "Unable to open the database file"; + break; + case PROTOCOL: + text_ = "Database lock protocol error"; + break; + case EMPTY: + text_ = "Database is empty"; + break; + case SCHEMA: + text_ = "The database schema changed"; + break; + case TOOBIG: + text_ = "String or BLOB exceeds size limit"; + break; + case CONSTRAINT: + text_ = "Abort due to constraint violation"; + break; + case MISMATCH: + text_ = "Data type mismatch"; + break; + case MISUSE: + text_ = "Library used incorrectly"; + break; + case NOLFS: + text_ = "Uses OS features not supported on host"; + break; + case AUTH: + text_ = "Authorization denied"; + break; + case FORMAT: + text_ = "Auxiliary database format error"; + break; + case RANGE: + text_ = "2nd parameter to sqlite3_bind out of range"; + break; + case NOTADB: + text_ = "File opened that is not a database file"; + break; + case NOTICE: + text_ = "Notifications from sqlite3_log()"; + break; + case WARNING: + text_ = "Warnings from sqlite3_log()"; + break; + case ROW: + text_ = "sqlite3_step() has another row ready"; + break; + case DONE: + text_ = "sqlite3_step() has finished executing"; + break; + default: + text_ = "Unknown error"; + } + return text_; +} + +} // namespace dbms +} // namespace utils diff --git a/src/components/utils/src/sqlite_wrapper/sql_query.cc b/src/components/utils/src/sqlite_wrapper/sql_query.cc new file mode 100644 index 0000000000..5a62ec360d --- /dev/null +++ b/src/components/utils/src/sqlite_wrapper/sql_query.cc @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2013, Ford Motor Company + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following + * disclaimer in the documentation and/or other materials provided with the + * distribution. + * + * Neither the name of the Ford Motor Company nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include "sqlite_wrapper/sql_query.h" +#include <sqlite3.h> +#include <cassert> +#include "sqlite_wrapper/sql_database.h" + +namespace utils { +namespace dbms { + +SQLQuery::SQLQuery(SQLDatabase* db) + : db_(*db), query_(""), statement_(NULL), error_(SQLITE_OK) {} + +SQLQuery::~SQLQuery() { + Finalize(); +} + +bool SQLQuery::Prepare(const std::string& query) { + Finalize(); + sync_primitives::AutoLock auto_lock(statement_lock_); + if (statement_) + return false; + error_ = sqlite3_prepare( + db_.conn(), query.c_str(), query.length(), &statement_, NULL); + query_ = query; + return error_ == SQLITE_OK; +} + +bool SQLQuery::Exec() { + error_ = sqlite3_step(statement_); + return error_ == SQLITE_ROW || error_ == SQLITE_DONE; +} + +bool SQLQuery::Next() { + error_ = sqlite3_step(statement_); + return error_ == SQLITE_ROW; +} + +bool SQLQuery::Reset() { + error_ = sqlite3_reset(statement_); + return error_ == SQLITE_OK; +} + +void SQLQuery::Finalize() { + sync_primitives::AutoLock auto_lock(statement_lock_); + error_ = sqlite3_finalize(statement_); + if (error_ == SQLITE_OK) { + statement_ = NULL; + } +} + +bool SQLQuery::Exec(const std::string& query) { + query_ = query; + error_ = sqlite3_exec(db_.conn(), query.c_str(), NULL, NULL, NULL); + return error_ == SQLITE_OK; +} + +void SQLQuery::Bind(int pos, int value) { + // In SQLite the number of position for binding starts since 1. + error_ = sqlite3_bind_int(statement_, pos + 1, value); +} + +void SQLQuery::Bind(int pos, int64_t value) { + // In SQLite the number of position for binding starts since 1. + error_ = sqlite3_bind_int64(statement_, pos + 1, value); +} + +void SQLQuery::Bind(int pos, double value) { + // In SQLite the number of position for binding starts since 1. + error_ = sqlite3_bind_double(statement_, pos + 1, value); +} + +void SQLQuery::Bind(int pos, bool value) { + Bind(pos, static_cast<int>(value)); +} + +void SQLQuery::Bind(int pos, const std::string& value) { + // In SQLite the number of position for binding starts since 1. + error_ = sqlite3_bind_text( + statement_, pos + 1, value.c_str(), value.length(), SQLITE_TRANSIENT); +} + +bool SQLQuery::GetBoolean(int pos) const { + return static_cast<bool>(GetInteger(pos)); +} + +int SQLQuery::GetInteger(int pos) const { + return sqlite3_column_int(statement_, pos); +} + +uint32_t SQLQuery::GetUInteger(int pos) const { + return static_cast<uint32_t>(sqlite3_column_int64(statement_, pos)); +} + +int64_t SQLQuery::GetLongInt(int pos) const { + return static_cast<int64_t>(sqlite3_column_int64(statement_, pos)); +} + +double SQLQuery::GetDouble(int pos) const { + return sqlite3_column_double(statement_, pos); +} + +std::string SQLQuery::GetString(int pos) const { + const unsigned char* str = sqlite3_column_text(statement_, pos); + return str ? reinterpret_cast<const char*>(str) : ""; +} + +const std::string& SQLQuery::query() const { + // TODO(KKolodiy): may return string query with value of arguments + return query_; +} + +bool SQLQuery::IsNull(int pos) const { + return sqlite3_column_type(statement_, pos) == SQLITE_NULL; +} + +void SQLQuery::Bind(int pos) { + // In SQLite the number of position for binding starts since 1. + error_ = sqlite3_bind_null(statement_, pos + 1); +} + +SQLError SQLQuery::LastError() const { + return SQLError(Error(error_)); +} + +int64_t SQLQuery::LastInsertId() const { + return sqlite3_last_insert_rowid(db_.conn()); +} + +} // namespace dbms +} // namespace utils |