From ed2ae5fa81adb554e0c74d513edbcd99ee377a2c Mon Sep 17 00:00:00 2001 From: Marco Bubke Date: Thu, 21 Sep 2017 11:43:24 +0200 Subject: [PATCH] Sqlite: Improve SqliteStatement There are now only value and values methods. value returns an optional and values are returning a vector. The result value count has now be specified instead of the result value list. Change-Id: I17a0741d5e838b4bf4b9486825c870ada1722584 Reviewed-by: Tim Jenssen --- src/libs/sqlite/sqlitedatabasebackend.cpp | 2 +- src/libs/sqlite/sqlitereadstatement.h | 3 +- src/libs/sqlite/sqlitereadwritestatement.h | 3 +- src/libs/sqlite/sqlitestatement.cpp | 54 +++- src/libs/sqlite/sqlitestatement.h | 285 ++++++------------ .../clangrefactoring/sourcelocations.h | 21 +- src/plugins/clangrefactoring/symbolquery.h | 4 +- .../unit/unittest/mocksqlitereadstatement.cpp | 49 +-- tests/unit/unittest/mocksqlitereadstatement.h | 31 +- tests/unit/unittest/sqlitestatement-test.cpp | 81 +++-- tests/unit/unittest/sqliteteststatement.h | 2 +- tests/unit/unittest/symbolquery-test.cpp | 4 +- 12 files changed, 250 insertions(+), 289 deletions(-) diff --git a/src/libs/sqlite/sqlitedatabasebackend.cpp b/src/libs/sqlite/sqlitedatabasebackend.cpp index e50b07aac25..5c4fc95e732 100644 --- a/src/libs/sqlite/sqlitedatabasebackend.cpp +++ b/src/libs/sqlite/sqlitedatabasebackend.cpp @@ -420,7 +420,7 @@ Type DatabaseBackend::toValue(Utils::SmallStringView sqlStatement) statement.next(); - return statement.value(0); + return statement.fetchValue(0); } } // namespace Sqlite diff --git a/src/libs/sqlite/sqlitereadstatement.h b/src/libs/sqlite/sqlitereadstatement.h index 1fddb3afce2..828d1f7c377 100644 --- a/src/libs/sqlite/sqlitereadstatement.h +++ b/src/libs/sqlite/sqlitereadstatement.h @@ -34,8 +34,7 @@ class SQLITE_EXPORT ReadStatement final : private Statement public: explicit ReadStatement(Utils::SmallStringView sqlStatement, Database &database); - using Statement::structValues; - using Statement::tupleValues; + using Statement::value; using Statement::values; using Statement::toValue; using Statement::database; diff --git a/src/libs/sqlite/sqlitereadwritestatement.h b/src/libs/sqlite/sqlitereadwritestatement.h index 8c8d2541984..8645a6eae8a 100644 --- a/src/libs/sqlite/sqlitereadwritestatement.h +++ b/src/libs/sqlite/sqlitereadwritestatement.h @@ -37,9 +37,8 @@ public: ReadWriteStatement(Utils::SmallStringView sqlStatement, Database &database); using Statement::execute; + using Statement::value; using Statement::values; - using Statement::structValues; - using Statement::tupleValues; using Statement::toValue; using Statement::database; using Statement::write; diff --git a/src/libs/sqlite/sqlitestatement.cpp b/src/libs/sqlite/sqlitestatement.cpp index ba64f44a398..0e70b5aaca6 100644 --- a/src/libs/sqlite/sqlitestatement.cpp +++ b/src/libs/sqlite/sqlitestatement.cpp @@ -445,8 +445,7 @@ static StringType convertToTextForColumn(sqlite3_stmt *sqlStatment, int column) Q_UNREACHABLE(); } -template<> -int Statement::value(int column) const +int Statement::fetchIntValue(int column) const { checkIfIsReadyToFetchValues(); checkColumnIsValid(column); @@ -454,13 +453,23 @@ int Statement::value(int column) const } template<> -long Statement::value(int column) const +int Statement::fetchValue(int column) const { - return long(value(column)); + return fetchIntValue(column); +} + +long Statement::fetchLongValue(int column) const +{ + return long(fetchValue(column)); } template<> -long long Statement::value(int column) const +long Statement::fetchValue(int column) const +{ + return fetchLongValue(column); +} + +long long Statement::fetchLongLongValue(int column) const { checkIfIsReadyToFetchValues(); checkColumnIsValid(column); @@ -468,27 +477,48 @@ long long Statement::value(int column) const } template<> -double Statement::value(int column) const +long long Statement::fetchValue(int column) const +{ + return fetchLongLongValue(column); +} + +double Statement::fetchDoubleValue(int column) const { checkIfIsReadyToFetchValues(); checkColumnIsValid(column); return sqlite3_column_double(m_compiledStatement.get(), column); } +template<> +double Statement::fetchValue(int column) const +{ + return fetchDoubleValue(column); +} + template -StringType Statement::value(int column) const +StringType Statement::fetchValue(int column) const { checkIfIsReadyToFetchValues(); checkColumnIsValid(column); return convertToTextForColumn(m_compiledStatement.get(), column); } -template SQLITE_EXPORT Utils::SmallString Statement::value(int column) const; -template SQLITE_EXPORT Utils::PathString Statement::value(int column) const; +Utils::SmallString Statement::fetchSmallStringValue(int column) const +{ + return fetchValue(column); +} + +Utils::PathString Statement::fetchPathStringValue(int column) const +{ + return fetchValue(column); +} + +template SQLITE_EXPORT Utils::SmallString Statement::fetchValue(int column) const; +template SQLITE_EXPORT Utils::PathString Statement::fetchValue(int column) const; Utils::SmallString Statement::text(int column) const { - return value(column); + return fetchValue(column); } template @@ -498,7 +528,7 @@ ContainerType Statement::columnValues(const std::vector &columnIndices) con ContainerType valueContainer; valueContainer.reserve(columnIndices.size()); for (int columnIndex : columnIndices) - valueContainer.push_back(value(columnIndex)); + valueContainer.push_back(fetchValue(columnIndex)); return valueContainer; } @@ -510,7 +540,7 @@ Type Statement::toValue(Utils::SmallStringView sqlStatement, Database &database) statement.next(); - return statement.value(0); + return statement.fetchValue(0); } template SQLITE_EXPORT int Statement::toValue(Utils::SmallStringView sqlStatement, Database &database); diff --git a/src/libs/sqlite/sqlitestatement.h b/src/libs/sqlite/sqlitestatement.h index 6c3848e6798..3e93b7ba8d6 100644 --- a/src/libs/sqlite/sqlitestatement.h +++ b/src/libs/sqlite/sqlitestatement.h @@ -31,6 +31,8 @@ #include +#include + #include #include #include @@ -58,16 +60,22 @@ protected: void execute() const; void reset() const; + int fetchIntValue(int column) const; + long fetchLongValue(int column) const; + long long fetchLongLongValue(int column) const; + double fetchDoubleValue(int column) const; + Utils::SmallString fetchSmallStringValue(int column) const; + Utils::PathString fetchPathStringValue(int column) const; template - Type value(int column) const; + Type fetchValue(int column) const; Utils::SmallString text(int column) const; int columnCount() const; Utils::SmallStringVector columnNames() const; - void bind(int index, int value); - void bind(int index, long long value); - void bind(int index, double value); - void bind(int index, Utils::SmallStringView value); + void bind(int index, int fetchValue); + void bind(int index, long long fetchValue); + void bind(int index, double fetchValue); + void bind(int index, Utils::SmallStringView fetchValue); void bind(int index, uint value) { @@ -110,138 +118,60 @@ protected: } template - void bind(Utils::SmallStringView name, Type value); + void bind(Utils::SmallStringView name, Type fetchValue); int bindingIndexForName(Utils::SmallStringView name) const; void setBindingColumnNames(const Utils::SmallStringVector &bindingColumnNames); const Utils::SmallStringVector &bindingColumnNames() const; - template - std::vector> tupleValues(std::size_t reserveSize) + template + std::vector values(std::size_t reserveSize) { - using Container = std::vector>; - Container resultValues; + std::vector resultValues; resultValues.reserve(reserveSize); while (next()) - emplaceTupleValues(resultValues); + emplaceBackValues(resultValues); reset(); return resultValues; } - template - std::vector> tupleValues(std::size_t reserveSize, const QueryTypes&... queryValues) + std::vector values(std::size_t reserveSize, const QueryTypes&... queryValues) { - using Container = std::vector>; - Container resultValues; + std::vector resultValues; resultValues.reserve(reserveSize); bindValues(queryValues...); while (next()) - emplaceTupleValues(resultValues); + emplaceBackValues(resultValues); reset(); return resultValues; } - template - std::vector> tupleValues(std::size_t reserveSize, - const std::vector> &queryTuples) - { - using Container = std::vector>; - Container resultValues; - resultValues.reserve(reserveSize); - - for (const auto &queryTuple : queryTuples) { - bindTupleValues(queryTuple); - - while (next()) - emplaceTupleValues(resultValues); - - reset(); - } - - return resultValues; - } - - template - std::vector> tupleValues(std::size_t reserveSize, - const std::vector &queryValues) - { - using Container = std::vector>; - Container resultValues; - resultValues.reserve(reserveSize); - - for (const QueryElementType &queryValue : queryValues) { - bindValues(queryValue); - - while (next()) - emplaceTupleValues(resultValues); - - reset(); - } - - return resultValues; - } - - template - std::vector structValues(std::size_t reserveSize) - { - using Container = std::vector; - Container resultValues; - resultValues.reserve(reserveSize); - - while (next()) - pushBackStructValues(resultValues); - - reset(); - - return resultValues; - } - - template - std::vector structValues(std::size_t reserveSize, const QueryTypes&... queryValues) - { - using Container = std::vector; - Container resultValues; - resultValues.reserve(reserveSize); - - bindValues(queryValues...); - - while (next()) - pushBackStructValues(resultValues); - - reset(); - - return resultValues; - } - - template - std::vector structValues(std::size_t reserveSize, + std::vector values(std::size_t reserveSize, const std::vector &queryValues) { - using Container = std::vector; - Container resultValues; + std::vector resultValues; resultValues.reserve(reserveSize); for (const QueryElementType &queryValue : queryValues) { bindValues(queryValue); while (next()) - pushBackStructValues(resultValues); + emplaceBackValues(resultValues); reset(); } @@ -250,9 +180,9 @@ protected: } template - std::vector structValues(std::size_t reserveSize, + std::vector values(std::size_t reserveSize, const std::vector> &queryTuples) { using Container = std::vector; @@ -263,62 +193,7 @@ protected: bindTupleValues(queryTuple); while (next()) - pushBackStructValues(resultValues); - - reset(); - } - - return resultValues; - } - - template - std::vector values(std::size_t reserveSize) - { - std::vector resultValues; - resultValues.reserve(reserveSize); - - while (next()) - resultValues.push_back(value(0)); - - reset(); - - return resultValues; - } - - template - std::vector values(std::size_t reserveSize, - const std::vector> &queryTuples) - { - std::vector resultValues; - resultValues.reserve(reserveSize); - - for (const auto &queryTuple : queryTuples) { - bindTupleValues(queryTuple); - - while (next()) - resultValues.push_back(value(0)); - - reset(); - } - - return resultValues; - } - - template - std::vector values(std::size_t reserveSize, - const std::vector &queryValues) - { - std::vector resultValues; - resultValues.reserve(reserveSize); - - for (const ElementType &queryValue : queryValues) { - bindValues(queryValue); - - while (next()) - resultValues.push_back(value(0)); + emplaceBackValues(resultValues); reset(); } @@ -327,20 +202,20 @@ protected: } template - std::vector values(std::size_t reserveSize, const QueryTypes&... queryValues) + Utils::optional value( const QueryTypes&... queryValues) { - std::vector resultValues; - resultValues.reserve(reserveSize); + Utils::optional resultValue; bindValues(queryValues...); - while (next()) - resultValues.push_back(value(0)); + if (next()) + resultValue = assignValue, ResultTypeCount>(); reset(); - return resultValues; + return resultValue; } template @@ -352,7 +227,6 @@ protected: sqlite3 *sqliteDatabaseHandle() const; TextEncoding databaseTextEncoding(); - bool checkForStepError(int resultCode) const; void checkForPrepareError(int resultCode) const; void checkForBindingError(int resultCode) const; @@ -388,35 +262,74 @@ protected: DatabaseBackend &databaseBackend); private: + class ValueGetter + { + public: + ValueGetter(Statement &statement, int column) + : statement(statement), + column(column) + {} + + operator int() + { + return statement.fetchIntValue(column); + } + + operator long() + { + return statement.fetchLongValue(column); + } + + operator long long() + { + return statement.fetchLongLongValue(column); + } + + operator double() + { + return statement.fetchDoubleValue(column); + } + + operator Utils::SmallString() + { + return statement.fetchSmallStringValue(column); + } + + operator Utils::PathString() + { + return statement.fetchPathStringValue(column); + } + + Statement &statement; + int column; + }; + template - void emplaceTupleValues(ContainerType &container, std::integer_sequence) + void emplaceBackValues(ContainerType &container, std::integer_sequence) { - container.emplace_back(value(ColumnIndices)...); + container.emplace_back(ValueGetter(*this, ColumnIndices)...); } - template - void emplaceTupleValues(ContainerType &container) + template + void emplaceBackValues(ContainerType &container) { - emplaceTupleValues(container, std::make_integer_sequence{}); + emplaceBackValues(container, std::make_integer_sequence{}); } - template - void pushBackStructValues(ContainerType &container, std::integer_sequence) + ResultOptionalType assignValue(std::integer_sequence) { - using ResultType = typename ContainerType::value_type; - container.push_back(ResultType{value(ColumnIndices)...}); + return ResultOptionalType(Utils::in_place, ValueGetter(*this, ColumnIndices)...); } - template - void pushBackStructValues(ContainerType &container) + template + ResultOptionalType assignValue() { - pushBackStructValues(container, std::make_integer_sequence{}); + return assignValue(std::make_integer_sequence{}); } template @@ -478,10 +391,10 @@ extern template SQLITE_EXPORT long long Statement::toValue(Utils::Sma extern template SQLITE_EXPORT double Statement::toValue(Utils::SmallStringView sqlStatement, Database &database); extern template SQLITE_EXPORT Utils::SmallString Statement::toValue(Utils::SmallStringView sqlStatement, Database &database); -template <> SQLITE_EXPORT int Statement::value(int column) const; -template <> SQLITE_EXPORT long Statement::value(int column) const; -template <> SQLITE_EXPORT long long Statement::value(int column) const; -template <> SQLITE_EXPORT double Statement::value(int column) const; -extern template SQLITE_EXPORT Utils::SmallString Statement::value(int column) const; -extern template SQLITE_EXPORT Utils::PathString Statement::value(int column) const; +template <> SQLITE_EXPORT int Statement::fetchValue(int column) const; +template <> SQLITE_EXPORT long Statement::fetchValue(int column) const; +template <> SQLITE_EXPORT long long Statement::fetchValue(int column) const; +template <> SQLITE_EXPORT double Statement::fetchValue(int column) const; +extern template SQLITE_EXPORT Utils::SmallString Statement::fetchValue(int column) const; +extern template SQLITE_EXPORT Utils::PathString Statement::fetchValue(int column) const; } // namespace Sqlite diff --git a/src/plugins/clangrefactoring/sourcelocations.h b/src/plugins/clangrefactoring/sourcelocations.h index fe2d3dace94..9ae4241c01a 100644 --- a/src/plugins/clangrefactoring/sourcelocations.h +++ b/src/plugins/clangrefactoring/sourcelocations.h @@ -39,24 +39,25 @@ class SourceLocations public: struct Location { - qint64 sourceId; - qint64 line; - qint64 column; + Location(qint64 sourceId, qint64 line, qint64 column) + : sourceId(sourceId), line(line), column(column) + {} + + qint64 sourceId; + qint64 line; + qint64 column; }; struct Source { + Source(qint64 sourceId, Utils::PathString &&sourcePath) + : sourceId(sourceId), sourcePath(std::move(sourcePath)) + {} + qint64 sourceId; Utils::PathString sourcePath; }; - enum LocationGetter - { - SourceId = 0, - Line, - Column - }; - std::vector locations; std::unordered_map sources; }; diff --git a/src/plugins/clangrefactoring/symbolquery.h b/src/plugins/clangrefactoring/symbolquery.h index 778156410a4..19faf972294 100644 --- a/src/plugins/clangrefactoring/symbolquery.h +++ b/src/plugins/clangrefactoring/symbolquery.h @@ -52,7 +52,7 @@ public: const std::size_t reserveSize = 128; - auto locations = locationsStatement.template structValues( + auto locations = locationsStatement.template values( reserveSize, filePath, line, @@ -62,7 +62,7 @@ public: ReadStatement &sourcesStatement = m_statementFactory.selectSourcePathForId; - auto sources = sourcesStatement.template structValues( + auto sources = sourcesStatement.template values( reserveSize, sourceIds); diff --git a/tests/unit/unittest/mocksqlitereadstatement.cpp b/tests/unit/unittest/mocksqlitereadstatement.cpp index 862742aedd9..386424386f9 100644 --- a/tests/unit/unittest/mocksqlitereadstatement.cpp +++ b/tests/unit/unittest/mocksqlitereadstatement.cpp @@ -25,31 +25,6 @@ #include "mocksqlitereadstatement.h" -template -std::vector values(std::size_t, QueryType...) -{ - FAIL() << "MockSqliteReadStatement::value was instanciated implicitly. Please add an explicit overload."; -} - -template -std::vector> values(std::size_t, - Utils::SmallStringView, - uint, - uint) -{ - FAIL() << "MockSqliteReadStatement::value was instanciated implicitly. Please add an explicit overload."; -} - -template class ContainerType, - typename ElementType> -std::vector> tupleValues(std::size_t, - const ContainerType &) -{ - FAIL() << "MockSqliteReadStatement::value was instanciated implicitly. Please add an explicit overload."; -} - template <> std::vector MockSqliteReadStatement::values(std::size_t reserveSize) { @@ -58,20 +33,24 @@ std::vector MockSqliteReadStatement::values(std::s template <> std::vector -MockSqliteReadStatement::structValues( - std::size_t reserveSize, - const Utils::PathString &sourcePath, - const uint &line, - const uint &column) +MockSqliteReadStatement::values(std::size_t reserveSize, + const Utils::PathString &sourcePath, + const uint &line, + const uint &column) { - return structValuesReturnStdVectorLocation(reserveSize, sourcePath, line, column); + return valuesReturnStdVectorLocation(reserveSize, sourcePath, line, column); } template <> std::vector -MockSqliteReadStatement::structValues( - std::size_t reserveSize, - const std::vector &sourceIds) +MockSqliteReadStatement::values(std::size_t reserveSize, const std::vector &sourceIds) { - return structValuesReturnStdVectorSource(reserveSize, sourceIds); + return valuesReturnStdVectorSource(reserveSize, sourceIds); +} + +template <> +Utils::optional +MockSqliteReadStatement::value(const Utils::SmallStringView &text) +{ + return valueReturnUInt32(text); } diff --git a/tests/unit/unittest/mocksqlitereadstatement.h b/tests/unit/unittest/mocksqlitereadstatement.h index f5b88c84673..b97ab1dc7d2 100644 --- a/tests/unit/unittest/mocksqlitereadstatement.h +++ b/tests/unit/unittest/mocksqlitereadstatement.h @@ -31,6 +31,7 @@ #include "mocksqlitedatabase.h" +#include #include #include @@ -53,28 +54,31 @@ public: MOCK_CONST_METHOD1(valuesReturnStdVectorInt, std::vector(std::size_t)); - MOCK_CONST_METHOD4(structValuesReturnStdVectorLocation, + MOCK_CONST_METHOD4(valuesReturnStdVectorLocation, std::vector(std::size_t, Utils::SmallStringView, qint64, qint64)); - MOCK_CONST_METHOD2(structValuesReturnStdVectorSource, + MOCK_CONST_METHOD2(valuesReturnStdVectorSource, std::vector(std::size_t, const std::vector &)); - template - std::vector values(std::size_t, QueryType...); + MOCK_CONST_METHOD1(valueReturnUInt32, + Utils::optional(Utils::SmallStringView)); + template - std::vector structValues(std::size_t reserveSize, const QueryType&... queryValues); + std::vector values(std::size_t reserveSize, const QueryType&... queryValues); template class QueryContainerType, typename QueryElementType> - std::vector structValues(std::size_t reserveSize, - const QueryContainerType &queryValues); + std::vector values(std::size_t reserveSize, + const QueryContainerType &queryValues); + template + Utils::optional value(const QueryTypes&... queryValues); public: Utils::SmallString sqlStatement; @@ -85,7 +89,7 @@ std::vector MockSqliteReadStatement::values(std::size_t reserveSize); template <> std::vector -MockSqliteReadStatement::structValues( +MockSqliteReadStatement::values( std::size_t reserveSize, const Utils::PathString &sourcePath, const uint &line, @@ -93,8 +97,11 @@ MockSqliteReadStatement::structValues( template <> std::vector -MockSqliteReadStatement::structValues( +MockSqliteReadStatement::values( std::size_t reserveSize, const std::vector &); +template <> +Utils::optional +MockSqliteReadStatement::value(const Utils::SmallStringView&); diff --git a/tests/unit/unittest/sqlitestatement-test.cpp b/tests/unit/unittest/sqlitestatement-test.cpp index 54be7bd0be9..30ea9cbca84 100644 --- a/tests/unit/unittest/sqlitestatement-test.cpp +++ b/tests/unit/unittest/sqlitestatement-test.cpp @@ -75,6 +75,10 @@ protected: struct Output { + Output(Utils::SmallString name, Utils::SmallString number, long long value) + : name(name), number(number), value(value) + {} + Utils::SmallString name; Utils::SmallString number; long long value; @@ -124,13 +128,13 @@ TEST_F(SqliteStatement, Value) statement.next(); - ASSERT_THAT(statement.value(0), 0); - ASSERT_THAT(statement.value(0), 0); - ASSERT_THAT(statement.value(0), 0.0); + ASSERT_THAT(statement.fetchValue(0), 0); + ASSERT_THAT(statement.fetchValue(0), 0); + ASSERT_THAT(statement.fetchValue(0), 0.0); ASSERT_THAT(statement.text(0), "foo"); - ASSERT_THAT(statement.value(1), 23); - ASSERT_THAT(statement.value(1), 23); - ASSERT_THAT(statement.value(1), 23.3); + ASSERT_THAT(statement.fetchValue(1), 23); + ASSERT_THAT(statement.fetchValue(1), 23); + ASSERT_THAT(statement.fetchValue(1), 23.3); ASSERT_THAT(statement.text(1), "23.3"); } @@ -138,7 +142,7 @@ TEST_F(SqliteStatement, ThrowNoValuesToFetchForNotSteppedStatement) { SqliteTestStatement statement("SELECT name, number FROM test", database); - ASSERT_THROW(statement.value(0), Sqlite::NoValuesToFetch); + ASSERT_THROW(statement.fetchValue(0), Sqlite::NoValuesToFetch); } TEST_F(SqliteStatement, ThrowNoValuesToFetchForDoneStatement) @@ -146,7 +150,7 @@ TEST_F(SqliteStatement, ThrowNoValuesToFetchForDoneStatement) SqliteTestStatement statement("SELECT name, number FROM test", database); while (statement.next()) {} - ASSERT_THROW(statement.value(0), Sqlite::NoValuesToFetch); + ASSERT_THROW(statement.fetchValue(0), Sqlite::NoValuesToFetch); } TEST_F(SqliteStatement, ThrowInvalidColumnFetchedForNegativeColumn) @@ -154,7 +158,7 @@ TEST_F(SqliteStatement, ThrowInvalidColumnFetchedForNegativeColumn) SqliteTestStatement statement("SELECT name, number FROM test", database); statement.next(); - ASSERT_THROW(statement.value(-1), Sqlite::InvalidColumnFetched); + ASSERT_THROW(statement.fetchValue(-1), Sqlite::InvalidColumnFetched); } TEST_F(SqliteStatement, ThrowInvalidColumnFetchedForNotExistingColumn) @@ -162,7 +166,7 @@ TEST_F(SqliteStatement, ThrowInvalidColumnFetchedForNotExistingColumn) SqliteTestStatement statement("SELECT name, number FROM test", database); statement.next(); - ASSERT_THROW(statement.value(2), Sqlite::InvalidColumnFetched); + ASSERT_THROW(statement.fetchValue(2), Sqlite::InvalidColumnFetched); } TEST_F(SqliteStatement, ToIntergerValue) @@ -206,7 +210,7 @@ TEST_F(SqliteStatement, BindString) statement.next(); ASSERT_THAT(statement.text(0), "foo"); - ASSERT_THAT(statement.value(1), 23.3); + ASSERT_THAT(statement.fetchValue(1), 23.3); } TEST_F(SqliteStatement, BindInteger) @@ -356,7 +360,7 @@ TEST_F(SqliteStatement, GetTupleValuesWithoutArguments) using Tuple = std::tuple; ReadStatement statement("SELECT name, number, value FROM test", database); - auto values = statement.tupleValues(3); + auto values = statement.values(3); ASSERT_THAT(values, ElementsAre(Tuple{"bar", 0, 1}, Tuple{"foo", 23.3, 2}, @@ -376,7 +380,7 @@ TEST_F(SqliteStatement, GetStructValuesWithoutArguments) { ReadStatement statement("SELECT name, number, value FROM test", database); - auto values = statement.structValues(3); + auto values = statement.values(3); ASSERT_THAT(values, ElementsAre(Output{"bar", "blah", 1}, Output{"foo", "23.3", 2}, @@ -399,7 +403,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryValues) std::vector queryValues = {40, 23.3}; ReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database); - auto values = statement.tupleValues(3, queryValues); + auto values = statement.values(3, queryValues); ASSERT_THAT(values, ElementsAre(Tuple{"poo", 40, 3.}, Tuple{"foo", 23.3, 2.})); @@ -418,14 +422,14 @@ TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryValues) TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndContainerQueryTupleValues) { using Tuple = std::tuple; - using Tuple2 = std::tuple; + using ResultTuple = std::tuple; std::vector queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}}; ReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database); - auto values = statement.tupleValues(3, queryValues); + auto values = statement.values(3, queryValues); - ASSERT_THAT(values, ElementsAre(Tuple2{"poo", 40, 3}, - Tuple2{"bar", 0, 1})); + ASSERT_THAT(values, ElementsAre(ResultTuple{"poo", 40, 3}, + ResultTuple{"bar", 0, 1})); } TEST_F(SqliteStatement, GetValuesForSingleOutputValuesAndContainerQueryTupleValues) @@ -444,7 +448,7 @@ TEST_F(SqliteStatement, GetValuesForMultipleOutputValuesAndMultipleQueryValue) using Tuple = std::tuple; ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database); - auto values = statement.tupleValues(3, "bar", "blah", 1); + auto values = statement.values(3, "bar", "blah", 1); ASSERT_THAT(values, ElementsAre(Tuple{"bar", "blah", 1})); } @@ -453,9 +457,9 @@ TEST_F(SqliteStatement, CallGetValuesForMultipleOutputValuesAndMultipleQueryValu { using Tuple = std::tuple; ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=?", database); - statement.tupleValues(3, "bar", "blah"); + statement.values(3, "bar", "blah"); - auto values = statement.tupleValues(3, "bar", "blah"); + auto values = statement.values(3, "bar", "blah"); ASSERT_THAT(values, ElementsAre(Tuple{"bar", "blah", 1})); } @@ -464,7 +468,7 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndMultipleQueryValue) { ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database); - auto values = statement.structValues(3, "bar", "blah", 1); + auto values = statement.values(3, "bar", "blah", 1); ASSERT_THAT(values, ElementsAre(Output{"bar", "blah", 1})); } @@ -474,7 +478,7 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryValues) std::vector queryValues = {40, 23.3}; ReadStatement statement("SELECT name, number, value FROM test WHERE number=?", database); - auto values = statement.structValues(3, queryValues); + auto values = statement.values(3, queryValues); ASSERT_THAT(values, ElementsAre(Output{"poo", "40", 3}, Output{"foo", "23.3", 2})); @@ -486,12 +490,41 @@ TEST_F(SqliteStatement, GetStructOutputValuesAndContainerQueryTupleValues) std::vector queryValues = {{"poo", "40", 3}, {"bar", "blah", 1}}; ReadStatement statement("SELECT name, number, value FROM test WHERE name= ? AND number=? AND value=?", database); - auto values = statement.structValues(3, queryValues); + auto values = statement.values(3, queryValues); ASSERT_THAT(values, ElementsAre(Output{"poo", "40", 3}, Output{"bar", "blah", 1})); } +TEST_F(SqliteStatement, GetOptionalSingleValueAndMultipleQueryValue) +{ + ReadStatement statement("SELECT name FROM test WHERE name=? AND number=? AND value=?", database); + + auto value = statement.value("bar", "blah", 1); + + ASSERT_THAT(value.value(), Eq("bar")); +} + +TEST_F(SqliteStatement, GetOptionalOutputValueAndMultipleQueryValue) +{ + ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database); + + auto value = statement.value("bar", "blah", 1); + + ASSERT_THAT(value.value(), Eq(Output{"bar", "blah", 1})); +} + +TEST_F(SqliteStatement, GetOptionalTupleValueAndMultipleQueryValue) +{ + using Tuple = std::tuple; + ReadStatement statement("SELECT name, number, value FROM test WHERE name=? AND number=? AND value=?", database); + + auto value = statement.value("bar", "blah", 1); + + ASSERT_THAT(value.value(), Eq(Tuple{"bar", "blah", 1})); +} + + void SqliteStatement::SetUp() { database.setJournalMode(JournalMode::Memory); diff --git a/tests/unit/unittest/sqliteteststatement.h b/tests/unit/unittest/sqliteteststatement.h index 43b6ab884c1..870180b5d05 100644 --- a/tests/unit/unittest/sqliteteststatement.h +++ b/tests/unit/unittest/sqliteteststatement.h @@ -46,7 +46,7 @@ public: using Statement::execute; using Statement::next; using Statement::text; - using Statement::value; + using Statement::fetchValue; protected: void checkIsWritableStatement(); diff --git a/tests/unit/unittest/symbolquery-test.cpp b/tests/unit/unittest/symbolquery-test.cpp index 2de8cc251b4..50925bd7f3c 100644 --- a/tests/unit/unittest/symbolquery-test.cpp +++ b/tests/unit/unittest/symbolquery-test.cpp @@ -63,9 +63,9 @@ protected: TEST_F(SymbolQuery, LocationsAt) { - EXPECT_CALL(selectLocationsForSymbolLocation, structValuesReturnStdVectorLocation(_, Eq("/path/to/file.cpp"), 14, 7)) + EXPECT_CALL(selectLocationsForSymbolLocation, valuesReturnStdVectorLocation(_, Eq("/path/to/file.cpp"), 14, 7)) .WillRepeatedly(Return(locations)); - EXPECT_CALL(selectSourcePathForId, structValuesReturnStdVectorSource(_, ElementsAre(1, 2, 4))); + EXPECT_CALL(selectSourcePathForId, valuesReturnStdVectorSource(_, ElementsAre(1, 2, 4))); query.locationsAt("/path/to/file.cpp", 14, 7); }