#include <sqlitemm.h>
 
int main(int argc, char** argv)
{
    // open a connection to a sqlite database
    Glib::RefPtr<sqlite::Connection> sqlite =
            sqlite::Connection::create("/path/to/db.sqlite");
 
    // we'll reuse this variable for different statements
    Glib::RefPtr<sqlite::Connection> stmt;
 
    // prepare a read statement
    stmt = sqlite->prepare("SELECT * FROM table_a WHERE field_a=?");
 
    // bind a value to one of the parameters
    stmt->bind<int>(1,10);
 
    // execute the select statement
    stmt->step();
 
    // read out the result set
    while(stmt->hasAnotherRow())
    {
        // retrieve the first column of the result set as an integer
        int             field_a = stmt->get<int>(0);
 
        // retrieve the second column of the result set as a string
        std::string     field_b = stmt->get<std::string>(1);
 
        // retrieve the third column of the result set as a double
        double          field_c = stmt->get<double>(2);
 
        // do something
    }
 
    // if we want to reuse the statement we need to call this
    stmt->reset();
 
    // prepare a second statement, note that all memory allocated for the
    // first statement is released here, because the smart pointer is
    // reassigned and the object it points to only has one outstanding reference
    stmt = m_sqlite->prepare("UPDATE table SET field_a=? WHERE field_b=?" );
    stmt->bind<int>(1,20);
    stmt->bind<std::string>(2,"something");
 
    // now actually execute the statement
    stmt->step();
 
    // note that we do not have to explicitly close the connection, when
    // the sqlite variable goes out of scope, the smart pointer will drop it's
    // reference to the underlying Connection object, and the connection
    // object will be destroyed. The databse is closed during the destructor
    // of the Connection object.
    return 0;
}