Final touches

Author: Killili

README.md

@@ -82,20 +82,20 @@ Prepared Statements
 It is possible to retain and reuse statments this will keep the query plan and in case of an complex query or many uses might increase the performance significantly.
 
 ```c++
-
 		database db(":memory:");
 
 		// if you use << on a sqlite::database you get a prepared statment back
 		// this will not be executed till it gets destroyed or you execute it explicitly
-		auto ps = db << "select ?,? "; // get a prepared parsed and ready statment
+		auto ps = db << "select a,b from table where something = ? and anotherthing = ?"; // get a prepared parsed and ready statment
 
 		// first if needed bind values to it
 		ps << 5;
 		int tmp = 8;
 		ps << tmp;
 
-		// now you can execute it, if the statment was executed once it will not be executed again when it goes out of scope.
-		// But beware that it will if it wasn't executed!
+		// now you can execute it with `operator>>` or `execute()`. 
+		// If the statment was executed once it will not be executed again when it goes out of scope.
+		// But beware that it will execute on destruction if it wasn't executed!
 		ps >> [&](int a,int b){ ... };
 
 		// after a successfull execution the statment needs to be reset to be execute again. This will reset the bound values too!
@@ -108,7 +108,7 @@ It is possible to retain and reuse statments this will keep the query plan and i
 		ps++;
 
 		// To disable the execution of a statment when it goes out of scope and wasn't used
-		ps.set_used(true); // or false if you want it to execute even if it was used 
+		ps.used(true); // or false if you want it to execute even if it was used 
 
 		// Usage Example:
 
@@ -124,15 +124,30 @@ Shared Connections
 =====
 If you need the handle to the database connection to execute sqlite3 commands directly you can get a managed shared_ptr to it, so it will not close as long as you have a referenc to it.
 
+Take this example on how to deal with a database backup using SQLITEs own functions in a save and modern way.
 ```c++
-	sqlite::connection_type con;
-	
-	{ // scope of our db object
-		database db(":memory:"); // Make a connection and create in memory db
-		con = db.get_sqlite3_connection();
-	} // here the temporary db would be lost but we still have the connection for our direct API calls
+	try {
+		database backup("backup");		//Open the database file we want to backup to
 
-	database db2(con); // or we can even make a new database object from it
+		auto con = db.connection();		// get a handle to the DB we want to backup in our scope
+										// this way we are sure the DB is open and ok while we backup
+		
+		// Init Backup and make sure its freed on exit or exceptions!
+		auto state = 
+			std::unique_ptr<sqlite3_backup,decltype(&sqlite3_backup_finish)>(
+			sqlite3_backup_init(backup.connection().get(), "main", con.get(), "main"),
+			sqlite3_backup_finish
+			);
+
+		if(state) {
+			int rc;
+			// Each iteration of this loop copies 500 database pages from database db to the backup database.
+			do {
+				rc = sqlite3_backup_step(state.get(), 500);
+				std::cout << "Remaining " << sqlite3_backup_remaining(pBackup) << "/" << sqlite3_backup_pagecount(pBackup) << "\n";
+			} while(rc == SQLITE_OK || rc == SQLITE_BUSY || rc == SQLITE_LOCKED);
+		}
+	} // Release allocated resources.
 ```
 
 Transactions

hdr/sqlite_modern_cpp.h

@@ -133,8 +133,8 @@ namespace sqlite {
 			}
 		}
 
-		void set_used(bool state) { execution_started = state; }
-		bool get_used() const { return execution_started; }
+		void used(bool state) { execution_started = state; }
+		bool used() const { return execution_started; }
 
 	private:
 		std::shared_ptr<sqlite3> _db;
@@ -228,7 +228,7 @@ namespace sqlite {
 
 		~database_binder() noexcept(false) {
 			/* Will be executed if no >>op is found, but not if an exception
-			is in mud flight */
+			is in mid flight */
 			if(!execution_started && !std::uncaught_exception()) {
 				execute();
 			}
@@ -279,16 +279,11 @@ namespace sqlite {
 		database(std::shared_ptr<sqlite3> db):
 			_db(db) {}
 
-		//template<typename T>
-		//database_binder::chain_type operator<<(const T& sql) const {
-		//	return database_binder::chain_type(new database_binder(_db,std::string(sql)));
-		//}
-
 		database_binder::chain_type operator<<(const char* sql) {
 			return database_binder::chain_type(new database_binder(_db, std::string(sql)));
 		}
 
-		connection_type get_sqlite3_connection() const { return _db; }
+		connection_type connection() const { return _db; }
 
 		sqlite3_int64 last_insert_rowid() const {
 			return sqlite3_last_insert_rowid(_db.get());
@@ -484,10 +479,11 @@ namespace sqlite {
 	}
 #endif
 
-	// there is too much magic here, val might be rValue or rValue
+	// there is too much magic here, val might be rValue or lValue
 	template<typename T> void operator >> (database_binder::chain_type& db, T&& val) { *db >> std::forward<T>(val); }
 	template<typename T> void operator >> (database_binder::chain_type&& db, T&& val) { db >> std::forward<T>(val); }
 
+	// Some ppl are lazy so we have a operator for proper prep. statemant handling.
 	void operator++(database_binder::chain_type& db, int) { db->execute(); db->reset(); }
 
 	// Convert the rValue binder to a reference and call first op<<, its needed for the call that creates the binder (be carfull of recursion here!)