feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Sqlite: Improve Sqlite wrapper

Browse Source 
It is now possible to read values at once.

for (auto [name, value] : statement.tupleValues<String, int>(1000, "foo", 20))
   ....

Change-Id: I3d4bc5218810b4620e1df625126aa490f30bbc71
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
This commit is contained in:
Marco Bubke
2017-08-17 15:33:25 +02:00
parent 8617f497bc
commit 1a25b61576
24 changed files with 769 additions and 277 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
tests/unit/unittest/createtablesqlstatementbuilder-test.cpp
View File

@@ -30,6 +30,10 @@
namespace {
using Sqlite::ColumnType;
using Sqlite::Contraint;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Sqlite::SqliteColumn;
using Sqlite::SqliteColumns;
@@ -81,7 +85,7 @@ TEST_F(CreateTableSqlStatementBuilder, SqlStatement)
bindValues();
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");
"CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");
}
TEST_F(CreateTableSqlStatementBuilder, AddColumnToExistingColumns)
@@ -91,17 +95,17 @@ TEST_F(CreateTableSqlStatementBuilder, AddColumnToExistingColumns)
builder.addColumn("number2", ColumnType::Real);
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC, number2 REAL)");
"CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC, number2 REAL)");
}
TEST_F(CreateTableSqlStatementBuilder, ChangeTable)
{
bindValues();
builder.setTable("test2");
builder.setTableName("test2");
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test2(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)"
"CREATE TABLE test2(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)"
);
}
@@ -124,7 +128,7 @@ TEST_F(CreateTableSqlStatementBuilder, ClearColumnsAndAddColumnNewColumns)
builder.addColumn("number3", ColumnType::Real);
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test(name3 TEXT, number3 REAL)");
"CREATE TABLE test(name3 TEXT, number3 REAL)");
}
TEST_F(CreateTableSqlStatementBuilder, SetWitoutRowId)
@@ -134,25 +138,60 @@ TEST_F(CreateTableSqlStatementBuilder, SetWitoutRowId)
builder.setUseWithoutRowId(true);
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC) WITHOUT ROWID");
"CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC) WITHOUT ROWID");
}
TEST_F(CreateTableSqlStatementBuilder, SetColumnDefinitions)
{
builder.clear();
builder.setTable("test");
builder.setTableName("test");
builder.setColumns(createColumns());
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");
"CREATE TABLE test(id INTEGER PRIMARY KEY, name TEXT, number NUMERIC)");
}
TEST_F(CreateTableSqlStatementBuilder, UniqueContraint)
{
builder.clear();
builder.setTableName("test");
builder.addColumn("id", ColumnType::Integer, Contraint::Unique);
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE test(id INTEGER UNIQUE)");
}
TEST_F(CreateTableSqlStatementBuilder, IfNotExitsModifier)
{
builder.clear();
builder.setTableName("test");
builder.addColumn("id", ColumnType::Integer, Contraint::NoConstraint);
builder.setUseIfNotExists(true);
ASSERT_THAT(builder.sqlStatement(),
"CREATE TABLE IF NOT EXISTS test(id INTEGER)");
}
TEST_F(CreateTableSqlStatementBuilder, TemporaryTable)
{
builder.clear();
builder.setTableName("test");
builder.addColumn("id", ColumnType::Integer, Contraint::NoConstraint);
builder.setUseTemporaryTable(true);
ASSERT_THAT(builder.sqlStatement(),
"CREATE TEMPORARY TABLE test(id INTEGER)");
}
void CreateTableSqlStatementBuilder::bindValues()
{
builder.clear();
builder.setTable("test");
builder.addColumn("id", ColumnType::Integer, IsPrimaryKey::Yes);
builder.setTableName("test");
builder.addColumn("id", ColumnType::Integer, Contraint::PrimaryKey);
builder.addColumn("name", ColumnType::Text);
builder.addColumn("number",ColumnType:: Numeric);
}
@@ -160,7 +199,7 @@ void CreateTableSqlStatementBuilder::bindValues()
SqliteColumns CreateTableSqlStatementBuilder::createColumns()
{
SqliteColumns columns;
columns.emplace_back("id", ColumnType::Integer, IsPrimaryKey::Yes);
columns.emplace_back("id", ColumnType::Integer, Contraint::PrimaryKey);
columns.emplace_back("name", ColumnType::Text);
columns.emplace_back("number", ColumnType::Numeric);

16
tests/unit/unittest/sqlitecolumn-test.cpp
View File

@@ -33,6 +33,10 @@ using testing::AllOf;
using testing::Contains;
using testing::Property;
using Sqlite::ColumnType;
using Sqlite::Contraint;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Column = Sqlite::SqliteColumn;
using Sqlite::SqliteColumns;
@@ -63,16 +67,16 @@ TEST_F(SqliteColumn, ChangeType)
ASSERT_THAT(column.type(), ColumnType::Text);
}
TEST_F(SqliteColumn, DefaultPrimaryKey)
TEST_F(SqliteColumn, DefaultConstraint)
{
ASSERT_FALSE(column.isPrimaryKey());
ASSERT_THAT(column.constraint(), Contraint::NoConstraint);
}
TEST_F(SqliteColumn, SetPrimaryKey)
TEST_F(SqliteColumn, SetConstraint)
{
column.setIsPrimaryKey(IsPrimaryKey::Yes);
column.setContraint(Contraint::PrimaryKey);
ASSERT_TRUE(column.isPrimaryKey());
ASSERT_THAT(column.constraint(), Contraint::PrimaryKey);
}
TEST_F(SqliteColumn, GetColumnDefinition)
@@ -83,7 +87,7 @@ TEST_F(SqliteColumn, GetColumnDefinition)
AllOf(
Property(&Column::name, "Claudia"),
Property(&Column::type, ColumnType::Numeric),
Property(&Column::isPrimaryKey, false)));
Property(&Column::constraint, Contraint::NoConstraint)));
}
void SqliteColumn::SetUp()

3
tests/unit/unittest/sqlitedatabase-test.cpp
View File

@@ -38,6 +38,9 @@ namespace {
using testing::Contains;
using Sqlite::ColumnType;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Sqlite::SqliteTable;
class SqliteDatabase : public ::testing::Test

25
tests/unit/unittest/sqlitedatabasebackend-test.cpp
View File

@@ -38,6 +38,11 @@ namespace {
using Backend = Sqlite::SqliteDatabaseBackend;
using Sqlite::ColumnType;
using Sqlite::Contraint;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Sqlite::TextEncoding;
using Sqlite::SqliteException;
using Sqlite::SqliteWriteStatement;
@@ -106,35 +111,35 @@ TEST_F(SqliteDatabaseBackend, PersistJournalMode)
TEST_F(SqliteDatabaseBackend, DefaultTextEncoding)
{
ASSERT_THAT(databaseBackend.textEncoding(), Utf8);
ASSERT_THAT(databaseBackend.textEncoding(), TextEncoding::Utf8);
}
TEST_F(SqliteDatabaseBackend, Utf16TextEncoding)
{
databaseBackend.setTextEncoding(Utf16);
databaseBackend.setTextEncoding(TextEncoding::Utf16);
ASSERT_THAT(databaseBackend.textEncoding(), Utf16);
ASSERT_THAT(databaseBackend.textEncoding(), TextEncoding::Utf16);
}
TEST_F(SqliteDatabaseBackend, Utf16beTextEncoding)
{
databaseBackend.setTextEncoding(Utf16be);
databaseBackend.setTextEncoding(TextEncoding::Utf16be);
ASSERT_THAT(databaseBackend.textEncoding(), Utf16be);
ASSERT_THAT(databaseBackend.textEncoding(),TextEncoding::Utf16be);
}
TEST_F(SqliteDatabaseBackend, Utf16leTextEncoding)
{
databaseBackend.setTextEncoding(Utf16le);
databaseBackend.setTextEncoding(TextEncoding::Utf16le);
ASSERT_THAT(databaseBackend.textEncoding(), Utf16le);
ASSERT_THAT(databaseBackend.textEncoding(), TextEncoding::Utf16le);
}
TEST_F(SqliteDatabaseBackend, Utf8TextEncoding)
{
databaseBackend.setTextEncoding(Utf8);
databaseBackend.setTextEncoding(TextEncoding::Utf8);
ASSERT_THAT(databaseBackend.textEncoding(), Utf8);
ASSERT_THAT(databaseBackend.textEncoding(), TextEncoding::Utf8);
}
TEST_F(SqliteDatabaseBackend, TextEncodingCannotBeChangedAfterTouchingDatabase)
@@ -143,7 +148,7 @@ TEST_F(SqliteDatabaseBackend, TextEncodingCannotBeChangedAfterTouchingDatabase)
databaseBackend.execute("CREATE TABLE text(name, number)");
ASSERT_THROW(databaseBackend.setTextEncoding(Utf16), SqliteException);
ASSERT_THROW(databaseBackend.setTextEncoding(TextEncoding::Utf16), SqliteException);
}
TEST_F(SqliteDatabaseBackend, OpenModeReadOnly)

209
tests/unit/unittest/sqlitestatement-test.cpp
View File

@@ -30,14 +30,15 @@
#include <sqlitereadwritestatement.h>
#include <sqlitewritestatement.h>
#include <utils/smallstringio.h>
#include <QDir>
#include <vector>
namespace {
using testing::ElementsAre;
using testing::PrintToString;
using Sqlite::JournalMode;
using Sqlite::SqliteException;
using Sqlite::SqliteDatabase;
using Sqlite::SqliteReadStatement;
@@ -71,6 +72,21 @@ protected:
SqliteDatabase database;
};
struct Output
{
Utils::SmallString name;
Utils::SmallString number;
long long value;
friend bool operator==(const Output &f, const Output &s)
{
return f.name == s.name && f.number == s.number && f.value == s.value;
}
friend std::ostream &operator<<(std::ostream &out, const Output &o)
{
return out << "(" << o.name << ", " << ", " << o.number<< ", " << o.value<< ")";
}
};
TEST_F(SqliteStatement, PrepareFailure)
{
ASSERT_THROW(SqliteReadStatement("blah blah blah", database), SqliteException);
@@ -99,11 +115,11 @@ TEST_F(SqliteStatement, Value)
statement.next();
ASSERT_THAT(statement.value<int>(0), 0);
ASSERT_THAT(statement.value<qint64>(0), 0);
ASSERT_THAT(statement.value<int64_t>(0), 0);
ASSERT_THAT(statement.value<double>(0), 0.0);
ASSERT_THAT(statement.text(0), "foo");
ASSERT_THAT(statement.value<int>(1), 23);
ASSERT_THAT(statement.value<qint64>(1), 23);
ASSERT_THAT(statement.value<int64_t>(1), 23);
ASSERT_THAT(statement.value<double>(1), 23.3);
ASSERT_THAT(statement.text(1), "23.3");
}
@@ -127,12 +143,14 @@ TEST_F(SqliteStatement, ValueFailure)
TEST_F(SqliteStatement, ToIntergerValue)
{
ASSERT_THAT(SqliteReadStatement::toValue<int>("SELECT number FROM test WHERE name='foo'", database), 23);
auto value = SqliteReadStatement::toValue<int>("SELECT number FROM test WHERE name='foo'", database);
ASSERT_THAT(value, 23);
}
TEST_F(SqliteStatement, ToLongIntergerValue)
{
ASSERT_THAT(SqliteReadStatement::toValue<qint64>("SELECT number FROM test WHERE name='foo'", database), 23LL);
ASSERT_THAT(SqliteReadStatement::toValue<qint64>("SELECT number FROM test WHERE name='foo'", database), Eq(23));
}
TEST_F(SqliteStatement, ToDoubleValue)
@@ -145,31 +163,6 @@ TEST_F(SqliteStatement, ToStringValue)
ASSERT_THAT(SqliteReadStatement::toValue<Utils::SmallString>("SELECT name FROM test WHERE name='foo'", database), "foo");
}
TEST_F(SqliteStatement, Utf8Values)
{
SqliteReadStatement statement("SELECT name, number FROM test ORDER by name", database);
auto values = statement.values<Utils::SmallStringVector>();
ASSERT_THAT(values, ElementsAre("bar", "foo", "poo"));
}
TEST_F(SqliteStatement, DoubleValues)
{
SqliteReadStatement statement("SELECT name, number FROM test ORDER by name", database);
auto values = statement.values<std::vector<double>>(1);
ASSERT_THAT(values, ElementsAre(0.0, 23.3, 40.0));
}
TEST_F(SqliteStatement, ValuesFailure)
{
SqliteReadStatement statement("SELECT name, number FROM test", database);
ASSERT_THROW(statement.values<Utils::SmallStringVector>({1, 2}), SqliteException);
ASSERT_THROW(statement.values<Utils::SmallStringVector>({-1, 1}), SqliteException);
}
TEST_F(SqliteStatement, ColumnNames)
{
SqliteReadStatement statement("SELECT name, number FROM test", database);
@@ -206,7 +199,7 @@ TEST_F(SqliteStatement, BindLongInteger)
{
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
statement.bind(1, qint64(40));
statement.bind(1, int64_t(40));
statement.next();
ASSERT_THAT(statement.text(0), "poo");
@@ -236,7 +229,7 @@ TEST_F(SqliteStatement, BindLongIntegerByParameter)
{
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=@number", database);
statement.bind("@number", qint64(40));
statement.bind("@number", int64_t(40));
statement.next();
ASSERT_THAT(statement.text(0), "poo");
@@ -315,14 +308,156 @@ TEST_F(SqliteStatement, ClosedDatabase)
database.open(QDir::tempPath() + QStringLiteral("/SqliteStatementTest.db"));
}
TEST_F(SqliteStatement, GetTupleValuesWithoutArguments)
{
using Tuple = std::tuple<Utils::SmallString, double, int>;
SqliteReadStatement statement("SELECT name, number, value FROM test", database);
auto values = statement.tupleValues<Utils::SmallString, double, int>(3);
ASSERT_THAT(values, ElementsAre(Tuple{"bar", 0, 1},
Tuple{"foo", 23.3, 2},
Tuple{"poo", 40.0, 3}));
}
TEST_F(SqliteStatement, GetSingleValuesWithoutArguments)
{
SqliteReadStatement statement("SELECT name FROM test", database);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3);
ASSERT_THAT(values, ElementsAre("bar", "foo", "poo"));
}
TEST_F(SqliteStatement, GetStructValuesWithoutArguments)
{
SqliteReadStatement statement("SELECT name, number, value FROM test", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3);
ASSERT_THAT(values, ElementsAre(Output{"bar", "blah", 1},
Output{"foo", "23.3", 2},
Output{"poo", "40", 3}));
}
TEST_F(SqliteStatement, GetValuesForSingleOutputWithBindingMultipleTimes)
{
SqliteReadStatement statement("SELECT name FROM test WHERE number=?", database);
statement.values<Utils::SmallString>(3, 40);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, 40);
ASSERT_THAT(values, ElementsAre("poo"));
}
TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryValues)
{
using Tuple = std::tuple<Utils::SmallString, double, double>;
std::vector<double> queryValues = {40, 23.3};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database);
auto values = statement.tupleValues<Utils::SmallString, double, double>(3, queryValues);
ASSERT_THAT(values, ElementsAre(Tuple{"poo", 40, 3.},
Tuple{"foo", 23.3, 2.}));
}
TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryValues)
{
std::vector<double> queryValues = {40, 23.3};
SqliteReadStatement statement("SELECT name, number FROM test WHERE number=?", database);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, queryValues);
ASSERT_THAT(values, ElementsAre("poo", "foo"));
}
TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryTupleValues)
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>;
using Tuple2 = std::tuple<Utils::SmallString, double, int>;
std::vector<Tuple> queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database);
auto values = statement.tupleValues<Utils::SmallString, double, int>(3, queryValues);
ASSERT_THAT(values, ElementsAre(Tuple2{"poo", 40, 3},
Tuple2{"bar", 0, 1}));
}
TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryTupleValues)
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString>;
std::vector<Tuple> queryValues = {{"poo", "40"}, {"bar", "blah"}};
SqliteReadStatement statement("SELECT name, number FROM test WHERE name= ? AND number=?", database);
std::vector<Utils::SmallString> values = statement.values<Utils::SmallString>(3, queryValues);
ASSERT_THAT(values, ElementsAre("poo", "bar"));
}
TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue)
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, long long>;
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database);
auto values = statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah", 1);
ASSERT_THAT(values, ElementsAre(Tuple{"bar", "blah", 1}));
}
TEST_F(SqliteStatement, CallGetValuesForMultipleOutputValuesAndMultipleQueryValueMultipleTimes)
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, long long>;
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=?", database);
statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah");
auto values = statement.tupleValues<Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah");
ASSERT_THAT(values, ElementsAre(Tuple{"bar", "blah", 1}));
}
TEST_F(SqliteStatement, GetStructOutputValuesAndMultipleQueryValue)
{
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, "bar", "blah", 1);
ASSERT_THAT(values, ElementsAre(Output{"bar", "blah", 1}));
}
TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryValues)
{
std::vector<double> queryValues = {40, 23.3};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, queryValues);
ASSERT_THAT(values, ElementsAre(Output{"poo", "40", 3},
Output{"foo", "23.3", 2}));
}
TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryTupleValues)
{
using Tuple = std::tuple<Utils::SmallString, Utils::SmallString, int>;
std::vector<Tuple> queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}};
SqliteReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database);
auto values = statement.structValues<Output, Utils::SmallString, Utils::SmallString, long long>(3, queryValues);
ASSERT_THAT(values, ElementsAre(Output{"poo", "40", 3},
Output{"bar", "blah", 1}));
}
void SqliteStatement::SetUp()
{
database.setJournalMode(JournalMode::Memory);
database.open(":memory:");
database.execute("CREATE TABLE test(name TEXT UNIQUE, number NUMERIC)");
database.execute("INSERT INTO test VALUES ('bar', 'blah')");
database.execute("INSERT INTO test VALUES ('foo', 23.3)");
database.execute("INSERT INTO test VALUES ('poo', 40)");
database.execute("CREATE TABLE test(name TEXT UNIQUE, number NUMERIC, value NUMERIC)");
database.execute("INSERT INTO test VALUES ('bar', 'blah', 1)");
database.execute("INSERT INTO test VALUES ('foo', 23.3, 2)");
database.execute("INSERT INTO test VALUES ('poo', 40, 3)");
}
void SqliteStatement::TearDown()

3
tests/unit/unittest/sqlitetable-test.cpp
View File

@@ -32,6 +32,9 @@
namespace {
using Sqlite::ColumnType;
using Sqlite::JournalMode;
using Sqlite::OpenMode;
using Sqlite::SqliteColumn;
using Sqlite::SqliteDatabase;

1
tests/unit/unittest/sqlstatementbuilder-test.cpp
View File

@@ -30,6 +30,7 @@
using namespace ::testing;
using Sqlite::ColumnType;
using Sqlite::SqlStatementBuilder;
using Sqlite::SqlStatementBuilderException;