SQLiteConnection Class Reference

#include <SQLiteConnection.hh>

Inheritance diagram for SQLiteConnection:

Collaboration diagram for SQLiteConnection:

Public Member Functions
	SQLiteConnection (sqlite3 *connection)
virtual	~SQLiteConnection ()
virtual int	updateQuery (const std::string &queryString)
virtual void	DDLQuery (const std::string &queryString)
virtual RelationalDBQueryResult *	query (const std::string &queryString, bool init=true)
virtual void	beginTransaction ()
virtual void	rollback ()
virtual void	commit ()
virtual RowID	lastInsertRowID ()
virtual bool	tableExistsInDB (const std::string &tableName)
virtual int	rowCountInTable (const std::string &tableName)
void	throwIfSQLiteError (int result)
void	finalizeQuery (sqlite3_stmt *statement)
virtual int	version ()
virtual void	updateVersion (int version)
Public Member Functions inherited from RelationalDBConnection
virtual	~RelationalDBConnection ()

Private Member Functions
sqlite3_stmt *	compileQuery (const std::string &queryString)

Private Attributes
sqlite3 *	connection_
	SQLite connection handle is saved to this.
bool	transactionActive_

Detailed Description

Implementation of RelationalDBConnection interface for SQLite library.

Definition at line 47 of file SQLiteConnection.hh.

Constructor & Destructor Documentation

SQLiteConnection()

SQLiteConnection::SQLiteConnection

(

sqlite3 *

connection

)

Constructor.

Parameters

connection

A pointer to a SQLite connection handle.

Definition at line 45 of file SQLiteConnection.cc.

                                                      :
    connection_(connection), transactionActive_(false) {
}

~SQLiteConnection()

SQLiteConnection::~SQLiteConnection ( )

virtual

Destructor.

Closes the connection.

Definition at line 54 of file SQLiteConnection.cc.

                                    {
    sqlite3_close(connection_);
}

References connection_.

Member Function Documentation

beginTransaction()

void SQLiteConnection::beginTransaction ( )

virtual

Starts a new database transaction.

Also ends the possible previous transaction successfully (commit).

Exceptions

RelationalDBException

In case a database error occured.

Implements RelationalDBConnection.

Definition at line 124 of file SQLiteConnection.cc.

                                   {
    if (transactionActive_) {
        commit();
    }
    updateQuery("BEGIN;");
    transactionActive_ = true;
}

References commit(), transactionActive_, and updateQuery().

Here is the call graph for this function:

commit()

void SQLiteConnection::commit ( )

virtual

Ends the current database transaction successfully and commits all the changes in the transaction to the database.

Exceptions

RelationalDBException

In case a database error occured.

Implements RelationalDBConnection.

Definition at line 151 of file SQLiteConnection.cc.

                         {
    updateQuery("COMMIT;");
    transactionActive_ = false;
}

References transactionActive_, and updateQuery().

Referenced by beginTransaction().

Here is the call graph for this function:

compileQuery()

sqlite3_stmt * SQLiteConnection::compileQuery ( const std::string &  queryString )

private

Compiles a SQLite query.

Parameters

queryString

The SQL statement to compile.

Returns

The SQLite virtual machine that should be used to execute the query.

Exceptions

RelationalDBException

In case a database error occured.

Definition at line 270 of file SQLiteConnection.cc.

                                                           {
    // "virtual machine" used by SQLite to execute the statements
    sqlite3_stmt* stmt = NULL;
    const char* dummy = NULL;
 
    throwIfSQLiteError(sqlite3_prepare(
        connection_, queryString.c_str(), queryString.length(),
        &stmt, &dummy));
    return stmt;
}

References connection_, dummy, and throwIfSQLiteError().

Referenced by query(), and updateQuery().

Here is the call graph for this function:

DDLQuery()

void SQLiteConnection::DDLQuery ( const std::string &  queryString )

virtual

Performs a SQL Data Definition Language query, that is a query that may change the structure of the database (CREATE TABLE, etc.).

Does not autocommit the changes in case the update is in the middle of transaction.

Parameters

queryString

The query string.

Exceptions

RelationalDBException

In case a database error occured.

Implements RelationalDBConnection.

Definition at line 98 of file SQLiteConnection.cc.

                                                       {
    updateQuery(queryString);
}

References updateQuery().

Here is the call graph for this function:

finalizeQuery()

void SQLiteConnection::finalizeQuery

(

sqlite3_stmt *

statement

)

Finalizes a SQLite query, frees the virtual machine.

Does nothing if the statement is NULL.

Parameters

statement

The SQLite statement to free.

Exceptions

RelationalDBException

In case there was errors (can be cumulated from a previous sqlite3_step() call).

Definition at line 291 of file SQLiteConnection.cc.

                                                       {
    if (statement == NULL) {
        return;
    }
 
    throwIfSQLiteError(sqlite3_finalize(statement));
}

References throwIfSQLiteError().

Referenced by updateQuery(), and SQLiteQueryResult::~SQLiteQueryResult().

Here is the call graph for this function:

lastInsertRowID()

RowID SQLiteConnection::lastInsertRowID ( )

virtual

Returns the row ID of the most recent insert in the database.

Returns

The row ID.

Implements RelationalDBConnection.

Definition at line 162 of file SQLiteConnection.cc.

                                  {
    return sqlite3_last_insert_rowid(connection_);
}

References connection_.

query()

RelationalDBQueryResult * SQLiteConnection::query ( const std::string &  queryString, bool  init = true  )

virtual

Performs a data retrieval query (SELECT).

Parameters

queryString

The query string.

Returns

A handle to the query result set.

Exceptions

RelationalDBException

In case a database error occured.

Implements RelationalDBConnection.

Definition at line 110 of file SQLiteConnection.cc.

                                                               {
    sqlite3_stmt* stmt = compileQuery(queryString);
    SQLiteQueryResult* result = new SQLiteQueryResult(stmt, this, init);
    return result;
}

References compileQuery().

Referenced by rowCountInTable(), tableExistsInDB(), updateVersion(), and version().

Here is the call graph for this function:

rollback()

void SQLiteConnection::rollback ( )

virtual

Ends the current database transaction unsuccessfully and rollbacks all the changes the queries in the transaction would have done.

Exceptions

RelationalDBException

In case a database error occured.

Implements RelationalDBConnection.

Definition at line 139 of file SQLiteConnection.cc.

                           {
    updateQuery("ROLLBACK;");
    transactionActive_ = false;
}

References transactionActive_, and updateQuery().

Here is the call graph for this function:

rowCountInTable()

int SQLiteConnection::rowCountInTable ( const std::string &  tableName )

virtual

Return number of entries in the given table.

Parameters

tableName

Name of the table.

Returns

Number of entries in table.

Exceptions

RelationalDBException

In case a database error occurred, call was made in the middle of an active transaction or the table does not exists.

Implements RelationalDBConnection.

Definition at line 218 of file SQLiteConnection.cc.

                                                            {
    if (!tableExistsInDB(tableName)) {
        throw RelationalDBException(__FILE__, __LINE__,
            "SQLiteConnection::rowCountInTable()",
            "Table was not found.");
    }
    string query = "SELECT count(*) FROM " + tableName + ";";
 
    RelationalDBQueryResult* result = this->query(query, false);
    assert(result->hasNext());
    result->next();
    const DataObject& count = result->data(0);
    int countAsInt = -1;
 
    try {
        countAsInt = count.integerValue(); // boolValue is zero if DataObject
                                           // has NULL value.
    } catch (NumberFormatException& e) {
        throw RelationalDBException(__FILE__, __LINE__,
            "SQLiteConnection::tableExistsInDB()",
            "Exception from DataObject: " + e.errorMessage());
    }
 
    delete result;
    assert(countAsInt > -1);
    return countAsInt;
}

References assert, RelationalDBQueryResult::data(), Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), query(), and tableExistsInDB().

Here is the call graph for this function:

tableExistsInDB()

bool SQLiteConnection::tableExistsInDB ( const std::string &  tableName )

virtual

Checks if database has given table by name.

Parameters

tableName

Name of the table

Returns

True if db has the table. Otherwise false.

Exceptions

RelationalDBException

In case a database error occurred or call was made in the middle of an active transaction.

Implements RelationalDBConnection.

Definition at line 177 of file SQLiteConnection.cc.

                                                            {
    if (transactionActive_) {
        throw RelationalDBException(__FILE__, __LINE__,
            "SQLiteConnection::tableExistsInDB()",
            "Illegal call during active transaction.");
    }
 
    string query = "SELECT count(*) "
        "FROM sqlite_master "
        "WHERE type = 'table' and name = '" + tableName + "';";
 
    RelationalDBQueryResult* result = this->query(query, false);
    assert(result->hasNext());
    result->next();
    const DataObject& count = result->data(0);
 
    int intBoolValue = 0;
 
    try {
        intBoolValue = count.integerValue(); // boolValue is zero if DataObject
                                             // has NULL value.
    } catch (NumberFormatException& e) {
        throw RelationalDBException(__FILE__, __LINE__,
            "SQLiteConnection::tableExistsInDB()",
            "Exception from DataObject: " + e.errorMessage());
    }
 
    delete result;
    return intBoolValue;
}

References assert, RelationalDBQueryResult::data(), Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), query(), and transactionActive_.

Referenced by rowCountInTable().

Here is the call graph for this function:

throwIfSQLiteError()

void SQLiteConnection::throwIfSQLiteError

(

int

result

)

Throws a RelationalDBException if result value indicates an SQLite error.

Parameters

result

The value from a SQLite API call.

Exceptions

RelationalDBException

Thrown if result is not SQLITE_OK.

Definition at line 253 of file SQLiteConnection.cc.

                                               {
    if (result != SQLITE_OK && result != SQLITE_ROW &&
        result != SQLITE_DONE) {
 
        string error = sqlite3_errmsg(connection_);
        throw RelationalDBException(__FILE__, __LINE__, "", error);
    }
}

References connection_.

Referenced by SQLiteQueryResult::bindInt(), SQLiteQueryResult::bindString(), compileQuery(), finalizeQuery(), SQLiteQueryResult::reset(), and updateQuery().

updateQuery()

int SQLiteConnection::updateQuery ( const std::string &  queryString )

virtual

Performs a query that changes the database (UPDATE/INSERT/DELETE).

Does not autocommit the changes in case the update is in the middle of transaction.

Parameters

queryString

The query string.

Returns

Number of rows affected by the change.

Exceptions

RelationalDBException

In case a database error occured.

Implements RelationalDBConnection.

Definition at line 69 of file SQLiteConnection.cc.

                                                          {
    if (connection_ == NULL) {
        throw RelationalDBException(
            __FILE__, __LINE__, "SQLiteConnection::updateQuery()",
            "Not connected!");
    }
 
    // "virtual machine" used by SQLite to execute the statements
    sqlite3_stmt* stmt = compileQuery(queryString);
 
    assert(stmt != NULL);
 
    throwIfSQLiteError(sqlite3_step(stmt));
    finalizeQuery(stmt);
 
    return sqlite3_changes(connection_);
}

References assert, compileQuery(), connection_, finalizeQuery(), and throwIfSQLiteError().

Referenced by beginTransaction(), commit(), DDLQuery(), rollback(), and updateVersion().

Here is the call graph for this function:

updateVersion()

void SQLiteConnection::updateVersion ( int  version )

virtual

Set database version number.

Parameters

version

New database version.

Implements RelationalDBConnection.

Definition at line 335 of file SQLiteConnection.cc.

                                           {
    string query = "pragma user_version = " +
        std::to_string(version) + ";";
    this->updateQuery(query);
}

References query(), updateQuery(), and version().

Here is the call graph for this function:

version()

int SQLiteConnection::version ( )

virtual

Return database version number.

Returns

Database version.

Implements RelationalDBConnection.

Definition at line 305 of file SQLiteConnection.cc.

                          {
    int version = 0;
 
    string query = "pragma user_version;";
 
    RelationalDBQueryResult* result = this->query(query, false);
 
 
    assert(result->hasNext());
    result->next();
    const DataObject& count = result->data(0);
 
    try {
        version = count.integerValue();
    } catch (NumberFormatException& e) {
        throw RelationalDBException(__FILE__, __LINE__,
            "SQLiteConnection::version()",
            "Exception from DataObject: " + e.errorMessage());
    }
 
    delete result;
    return version;
}

References assert, RelationalDBQueryResult::data(), Exception::errorMessage(), RelationalDBQueryResult::hasNext(), DataObject::integerValue(), RelationalDBQueryResult::next(), query(), and version().

Referenced by updateVersion(), and version().

Here is the call graph for this function:

Member Data Documentation

connection_

sqlite3* SQLiteConnection::connection_

private

SQLite connection handle is saved to this.

Definition at line 78 of file SQLiteConnection.hh.

Referenced by compileQuery(), lastInsertRowID(), throwIfSQLiteError(), updateQuery(), and ~SQLiteConnection().

transactionActive_

bool SQLiteConnection::transactionActive_

private

Definition at line 80 of file SQLiteConnection.hh.

Referenced by beginTransaction(), commit(), rollback(), and tableExistsInDB().

---

The documentation for this class was generated from the following files:

• SQLiteConnection.hh
• SQLiteConnection.cc