From 3c95f9f788ed98b9e1eb99b9ce6d7a64a5bb07c8 Mon Sep 17 00:00:00 2001 From: "Scott E. Graves" Date: Sun, 19 Feb 2017 13:33:40 -0600 Subject: [PATCH] Sqlite --- .../examples/example1/example.db3 | Bin 0 -> 3072 bytes .../examples/example1/logo.png | Bin 0 -> 12581 bytes .../examples/example1/main.cpp | 464 ++++++++++++++++++ 3 files changed, 464 insertions(+) create mode 100644 3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/example.db3 create mode 100644 3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/logo.png create mode 100644 3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/main.cpp diff --git a/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/example.db3 b/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/example.db3 new file mode 100644 index 0000000000000000000000000000000000000000..89a74195a6ec2ae6bf20812d7dcd8da485fd1c17 GIT binary patch literal 3072 zcmeHG%SyvQ6rE&((Ly&uEp&CIl(rD153m6@N$XTfW34d-O9>&GR0FYrHkx%m#Dz=O z{zm-?SAK?*)CSztT`7_ScOGXhbIu%?>np|aZ5VsgN7IKo;t<0i2>>BfpoM>mq4Pd1 zmevX(_ZJH2=(CWfT?`Ho4(O2Jenx=J91A)C#H(Iz0Z0G*LhqiJlYpF7g z_%)l!F!La`7hcZ(k{gAT4yANz-0@sYzED)S~~O>oVb4<0?sFQ0P2 eaOjX9J5x#r-qe!VafEGpXyPSFAW2}e348;v>7zsd literal 0 HcmV?d00001 diff --git a/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/logo.png b/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..ba2d895c9eeedc83422dd5312f8a88983eb983a0 GIT binary patch literal 12581 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 literal 0 HcmV?d00001 diff --git a/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/main.cpp b/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/main.cpp new file mode 100644 index 0000000..9aaffd7 --- /dev/null +++ b/3rd-party/SRombauts-SQLiteCpp-f69986a/examples/example1/main.cpp @@ -0,0 +1,464 @@ +/** + * @file main.cpp + * @brief A few short examples in a row. + * + * Demonstrates how-to use the SQLite++ wrapper + * + * Copyright (c) 2012-2016 Sebastien Rombauts (sebastien.rombauts@gmail.com) + * + * Distributed under the MIT License (MIT) (See accompanying file LICENSE.txt + * or copy at http://opensource.org/licenses/MIT) + */ + +#include +#include +#include +#include + +#include +#include + + +#ifdef SQLITECPP_ENABLE_ASSERT_HANDLER +namespace SQLite +{ +/// definition of the assertion handler enabled when SQLITECPP_ENABLE_ASSERT_HANDLER is defined in the project (CMakeList.txt) +void assertion_failed(const char* apFile, const long apLine, const char* apFunc, const char* apExpr, const char* apMsg) +{ + // Print a message to the standard error output stream, and abort the program. + std::cerr << apFile << ":" << apLine << ":" << " error: assertion failed (" << apExpr << ") in " << apFunc << "() with message \"" << apMsg << "\"\n"; + std::abort(); +} +} +#endif + +/// Get example path +static inline std::string getExamplePath() +{ + std::string filePath(__FILE__); + return filePath.substr( 0, filePath.length() - std::string("main.cpp").length()); +} + +/// Example Database +static const std::string filename_example_db3 = getExamplePath() + "/example.db3"; +/// Image +static const std::string filename_logo_png = getExamplePath() + "/logo.png"; + + +/// Object Oriented Basic example +class Example +{ +public: + // Constructor + Example() : + mDb(filename_example_db3), // Open a database file in readonly mode + mQuery(mDb, "SELECT * FROM test WHERE weight > :min_weight")// Compile a SQL query, containing one parameter (index 1) + { + } + virtual ~Example() + { + } + + /// List the rows where the "weight" column is greater than the provided aParamValue + void ListGreaterThan (const int aParamValue) + { + std::cout << "ListGreaterThan (" << aParamValue << ")\n"; + + // Bind the integer value provided to the first parameter of the SQL query + mQuery.bind(":min_weight", aParamValue); // same as mQuery.bind(1, aParamValue); + + // Loop to execute the query step by step, to get one a row of results at a time + while (mQuery.executeStep()) + { + std::cout << "row (" << mQuery.getColumn(0) << ", \"" << mQuery.getColumn(1) << "\", " << mQuery.getColumn(2) << ")\n"; + } + + // Reset the query to be able to use it again later + mQuery.reset(); + } + +private: + SQLite::Database mDb; ///< Database connection + SQLite::Statement mQuery; ///< Database prepared SQL query +}; + +int main () +{ + // Using SQLITE_VERSION would require #include which we want to avoid: use SQLite::VERSION if possible. +// std::cout << "SQlite3 version " << SQLITE_VERSION << std::endl; + std::cout << "SQlite3 version " << SQLite::VERSION << " (" << SQLite::getLibVersion() << ")" << std::endl; + std::cout << "SQliteC++ version " << SQLITECPP_VERSION << std::endl; + + //////////////////////////////////////////////////////////////////////////// + // Very basic first example (1/7) : + try + { + // Open a database file in readonly mode + SQLite::Database db(filename_example_db3); // SQLite::OPEN_READONLY + std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; + + // Test if the 'test' table exists + const bool bExists = db.tableExists("test"); + std::cout << "SQLite table 'test' exists=" << bExists << "\n"; + + // Get a single value result with an easy to use shortcut + const std::string value = db.execAndGet("SELECT value FROM test WHERE id=2"); + std::cout << "execAndGet=" << value.c_str() << std::endl; + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + + //////////////////////////////////////////////////////////////////////////// + // Simple select query - few variations (2/7) : + try + { + // Open a database file in readonly mode + SQLite::Database db(filename_example_db3); // SQLite::OPEN_READONLY + std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; + + ///// a) Loop to get values of column by index, using auto cast to variable type + + // Compile a SQL query, containing one parameter (index 1) + SQLite::Statement query(db, "SELECT id as test_id, value as test_val, weight as test_weight FROM test WHERE weight > ?"); + std::cout << "SQLite statement '" << query.getQuery().c_str() << "' compiled (" << query.getColumnCount () << " columns in the result)\n"; + // Bind the integer value 2 to the first parameter of the SQL query + query.bind(1, 2); + std::cout << "binded with integer value '2' :\n"; + + // Loop to execute the query step by step, to get one a row of results at a time + while (query.executeStep()) + { + // Demonstrates how to get some typed column value (and the equivalent explicit call) + const int id = query.getColumn(0); // = query.getColumn(0).getInt(); + //const char* pvalue = query.getColumn(1); // = query.getColumn(1).getText(); + const std::string value = query.getColumn(1); // = query.getColumn(1).getText(); + const int bytes = query.getColumn(1).size(); // .getColumn(1).getBytes(); + const double weight = query.getColumn(2); // = query.getColumn(2).getInt(); + std::cout << "row (" << id << ", \"" << value.c_str() << "\"(" << bytes << ") " << weight << ")\n"; + } + + ///// b) Get aliased column names (and original column names if possible) + + // Reset the query to use it again + query.reset(); + std::cout << "SQLite statement '" << query.getQuery().c_str() << "' reseted (" << query.getColumnCount() << " columns in the result)\n"; + + // Show how to get the aliased names of the result columns. + const std::string name0 = query.getColumnName(0); + const std::string name1 = query.getColumnName(1); + const std::string name2 = query.getColumnName(2); + std::cout << "aliased result [\"" << name0.c_str() << "\", \"" << name1.c_str() << "\", \"" << name2.c_str() << "\"]\n"; + +#ifdef SQLITE_ENABLE_COLUMN_METADATA + // Show how to get origin names of the table columns from which theses result columns come from. + // Requires the SQLITE_ENABLE_COLUMN_METADATA preprocessor macro to be + // also defined at compile times of the SQLite library itself. + const std::string oname0 = query.getColumnOriginName(0); + const std::string oname1 = query.getColumnOriginName(1); + const std::string oname2 = query.getColumnOriginName(2); + std::cout << "origin table 'test' [\"" << oname0.c_str() << "\", \"" << oname1.c_str() << "\", \"" << oname2.c_str() << "\"]\n"; +#endif + // Loop to execute the query step by step, to get one a row of results at a time + while (query.executeStep()) + { + // Demonstrates that inserting column value in a std:ostream is natural + std::cout << "row (" << query.getColumn(0) << ", \"" << query.getColumn(1) << "\", " << query.getColumn(2) << ")\n"; + } + + ///// c) Get columns by name + + // Reset the query to use it again + query.reset(); + std::cout << "SQLite statement '" << query.getQuery().c_str() << "' reseted (" << query.getColumnCount() << " columns in the result)\n"; + + // Loop to execute the query step by step, to get one a row of results at a time + while (query.executeStep()) + { + // Demonstrates how to get column value by aliased name (not the original table names, see above) + const int id = query.getColumn("test_id"); + const std::string value = query.getColumn("test_val"); + const double weight = query.getColumn("test_weight"); + std::cout << "row (" << id << ", \"" << value.c_str() << "\" " << weight << ")\n"; + } + + ///// d) Uses explicit typed getters instead of auto cast operators + + // Reset the query to use it again + query.reset(); + std::cout << "SQLite statement '" << query.getQuery().c_str() << "' reseted (" << query.getColumnCount () << " columns in the result)\n"; + // Bind the string value "6" to the first parameter of the SQL query + query.bind(1, "6"); + std::cout << "binded with string value \"6\" :\n"; + // Reuses variables: uses assignement operator in the loop instead of constructor with initialization + int id = 0; + std::string value; + double weight = 0.0; + while (query.executeStep()) + { + id = query.getColumn(0).getInt(); + value = query.getColumn(1).getText(); + weight = query.getColumn(2).getInt(); + std::cout << "row (" << id << ", \"" << value << "\", " << weight << ")\n"; + } + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + + //////////////////////////////////////////////////////////////////////////// + // Object Oriented Basic example (3/7) : + try + { + // Open the database and compile the query + Example example; + + // Demonstrates the way to use the same query with different parameter values + example.ListGreaterThan(8); + example.ListGreaterThan(6); + example.ListGreaterThan(2); + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + + // The execAndGet wrapper example (4/7) : + try + { + // Open a database file in readonly mode + SQLite::Database db(filename_example_db3); // SQLite::OPEN_READONLY + std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; + + // WARNING: Be very careful with this dangerous method: you have to + // make a COPY OF THE result, else it will be destroy before the next line + // (when the underlying temporary Statement and Column objects are destroyed) + std::string value = db.execAndGet("SELECT value FROM test WHERE id=2"); + std::cout << "execAndGet=" << value.c_str() << std::endl; + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + + //////////////////////////////////////////////////////////////////////////// + // Simple batch queries example (5/7) : + try + { + // Open a database file in create/write mode + SQLite::Database db("test.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; + + // Create a new table with an explicit "id" column aliasing the underlying rowid + db.exec("DROP TABLE IF EXISTS test"); + db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); + + // first row + int nb = db.exec("INSERT INTO test VALUES (NULL, \"test\")"); + std::cout << "INSERT INTO test VALUES (NULL, \"test\")\", returned " << nb << std::endl; + + // second row + nb = db.exec("INSERT INTO test VALUES (NULL, \"second\")"); + std::cout << "INSERT INTO test VALUES (NULL, \"second\")\", returned " << nb << std::endl; + + // update the second row + nb = db.exec("UPDATE test SET value=\"second-updated\" WHERE id='2'"); + std::cout << "UPDATE test SET value=\"second-updated\" WHERE id='2', returned " << nb << std::endl; + + // Check the results : expect two row of result + SQLite::Statement query(db, "SELECT * FROM test"); + std::cout << "SELECT * FROM test :\n"; + while (query.executeStep()) + { + std::cout << "row (" << query.getColumn(0) << ", \"" << query.getColumn(1) << "\")\n"; + } + + db.exec("DROP TABLE test"); + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + remove("test.db3"); + + //////////////////////////////////////////////////////////////////////////// + // RAII transaction example (6/7) : + try + { + // Open a database file in create/write mode + SQLite::Database db("transaction.db3", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; + + db.exec("DROP TABLE IF EXISTS test"); + + // Exemple of a successful transaction : + try + { + // 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 << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + + // Exemple of a rollbacked transaction : + try + { + // Begin transaction + SQLite::Transaction transaction(db); + + int nb = db.exec("INSERT INTO test VALUES (NULL, \"second\")"); + std::cout << "INSERT INTO test VALUES (NULL, \"second\")\", returned " << nb << std::endl; + + nb = db.exec("INSERT INTO test ObviousError"); + std::cout << "INSERT INTO test \"error\", returned " << nb << std::endl; + + return EXIT_FAILURE; // we should never get there : exit the example program + + // Commit transaction + transaction.commit(); + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + // expected error, see above + } + + // Check the results (expect only one row of result, as the second one has been rollbacked by the error) + SQLite::Statement query(db, "SELECT * FROM test"); + std::cout << "SELECT * FROM test :\n"; + while (query.executeStep()) + { + std::cout << "row (" << query.getColumn(0) << ", \"" << query.getColumn(1) << "\")\n"; + } + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + remove("transaction.db3"); + + //////////////////////////////////////////////////////////////////////////// + // Binary blob and in-memory database example (7/7) : + try + { + // Open a database file in create/write mode + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + std::cout << "SQLite database file '" << db.getFilename().c_str() << "' opened successfully\n"; + + db.exec("DROP TABLE IF EXISTS test"); + db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value BLOB)"); + + FILE* fp = fopen(filename_logo_png.c_str(), "rb"); + if (NULL != fp) + { + char buffer[16*1024]; + void* blob = &buffer; + int size = static_cast(fread(blob, 1, 16*1024, fp)); + buffer[size] = '\0'; + fclose (fp); + std::cout << "blob size=" << size << " :\n"; + + // Insert query + SQLite::Statement query(db, "INSERT INTO test VALUES (NULL, ?)"); + // Bind the blob value to the first parameter of the SQL query + query.bind(1, blob, size); + std::cout << "blob binded successfully\n"; + + // Execute the one-step query to insert the blob + int nb = query.exec (); + std::cout << "INSERT INTO test VALUES (NULL, ?)\", returned " << nb << std::endl; + } + else + { + std::cout << "file " << filename_logo_png << " not found !\n"; + return EXIT_FAILURE; // unexpected error : exit the example program + } + + fp = fopen("out.png", "wb"); + if (NULL != fp) + { + const void* blob = NULL; + size_t size; + + SQLite::Statement query(db, "SELECT * FROM test"); + std::cout << "SELECT * FROM test :\n"; + if (query.executeStep()) + { + SQLite::Column colBlob = query.getColumn(1); + blob = colBlob.getBlob (); + size = colBlob.getBytes (); + std::cout << "row (" << query.getColumn(0) << ", size=" << size << ")\n"; + size_t sizew = fwrite(blob, 1, size, fp); + SQLITECPP_ASSERT(sizew == size, "fwrite failed"); // See SQLITECPP_ENABLE_ASSERT_HANDLER + fclose (fp); + } + } + else + { + std::cout << "file out.png not created !\n"; + return EXIT_FAILURE; // unexpected error : exit the example program + } + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } + remove("out.png"); + +#if (__cplusplus >= 201402L) || ( defined(_MSC_VER) && (_MSC_VER >= 1900) ) // c++14: Visual Studio 2015 + // example with C++14 variadic bind + try + { + // Open a database file in create/write mode + SQLite::Database db(":memory:", SQLite::OPEN_READWRITE|SQLite::OPEN_CREATE); + + db.exec("DROP TABLE IF EXISTS test"); + db.exec("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)"); + + { + SQLite::Statement query(db, "INSERT INTO test VALUES (?, ?)"); + + SQLite::bind(query, 42, "fortytwo"); + // Execute the one-step query to insert the blob + int nb = query.exec(); + std::cout << "INSERT INTO test VALUES (NULL, ?)\", returned " << nb << std::endl; + } + + SQLite::Statement query(db, "SELECT * FROM test"); + std::cout << "SELECT * FROM test :\n"; + if (query.executeStep()) + { + std::cout << query.getColumn(0).getInt() << "\t\"" << query.getColumn(1).getText() << "\"\n"; + } + } + catch (std::exception& e) + { + std::cout << "SQLite exception: " << e.what() << std::endl; + return EXIT_FAILURE; // unexpected error : exit the example program + } +#endif + + std::cout << "everything ok, quitting\n"; + + return EXIT_SUCCESS; +}