SQLiteCpp: A C repository from makiftasova

SQLiteC++

SQLiteC++ (SQLiteCpp) is a smart and easy to use C++ SQLite3 wrapper.

See SQLiteC++ website http://srombauts.github.com/SQLiteCpp on GitHub.

Keywords: sqlite, sqlite3, C, library, wrapper C++

About SQLite:

SQLite is a library that implements a serverless transactional SQL database engine. It is the most widely deployed SQL database engine in the world. The source code for SQLite is in the public domain. http://www.sqlite.org/about.html

About SQLiteC++:

SQLiteC++ offers an encapsulation arround the native C APIs of sqlite, with a few intuitive and well documented C++ class.

The goals of SQLiteC++ are:

to offer the best of existing simple C++ SQLite wrappers
to be elegantly written with good C++ design, STL, exceptions and RAII idiom
to keep dependencies to a minimum (STL and SQLite3)
to be portable
to be light and fast
to be thread-safe only as much as SQLite "Multi-thread" mode (see below)
to have a good unit test coverage
to use API names sticking with those of the SQLite library
to be well documented with Doxygen tags, and with some good examples
to be well maintained
to use a permissive MIT license, similar to BSD or Boost, for proprietary/commercial usage

It is designed using the Resource Acquisition Is Initialization (RAII) idom (see http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization), and throwing exceptions in case of SQLite errors (exept in destructors, where assert() are used instead). Each SQLiteC++ object must be constructed with a valid SQLite database connection, and then is always valid until destroyed.

### Suported platforms:

Developements and tests are done under the following OSs :

Debian 7 (testing)
Ubuntu 12.10
Windows XP/7/8 And following IDEs/Compilers
GCC 4.7.x with a provided Makefile
Eclipse CDT under Linux, using the provided Makefile
Visual Studio Express 2008/2010/2012 for testing compatibility purpose

Dependencies:

a STL implementation (even an old one, like the one provided with VC6 should work)
exception support (the class Exception inherit from std::runtime_error)
the SQLite library, either by linking to it dynamicaly or staticaly (libsqlite3-dev under Linux), or by adding its source file in your project code base (source code provided in src/sqlite3 for Windows).

Thread-safety

SQLite supports three mode of thread safety, as describe in "SQLite And Multiple Threads" : see http://www.sqlite.org/threadsafe.html

This SQLiteC++ wrapper does no add any lock (no mutexes) nor any other thread-safety mecanism above the SQLite library itself, by design, for lightness and speed.

Thus, SQLiteC++ naturally supports the "Multi Thread" mode of SQLite ; "In this mode, SQLite can be safely used by multiple threads provided that no single database connection is used simultaneously in two or more threads."

But SQLiteC++ does not support the fully thread-safe "Serialized" mode of SQLite, because of the way it shares the underling SQLite precompiled statement in a custom shared pointer (See the inner class "Statement::Ptr").

Installation:

To use this wrappers, you need to add the 10 SQLiteC++ source files from the src/ directory in your project code base, and compile/link against the sqlite library.

License

Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt or copy at http://opensource.org/licenses/MIT)

Getting started

First sample demonstrates how to query a database and get results:

try
{
    // Open a database file
    SQLite::Database    db("example.db3");
    
    // Compile a SQL query, containing one parameter (index 1)
    SQLite::Statement   query(db, "SELECT * FROM test WHERE size > ?");
    
    // Bind the integer value 6 to the first parameter of the SQL query
    query.bind(1, 6);
    
    // Loop to execute the query step by step, to get rows of result
    while (query.executeStep())
    {
        // Demonstrate how to get some typed column value
        int         id      = query.getColumn(0);
        const char* value   = query.getColumn(1);
        int         size    = query.getColumn(2);
        
        std::cout << "row: " << id << ", " << value << ", " << size << std::endl;
    }
}
catch (std::exception& e)
{
    std::cout << "exception: " << e.what() << std::endl;
}

Second sample shows how to manage a transaction:

try
{
    SQLite::Database    db("transaction.db3", SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);

    db.exec("DROP TABLE IF EXISTS test");

    // Begin transaction
    SQLite::Transaction transaction(db);

    db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)");

    int nb = db.exec("INSERT INTO test VALUES (NULL, \"test\")");
    std::cout << "INSERT INTO test VALUES (NULL, \"test\")\", returned " << nb << std::endl;

    // Commit transaction
    transaction.commit();
}
catch (std::exception& e)
{
    std::cout << "exception: " << e.what() << std::endl;
}

How to contribute

GitHub website

The most efficient way to help and contribute to this wrapper project is to use the tools provided by GitHub:

please fill bug reports and feature requests here: https://github.com/SRombauts/SQLiteCpp/issues
fork the repository, make some small changes and submit them with pull-request

Contact

You can also email me directly, I will answer any questions and requests.

Coding Style Guidelines

The source code use the CamelCase naming style variant where :

type names (class, struct, typedef, enums...) begins with a capital letter
files (.cpp/.h) are named like the class they contains
function and variable names begins with a lower case letter
member variables begins with a 'm', function arguments begins with a 'a', boolean with a 'b', pointers with a 'p'
each file, class, method and member variable is documented using Doxygen tags See also http://www.appinf.com/download/CppCodingStyleGuide.pdf for good guidelines

makiftasova/SQLiteCpp