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

Sqlite: Add change set iterator

Browse Source 
Task-number: QDS-2998
Change-Id: I7bfa8af51d9d7e6122902ee132ad51019e20afb5
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>
This commit is contained in:
Marco Bubke
2020-10-27 15:09:25 +01:00
parent 3c7ab41e9e
commit c3873fcf40
8 changed files with 816 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

115
src/libs/sqlite/sqliteexception.h
View File

@@ -37,12 +37,15 @@ namespace Sqlite {
class SQLITE_EXPORT Exception : public std::exception
{
public:
Exception(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
Exception(const char *whatErrorHasHappen, Utils::SmallString &&sqliteErrorMessage)
: m_whatErrorHasHappen(whatErrorHasHappen)
, m_sqliteErrorMessage(std::move(sqliteErrorMessage))
{}
Exception(const char *whatErrorHasHappen)
: m_whatErrorHasHappen(whatErrorHasHappen)
{}
const char *what() const noexcept override { return m_whatErrorHasHappen; }
void printWarning() const;
@@ -58,8 +61,7 @@ public:
StatementIsBusy(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
{
}
{}
};
class DatabaseIsBusy : public Exception
@@ -67,8 +69,7 @@ class DatabaseIsBusy : public Exception
public:
DatabaseIsBusy(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class StatementHasError : public Exception
@@ -77,8 +78,7 @@ public:
StatementHasError(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
{
}
{}
};
class StatementIsMisused : public Exception
@@ -87,8 +87,7 @@ public:
StatementIsMisused(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
{
}
{}
};
class InputOutputError : public Exception
@@ -96,8 +95,7 @@ class InputOutputError : public Exception
public:
InputOutputError(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class ConstraintPreventsModification : public Exception
@@ -106,8 +104,7 @@ public:
ConstraintPreventsModification(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
{
}
{}
};
class NoValuesToFetch : public Exception
@@ -115,8 +112,7 @@ class NoValuesToFetch : public Exception
public:
NoValuesToFetch(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class ColumnCountDoesNotMatch : public Exception
@@ -133,8 +129,7 @@ public:
BindingIndexIsOutOfRange(const char *whatErrorHasHappen,
Utils::SmallString &&sqliteErrorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(sqliteErrorMessage))
{
}
{}
};
class WrongBindingName : public Exception
@@ -142,8 +137,7 @@ class WrongBindingName : public Exception
public:
WrongBindingName(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class DatabaseIsNotOpen : public Exception
@@ -151,8 +145,7 @@ class DatabaseIsNotOpen : public Exception
public:
DatabaseIsNotOpen(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class DatabaseCannotBeOpened : public Exception
@@ -161,8 +154,7 @@ public:
DatabaseCannotBeOpened(const char *whatErrorHasHappen,
Utils::SmallString &&errorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(errorMessage))
{
}
{}
};
class DatabaseFilePathIsEmpty : public DatabaseCannotBeOpened
@@ -170,8 +162,7 @@ class DatabaseFilePathIsEmpty : public DatabaseCannotBeOpened
public:
DatabaseFilePathIsEmpty(const char *whatErrorHasHappen)
: DatabaseCannotBeOpened(whatErrorHasHappen)
{
}
{}
};
class DatabaseIsAlreadyOpen : public DatabaseCannotBeOpened
@@ -179,8 +170,7 @@ class DatabaseIsAlreadyOpen : public DatabaseCannotBeOpened
public:
DatabaseIsAlreadyOpen(const char *whatErrorHasHappen)
: DatabaseCannotBeOpened(whatErrorHasHappen)
{
}
{}
};
class DatabaseCannotBeClosed : public Exception
@@ -188,8 +178,7 @@ class DatabaseCannotBeClosed : public Exception
public:
DatabaseCannotBeClosed(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class DatabaseIsAlreadyClosed : public DatabaseCannotBeClosed
@@ -197,8 +186,7 @@ class DatabaseIsAlreadyClosed : public DatabaseCannotBeClosed
public:
DatabaseIsAlreadyClosed(const char *whatErrorHasHappen)
: DatabaseCannotBeClosed(whatErrorHasHappen)
{
}
{}
};
class WrongFilePath : public DatabaseCannotBeOpened
@@ -207,8 +195,7 @@ public:
WrongFilePath(const char *whatErrorHasHappen,
Utils::SmallString &&errorMessage = Utils::SmallString())
: DatabaseCannotBeOpened(whatErrorHasHappen, std::move(errorMessage))
{
}
{}
};
class PragmaValueNotSet : public Exception
@@ -216,8 +203,7 @@ class PragmaValueNotSet : public Exception
public:
PragmaValueNotSet(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class NotReadOnlySqlStatement : public Exception
@@ -225,8 +211,7 @@ class NotReadOnlySqlStatement : public Exception
public:
NotReadOnlySqlStatement(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class NotWriteSqlStatement : public Exception
@@ -234,8 +219,7 @@ class NotWriteSqlStatement : public Exception
public:
NotWriteSqlStatement(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class DeadLock : public Exception
@@ -243,8 +227,7 @@ class DeadLock : public Exception
public:
DeadLock(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{
}
{}
};
class UnknowError : public Exception
@@ -253,8 +236,7 @@ public:
UnknowError(const char *whatErrorHasHappen,
Utils::SmallString &&errorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(errorMessage))
{
}
{}
};
class BindingTooBig : public Exception
@@ -263,8 +245,7 @@ public:
BindingTooBig(const char *whatErrorHasHappen,
Utils::SmallString &&errorMessage = Utils::SmallString())
: Exception(whatErrorHasHappen, std::move(errorMessage))
{
}
{}
};
class TooBig : public Exception
@@ -387,4 +368,46 @@ public:
: Exception(whatErrorHasHappen, std::move(errorMessage))
{}
};
class CannotCreateChangeSetIterator : public Exception
{
public:
CannotCreateChangeSetIterator(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{}
};
class CannotGetChangeSetOperation : public Exception
{
public:
CannotGetChangeSetOperation(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{}
};
class ChangeSetTupleIsOutOfRange : public Exception
{
public:
ChangeSetTupleIsOutOfRange(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{}
};
class ChangeSetTupleIsMisused : public Exception
{
public:
ChangeSetTupleIsMisused(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{}
};
class UnknownError : public Exception
{
public:
UnknownError(const char *whatErrorHasHappen)
: Exception(whatErrorHasHappen)
{}
};
} // namespace Sqlite

171
src/libs/sqlite/sqlitesessionchangeset.cpp
View File

@@ -24,6 +24,7 @@
****************************************************************************/
#include "sqlitesessionchangeset.h"
#include "sqliteexception.h"
#include "sqlitesessions.h"
#include <utils/smallstringio.h>
@@ -33,7 +34,7 @@
namespace Sqlite {
namespace {
void checkResultCode(int resultCode)
void checkSessionChangeSetCreation(int resultCode)
{
switch (resultCode) {
case SQLITE_NOMEM:
@@ -44,29 +45,183 @@ void checkResultCode(int resultCode)
throw UnknowError("Unknow exception");
}
void checkIteratorCreation(int resultCode)
{
if (resultCode != SQLITE_OK)
throw Sqlite::CannotCreateChangeSetIterator{
"SessionChangeSet: Cannot create iterator from blob."};
}
void checkIteratorOperation(int resultCode)
{
if (resultCode != SQLITE_OK)
throw Sqlite::CannotGetChangeSetOperation{
"SessionChangeSet: Cannot create iterator from blob."};
}
void checkChangeSetValue(int resultCode)
{
switch (resultCode) {
case SQLITE_OK:
return;
case SQLITE_RANGE:
throw Sqlite::ChangeSetTupleIsOutOfRange{
"SessionChangeSet: You tried to access a non existing column."};
case SQLITE_MISUSE:
throw Sqlite::ChangeSetIsMisused{
"SessionChangeSet: Some misuse happened as you tried to access."};
}
throw Sqlite::UnknownError{"SessionChangeSet: Some unknown error happened."};
}
ValueView convertSqliteValue(sqlite3_value *value)
{
if (value) {
int type = sqlite3_value_type(value);
switch (type) {
case SQLITE_INTEGER:
return ValueView::create(sqlite3_value_int64(value));
case SQLITE_FLOAT:
return ValueView::create(sqlite3_value_double(value));
case SQLITE_TEXT:
return ValueView::create(
Utils::SmallStringView{reinterpret_cast<const char *const>(sqlite3_value_text(value)),
static_cast<std::size_t>(sqlite3_value_bytes(value))});
case SQLITE_NULL:
return ValueView::create(NullValue{});
}
}
return ValueView::create(NullValue{});
}
} // namespace
SessionChangeSet::SessionChangeSet(BlobView blob)
: data(sqlite3_malloc64(blob.size()))
, size(int(blob.size()))
: m_data(sqlite3_malloc64(blob.size()))
, m_size(int(blob.size()))
{
std::memcpy(data, blob.data(), blob.size());
std::memcpy(m_data, blob.data(), blob.size());
}
SessionChangeSet::SessionChangeSet(Sessions &session)
{
int resultCode = sqlite3session_changeset(session.session.get(), &size, &data);
checkResultCode(resultCode);
int resultCode = sqlite3session_changeset(session.session.get(), &m_size, &m_data);
checkSessionChangeSetCreation(resultCode);
}
SessionChangeSet::~SessionChangeSet()
{
sqlite3_free(data);
sqlite3_free(m_data);
}
BlobView SessionChangeSet::asBlobView() const
{
return {static_cast<const byte *>(data), static_cast<std::size_t>(size)};
return {static_cast<const byte *>(m_data), static_cast<std::size_t>(m_size)};
}
SessionChangeSetInternal::ConstIterator SessionChangeSet::begin() const
{
sqlite3_changeset_iter *sessionIterator;
int resultCode = sqlite3changeset_start(&sessionIterator, m_size, m_data);
checkIteratorCreation(resultCode);
SessionChangeSetInternal::ConstIterator iterator{sessionIterator};
++iterator;
return iterator;
}
namespace SessionChangeSetInternal {
ConstIterator::~ConstIterator()
{
sqlite3changeset_finalize(m_sessionIterator);
}
namespace {
State convertState(int state)
{
switch (state) {
case SQLITE_ROW:
return State::Row;
case SQLITE_DONE:
return State::Done;
}
return State::Invalid;
}
Operation convertOperation(int operation)
{
switch (operation) {
case SQLITE_INSERT:
return Operation::Insert;
case SQLITE_UPDATE:
return Operation::Update;
case SQLITE_DELETE:
return Operation::Delete;
}
return Operation::Invalid;
}
} // namespace
ConstIterator &ConstIterator::operator++()
{
int state = sqlite3changeset_next(m_sessionIterator);
m_state = convertState(state);
return *this;
}
Tuple ConstIterator::operator*() const
{
const char *table;
int columnCount;
int operation;
int isIndirect;
int resultCode = sqlite3changeset_op(m_sessionIterator, &table, &columnCount, &operation, &isIndirect);
checkIteratorOperation(resultCode);
return {table, m_sessionIterator, columnCount, convertOperation(operation)};
}
namespace {
ValueViews fetchValues(sqlite3_changeset_iter *sessionIterator, int column, Operation operation)
{
sqlite3_value *newValue = nullptr;
if (operation == Operation::Insert || operation == Operation::Update) {
int resultCode = sqlite3changeset_new(sessionIterator, column, &newValue);
checkChangeSetValue(resultCode);
}
sqlite3_value *oldValue = nullptr;
if (operation == Operation::Delete || operation == Operation::Update) {
int resultCode = sqlite3changeset_old(sessionIterator, column, &oldValue);
checkChangeSetValue(resultCode);
}
return {convertSqliteValue(newValue), convertSqliteValue(oldValue)};
}
} // namespace
ValueViews ConstTupleIterator::operator*() const
{
return fetchValues(m_sessionIterator, m_column, m_operation);
}
ValueViews Tuple::operator[](int column) const
{
return fetchValues(sessionIterator, column, operation);
}
} // namespace SessionChangeSetInternal
} // namespace Sqlite

185
src/libs/sqlite/sqlitesessionchangeset.h
View File

@@ -27,17 +27,173 @@
#include "sqliteblob.h"
#include "sqliteglobal.h"
#include "sqlitevalue.h"
#include <utils/smallstring.h>
#include <memory>
#include <vector>
#include <iosfwd>
struct sqlite3_changeset_iter;
namespace Sqlite {
class Sessions;
class SessionChangeSet
namespace SessionChangeSetInternal {
enum class Operation : char { Invalid, Insert, Update, Delete };
class SentinelIterator
{};
class ValueViews
{
public:
ValueView newValue;
ValueView oldValue;
};
class ConstTupleIterator
{
public:
using difference_type = int;
using value_type = ValueView;
using pointer = const ValueView *;
using reference = const ValueView &;
using iterator_category = std::forward_iterator_tag;
ConstTupleIterator(sqlite3_changeset_iter *sessionIterator, int index, Operation operation)
: m_sessionIterator{sessionIterator}
, m_column{index}
, m_operation{operation}
{}
ConstTupleIterator operator++()
{
++m_column;
return *this;
}
friend bool operator==(const ConstTupleIterator &first, const ConstTupleIterator &second)
{
return first.m_column == second.m_column;
}
friend bool operator!=(const ConstTupleIterator &first, const ConstTupleIterator &second)
{
return !(first == second);
}
ValueViews operator*() const;
private:
sqlite3_changeset_iter *m_sessionIterator = {};
int m_column = 0;
Operation m_operation = Operation::Invalid;
};
class Tuple
{
public:
using difference_type = int;
using value_type = ValueView;
using reference = ValueView &;
using const_reference = const ValueView &;
using iterator = ConstTupleIterator;
using const_iterator = ConstTupleIterator;
using size_type = int;
Utils::SmallStringView table;
sqlite3_changeset_iter *sessionIterator = {};
int columnCount = 0;
Operation operation = Operation::Invalid;
ValueViews operator[](int column) const;
ConstTupleIterator begin() const { return {sessionIterator, 0, operation}; }
ConstTupleIterator end() const { return {sessionIterator, columnCount, operation}; }
};
enum class State : char { Invalid, Row, Done };
class ConstIterator
{
public:
using difference_type = long;
using value_type = Tuple;
using pointer = const Tuple *;
using reference = const Tuple &;
using iterator_category = std::input_iterator_tag;
ConstIterator(sqlite3_changeset_iter *sessionIterator)
: m_sessionIterator(sessionIterator)
{}
ConstIterator(const ConstIterator &) = delete;
void operator=(const ConstIterator &) = delete;
ConstIterator(ConstIterator &&other)
: m_sessionIterator(other.m_sessionIterator)
, m_state(other.m_state)
{
other.m_sessionIterator = {};
other.m_state = State::Done;
}
ConstIterator &operator=(ConstIterator &&other)
{
auto tmp = std::move(other);
std::swap(tmp, *this);
return *this;
}
~ConstIterator();
ConstIterator &operator++();
friend bool operator==(const ConstIterator &first, const ConstIterator &second)
{
return first.m_sessionIterator == second.m_sessionIterator;
}
friend bool operator!=(const ConstIterator &first, const ConstIterator &second)
{
return !(first == second);
}
friend bool operator==(const ConstIterator &first, SentinelIterator)
{
return first.m_state == State::Done;
}
friend bool operator!=(const ConstIterator &first, SentinelIterator)
{
return first.m_state == State::Row;
}
friend bool operator==(SentinelIterator first, const ConstIterator &second)
{
return second == first;
}
friend bool operator!=(SentinelIterator first, const ConstIterator &second)
{
return second != first;
}
Tuple operator*() const;
State state() const { return m_state; }
private:
sqlite3_changeset_iter *m_sessionIterator = {};
State m_state = State::Invalid;
};
} // namespace SessionChangeSetInternal
class SQLITE_EXPORT SessionChangeSet
{
public:
SessionChangeSet(BlobView blob);
@@ -58,20 +214,27 @@ public:
friend void swap(SessionChangeSet &first, SessionChangeSet &second) noexcept
{
SessionChangeSet temp;
std::swap(temp.data, first.data);
std::swap(temp.size, first.size);
std::swap(first.data, second.data);
std::swap(first.size, second.size);
std::swap(temp.data, second.data);
std::swap(temp.size, second.size);
std::swap(temp.m_data, first.m_data);
std::swap(temp.m_size, first.m_size);
std::swap(first.m_data, second.m_data);
std::swap(first.m_size, second.m_size);
std::swap(temp.m_data, second.m_data);
std::swap(temp.m_size, second.m_size);
}
SessionChangeSetInternal::ConstIterator begin() const;
SessionChangeSetInternal::SentinelIterator end() const { return {}; }
void *data() const { return m_data; }
int size() const { return m_size; }
private:
SessionChangeSet() = default;
public:
void *data = nullptr;
int size = {};
private:
void *m_data = nullptr;
int m_size = {};
};
using SessionChangeSets = std::vector<SessionChangeSet>;

18
src/libs/sqlite/sqlitesessions.cpp
View File

@@ -136,8 +136,8 @@ void Sessions::revert()
for (auto &changeSet : changeSets) {
int resultCode = sqlite3changeset_apply_v2(database.backend().sqliteDatabaseHandle(),
changeSet.size,
changeSet.data,
changeSet.size(),
changeSet.data(),
nullptr,
xConflict,
nullptr,
@@ -160,8 +160,8 @@ void Sessions::apply()
for (auto &changeSet : changeSets) {
int resultCode = sqlite3changeset_apply_v2(database.backend().sqliteDatabaseHandle(),
changeSet.size,
changeSet.data,
changeSet.size(),
changeSet.data(),
nullptr,
xConflict,
nullptr,
@@ -185,4 +185,14 @@ void Sessions::deleteAll()
WriteStatement{Utils::SmallString{"DELETE FROM ", sessionsTableName}, database}.execute();
}
SessionChangeSets Sessions::changeSets() const
{
ReadStatement selectChangeSets{Utils::PathString{"SELECT changeset FROM ",
sessionsTableName,
" ORDER BY id DESC"},
database};
return selectChangeSets.values<SessionChangeSet>(1024);
}
} // namespace Sqlite

3
src/libs/sqlite/sqlitesessions.h
View File

@@ -26,6 +26,7 @@
#pragma once
#include "sqlitedatabase.h"
#include "sqlitesessionchangeset.h"
#include "sqlitewritestatement.h"
extern "C" {
@@ -81,6 +82,8 @@ public:
void applyAndUpdateSessions();
void deleteAll();
SessionChangeSets changeSets() const;
private:
void attachTables(const Utils::SmallStringVector &tables);

97
tests/unit/unittest/gtest-creator-printing.cpp
View File

@@ -331,6 +331,28 @@ std::ostream &operator<<(std::ostream &out, const Value &value)
return out << ")";
}
std::ostream &operator<<(std::ostream &out, const ValueView &value)
{
out << "(";
switch (value.type()) {
case Sqlite::ValueType::Integer:
out << value.toInteger();
break;
case Sqlite::ValueType::Float:
out << value.toFloat();
break;
case Sqlite::ValueType::String:
out << "\"" << value.toStringView() << "\"";
break;
case Sqlite::ValueType::Null:
out << "null";
break;
}
return out << ")";
}
namespace {
Utils::SmallStringView operationText(int operation)
{
@@ -398,7 +420,7 @@ std::ostream &operator<<(std::ostream &out, sqlite3_changeset_iter *iter)
std::ostream &operator<<(std::ostream &out, const SessionChangeSet &changeset)
{
sqlite3_changeset_iter *iter = nullptr;
sqlite3changeset_start(&iter, changeset.size, const_cast<void *>(changeset.data));
sqlite3changeset_start(&iter, changeset.size(), const_cast<void *>(changeset.data()));
out << "ChangeSets([";
@@ -414,6 +436,79 @@ std::ostream &operator<<(std::ostream &out, const SessionChangeSet &changeset)
return out;
}
namespace SessionChangeSetInternal {
namespace {
const char *toText(Operation operation)
{
switch (operation) {
case Operation::Invalid:
return "Invalid";
case Operation::Insert:
return "Invalid";
case Operation::Update:
return "Invalid";
case Operation::Delete:
return "Invalid";
}
return "";
}
const char *toText(State state)
{
switch (state) {
case State::Invalid:
return "Invalid";
case State::Row:
return "Row";
case State::Done:
return "Done";
}
return "";
}
} // namespace
std::ostream &operator<<(std::ostream &out, SentinelIterator)
{
return out << "sentinel";
}
std::ostream &operator<<(std::ostream &out, Operation operation)
{
return out << toText(operation);
}
std::ostream &operator<<(std::ostream &out, State state)
{
return out << toText(state);
}
std::ostream &operator<<(std::ostream &out, const Tuple &tuple)
{
return out << "(" << tuple.operation << ", " << tuple.columnCount << ")";
}
std::ostream &operator<<(std::ostream &out, const ValueViews &valueViews)
{
return out << "(" << valueViews.newValue << ", " << valueViews.oldValue << ")";
}
std::ostream &operator<<(std::ostream &out, const ConstIterator &iterator)
{
return out << "(" << (*iterator) << ", " << iterator.state() << ")";
}
std::ostream &operator<<(std::ostream &out, const ConstTupleIterator &iterator)
{
auto value = *iterator;
return out << "(" << value.newValue << ", " << value.newValue << ")";
}
} // namespace SessionChangeSetInternal
} // namespace Sqlite
namespace ClangBackEnd {

20
tests/unit/unittest/gtest-creator-printing.h
View File

@@ -66,10 +66,30 @@ void PrintTo(const TextRange &range, ::std::ostream *os);
namespace Sqlite {
class Value;
class ValueView;
class SessionChangeSet;
std::ostream &operator<<(std::ostream &out, const Value &value);
std::ostream &operator<<(std::ostream &out, const ValueView &value);
std::ostream &operator<<(std::ostream &out, const SessionChangeSet &changeset);
namespace SessionChangeSetInternal {
class ConstIterator;
class ConstTupleIterator;
class SentinelIterator;
class Tuple;
class ValueViews;
enum class Operation : char;
enum class State : char;
std::ostream &operator<<(std::ostream &out, SentinelIterator iterator);
std::ostream &operator<<(std::ostream &out, const ConstIterator &iterator);
std::ostream &operator<<(std::ostream &out, const ConstTupleIterator &iterator);
std::ostream &operator<<(std::ostream &out, const Tuple &tuple);
std::ostream &operator<<(std::ostream &out, Operation operation);
std::ostream &operator<<(std::ostream &out, State operation);
std::ostream &operator<<(std::ostream &out, const ValueViews &valueViews);
} // namespace SessionChangeSetInternal
} // namespace Sqlite
namespace ProjectExplorer {

285
tests/unit/unittest/sqlitesessions-test.cpp
View File

@@ -38,6 +38,8 @@ namespace {
using Sqlite::SessionChangeSet;
using Sqlite::SessionChangeSets;
using Sqlite::SessionChangeSetInternal::Operation;
using Sqlite::SessionChangeSetInternal::ValueViews;
class DatabaseExecute
{
@@ -79,6 +81,17 @@ MATCHER_P3(HasData,
return data.name == name && data.number == number && data.value == value;
}
MATCHER_P2(HasValues,
newValue,
oldValue,
std::string(negation ? "hasn't " : "has ") + PrintToString(newValue) + ", "
+ PrintToString(oldValue))
{
const ValueViews &values = arg;
return values.newValue == newValue && values.oldValue == oldValue;
}
class Tag
{
public:
@@ -113,7 +126,6 @@ protected:
std::vector<Data> fetchData() { return selectData.values<Data, 3>(8); }
std::vector<Tag> fetchTags() { return selectTags.values<Tag, 2>(8); }
SessionChangeSets fetchChangeSets() { return selectChangeSets.values<SessionChangeSet>(8); }
protected:
Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
@@ -128,6 +140,9 @@ protected:
Sqlite::WriteStatement insertData{"INSERT INTO data(name, number, value) VALUES (?1, ?2, ?3) "
"ON CONFLICT (name) DO UPDATE SET (number, value) = (?2, ?3)",
database};
Sqlite::WriteStatement insertOneDatum{"INSERT INTO data(value, name) VALUES (?1, ?2) "
"ON CONFLICT (name) DO UPDATE SET (value) = (?2)",
database};
Sqlite::WriteStatement updateNumber{"UPDATE data SET number = ?002 WHERE name=?001", database};
Sqlite::WriteStatement updateValue{"UPDATE data SET value = ?002 WHERE name=?001", database};
Sqlite::WriteStatement deleteData{"DELETE FROM data WHERE name=?", database};
@@ -151,7 +166,7 @@ TEST_F(Sessions, CreateEmptySession)
sessions.create();
sessions.commit();
ASSERT_THAT(fetchChangeSets(), IsEmpty());
ASSERT_THAT(sessions.changeSets(), IsEmpty());
}
TEST_F(Sessions, CreateSessionWithInsert)
@@ -160,7 +175,7 @@ TEST_F(Sessions, CreateSessionWithInsert)
insertData.write("foo", 22, 3.14);
sessions.commit();
ASSERT_THAT(fetchChangeSets(), SizeIs(1));
ASSERT_THAT(sessions.changeSets(), SizeIs(1));
}
TEST_F(Sessions, CreateSessionWithUpdate)
@@ -171,7 +186,7 @@ TEST_F(Sessions, CreateSessionWithUpdate)
updateNumber.write("foo", "bar");
sessions.commit();
ASSERT_THAT(fetchChangeSets(), SizeIs(1));
ASSERT_THAT(sessions.changeSets(), SizeIs(1));
}
TEST_F(Sessions, CreateSessionWithDelete)
@@ -182,7 +197,7 @@ TEST_F(Sessions, CreateSessionWithDelete)
deleteData.write("foo");
sessions.commit();
ASSERT_THAT(fetchChangeSets(), SizeIs(1));
ASSERT_THAT(sessions.changeSets(), SizeIs(1));
}
TEST_F(Sessions, CreateSessionWithInsertAndUpdate)
@@ -195,7 +210,7 @@ TEST_F(Sessions, CreateSessionWithInsertAndUpdate)
updateNumber.write("foo", "bar");
sessions.commit();
ASSERT_THAT(fetchChangeSets(), SizeIs(2));
ASSERT_THAT(sessions.changeSets(), SizeIs(2));
}
TEST_F(Sessions, CreateSession)
@@ -205,7 +220,7 @@ TEST_F(Sessions, CreateSession)
sessions.commit();
ASSERT_THAT(fetchChangeSets(), SizeIs(1));
ASSERT_THAT(sessions.changeSets(), SizeIs(1));
}
TEST_F(Sessions, RevertSession)
@@ -437,7 +452,261 @@ TEST_F(Sessions, ApplyAndUpdateSessionsHasOnlyOneChangeSet)
sessions.applyAndUpdateSessions();
ASSERT_THAT(fetchChangeSets(), SizeIs(1));
ASSERT_THAT(sessions.changeSets(), SizeIs(1));
}
TEST_F(Sessions, ForEmptySessionBeginEqualsEnd)
{
auto changeSets = sessions.changeSets();
auto begin = changeSets.begin();
ASSERT_THAT(begin, Eq(changeSets.end()));
}
TEST_F(Sessions, IteratorBeginUnequalsEndIfChangeSetHasContent)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
ASSERT_THAT(begin, Ne(changeSet.end()));
}
TEST_F(Sessions, NextIteratorUnequalsBeginIfChangeSetHasContent)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto next = std::next(changeSet.begin());
ASSERT_NE(next, changeSet.begin());
}
TEST_F(Sessions, NextIteratorEqualsEndIfChangeSetHasContent)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto next = std::next(changeSet.begin());
ASSERT_THAT(next, Eq(changeSet.end()));
}
TEST_F(Sessions, NextIteratorNotUnqualsEndIfChangeSetHasContent)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto next = std::next(changeSet.begin());
ASSERT_THAT(next, Not(Ne(changeSet.end())));
}
TEST_F(Sessions, BeginIteratorHasInsertOperation)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ASSERT_THAT(tuple.operation, Eq(Operation::Insert));
}
TEST_F(Sessions, BeginIteratorHasUpdateOperation)
{
insertData.write("foo", "bar", 3.14);
sessions.create();
updateValue.write("foo", 99);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ASSERT_THAT(tuple.operation, Eq(Operation::Update));
}
TEST_F(Sessions, BeginIteratorHasDeleteOperation)
{
insertData.write("foo", "bar", 3.14);
sessions.create();
deleteData.write("foo");
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ASSERT_THAT(tuple.operation, Eq(Operation::Delete));
}
TEST_F(Sessions, BeginIteratorHasDataTableName)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ASSERT_THAT(tuple.table, Eq("data"));
}
TEST_F(Sessions, ConvertAllValueTypesInChangeSet)
{
sessions.create();
insertData.write("foo", "bar", 3.14);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
std::vector<ValueViews> values{tuple.begin(), tuple.end()};
ASSERT_THAT(values,
ElementsAre(HasValues(1, nullptr),
HasValues("foo", nullptr),
HasValues("bar", nullptr),
HasValues(3.14, nullptr)));
}
TEST_F(Sessions, InsertOneValueChangeSet)
{
sessions.create();
insertOneDatum.write("foo");
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
std::vector<ValueViews> values{tuple.begin(), tuple.end()};
ASSERT_THAT(values,
ElementsAre(HasValues(1, nullptr),
HasValues(nullptr, nullptr),
HasValues(nullptr, nullptr),
HasValues("foo", nullptr)));
}
TEST_F(Sessions, UpdateOneValueChangeSet)
{
insertData.write("foo", "bar", 3.14);
sessions.create();
updateValue.write("foo", 99);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
std::vector<ValueViews> values{tuple.begin(), tuple.end()};
ASSERT_THAT(values,
ElementsAre(HasValues(nullptr, 1),
HasValues(nullptr, nullptr),
HasValues(nullptr, nullptr),
HasValues(99, 3.14)));
}
TEST_F(Sessions, DeleteRowChangeSet)
{
insertData.write("foo", "bar", 3.14);
sessions.create();
deleteData.write("foo");
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
std::vector<ValueViews> values{tuple.begin(), tuple.end()};
ASSERT_THAT(values,
ElementsAre(HasValues(nullptr, 1),
HasValues(nullptr, "foo"),
HasValues(nullptr, "bar"),
HasValues(nullptr, 3.14)));
}
TEST_F(Sessions, EmptyChangeSet)
{
sessions.create();
sessions.commit();
auto changeSets = sessions.changeSets();
ASSERT_THAT(changeSets, ElementsAre());
}
TEST_F(Sessions, AccessInsertOneValueChangeSet)
{
sessions.create();
insertOneDatum.write("foo");
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ValueViews value = tuple[3];
ASSERT_THAT(value, HasValues("foo", nullptr));
}
TEST_F(Sessions, AccessUpdateOneValueChangeSet)
{
insertData.write("foo", "bar", 3.14);
sessions.create();
updateValue.write("foo", 99);
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ValueViews value = tuple[3];
ASSERT_THAT(value, HasValues(99, 3.14));
}
TEST_F(Sessions, AccessDeleteRowChangeSet)
{
insertData.write("foo", "bar", 3.14);
sessions.create();
deleteData.write("foo");
sessions.commit();
auto changeSets = sessions.changeSets();
auto &&changeSet = changeSets.front();
auto begin = changeSet.begin();
auto tuple = (*begin);
ValueViews value = tuple[0];
ASSERT_THAT(value, HasValues(nullptr, 1));
}
} // namespace