From 98b682acb8c57cadaea5ff0ac6709d21a591b97b Mon Sep 17 00:00:00 2001 From: Christian Mollekopf Date: Fri, 4 Nov 2016 12:00:35 +0100 Subject: Separated the base filter from the rest of the query. --- common/datastorequery.cpp | 4 +- common/query.h | 192 +++++++++++++++++++++++++++------------------- 2 files changed, 115 insertions(+), 81 deletions(-) (limited to 'common') diff --git a/common/datastorequery.cpp b/common/datastorequery.cpp index aa7b772..0987d68 100644 --- a/common/datastorequery.cpp +++ b/common/datastorequery.cpp @@ -400,8 +400,8 @@ QVector DataStoreQuery::indexLookup(const QByteArray &property, cons QByteArrayList DataStoreQuery::executeSubquery(const Query &subquery) { - Q_ASSERT(!subquery.type.isEmpty()); - auto sub = DataStoreQuery(subquery, subquery.type, mStore); + Q_ASSERT(!subquery.type().isEmpty()); + auto sub = DataStoreQuery(subquery, subquery.type(), mStore); auto result = sub.execute(); QByteArrayList ids; while (result.next([&ids](const ResultSet::Result &result) { diff --git a/common/query.h b/common/query.h index 3ab5acf..c0ea0f3 100644 --- a/common/query.h +++ b/common/query.h @@ -27,21 +27,9 @@ namespace Sink { -/** - * A query that matches a set of entities. - */ -class SINK_EXPORT Query +class SINK_EXPORT QueryBase { public: - enum Flag - { - /** Leave the query running and continuously update the result set. */ - LiveQuery, - /** Run the query synchronously. */ - SynchronousQuery - }; - Q_DECLARE_FLAGS(Flags, Flag) - struct Comparator { enum Comparators { Invalid, @@ -59,137 +47,184 @@ public: Comparators comparator; }; - template - Query &request() + class Filter { + public: + QByteArrayList ids; + QHash propertyFilter; + }; + + Comparator getFilter(const QByteArray &property) const { - requestedProperties << T::name; - return *this; + return mBaseFilterStage.propertyFilter.value(property); } - template - Query &requestTree() + bool hasFilter(const QByteArray &property) const { - parentProperty = T::name; - return *this; + return mBaseFilterStage.propertyFilter.contains(property); } - template - Query &sort() + void setBaseFilters(const QHash &filter) { - sortProperty = T::name; - return *this; + mBaseFilterStage.propertyFilter = filter; } - Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false) + QHash getBaseFilters() const { - filter(value.identifier()); - resourceFilter(value.resourceInstanceIdentifier()); + return mBaseFilterStage.propertyFilter; } - Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false) + QByteArrayList ids() const { + return mBaseFilterStage.ids; } - QByteArrayList requestedProperties; - QByteArray parentProperty; - QByteArray sortProperty; - QByteArray type; - int limit; - bool liveQuery; - bool synchronousQuery; - - class FilterStage { - public: - virtual ~FilterStage(){}; - }; + void filter(const QByteArray &id) + { + mBaseFilterStage.ids << id; + } - QList> getFilterStages() + void filter(const QByteArrayList &ids) { - return mFilterStages; + mBaseFilterStage.ids << ids; } - /* - * Filters - */ - class Filter : public FilterStage { - public: - QByteArrayList ids; - QHash propertyFilter; - }; + void filter(const QByteArray &property, const QueryBase::Comparator &comparator) + { + mBaseFilterStage.propertyFilter.insert(property, comparator); + } - template - Query &filter(const QVariant &value) + void setType(const QByteArray &type) { - return filter(T::name, value); + mType = type; } - template - Query &containsFilter(const QVariant &value) + QByteArray type() const { - return filter(T::name, Comparator(value, Comparator::Contains)); + return mType; } +private: + Filter mBaseFilterStage; + QByteArray mType; +}; + +/** + * A query that matches a set of entities. + */ +class SINK_EXPORT Query : public QueryBase +{ +public: + enum Flag + { + /** Leave the query running and continuously update the result set. */ + LiveQuery, + /** Run the query synchronously. */ + SynchronousQuery + }; + Q_DECLARE_FLAGS(Flags, Flag) + template - Query &filter(const Comparator &comparator) + Query &request() { - return filter(T::name, comparator); + requestedProperties << T::name; + return *this; } - Query &filter(const QByteArray &id) + template + Query &requestTree() { - mBaseFilterStage.ids << id; + parentProperty = T::name; return *this; } - Query &filter(const QByteArrayList &ids) + template + Query &sort() { - mBaseFilterStage.ids << ids; + sortProperty = T::name; return *this; } - Query &filter(const QByteArray &property, const Comparator &comparator) + template + Query &filter(const QVariant &value) { - mBaseFilterStage.propertyFilter.insert(property, comparator); + filter(T::name, value); return *this; } - Comparator getFilter(const QByteArray &property) const + template + Query &containsFilter(const QVariant &value) { - return mBaseFilterStage.propertyFilter.value(property); + QueryBase::filter(T::name, QueryBase::Comparator(value, QueryBase::Comparator::Contains)); + return *this; } - bool hasFilter(const QByteArray &property) const + template + Query &filter(const QueryBase::Comparator &comparator) { - return mBaseFilterStage.propertyFilter.contains(property); + QueryBase::filter(T::name, comparator); + return *this; } - void setBaseFilters(const QHash &filter) + Query &filter(const QByteArray &id) { - mBaseFilterStage.propertyFilter = filter; + QueryBase::filter(id); + return *this; } - QHash getBaseFilters() const + Query &filter(const QByteArrayList &ids) { - return mBaseFilterStage.propertyFilter; + QueryBase::filter(ids); + return *this; } - QByteArrayList ids() const + Query &filter(const QByteArray &property, const QueryBase::Comparator &comparator) { - return mBaseFilterStage.ids; + QueryBase::filter(property, comparator); + return *this; } template Query &filter(const ApplicationDomain::Entity &value) { - return filter(T::name, QVariant::fromValue(value.identifier())); + filter(T::name, QVariant::fromValue(value.identifier())); + return *this; } template Query &filter(const Query &query) { auto q = query; - q.type = ApplicationDomain::getTypeName(); - return filter(T::name, QVariant::fromValue(q)); + q.setType(ApplicationDomain::getTypeName()); + filter(T::name, QVariant::fromValue(q)); + return *this; + } + + + Query(const ApplicationDomain::Entity &value) : limit(0), liveQuery(false), synchronousQuery(false) + { + filter(value.identifier()); + resourceFilter(value.resourceInstanceIdentifier()); + } + + Query(Flags flags = Flags()) : limit(0), liveQuery(false), synchronousQuery(false) + { + } + + QByteArrayList requestedProperties; + QByteArray parentProperty; + QByteArray sortProperty; + int limit; + bool liveQuery; + bool synchronousQuery; + + class FilterStage { + public: + virtual ~FilterStage(){}; + }; + + QList> getFilterStages() + { + return mFilterStages; } Filter getResourceFilter() const @@ -342,7 +377,6 @@ public: private: Filter mResourceFilter; - Filter mBaseFilterStage; QList> mFilterStages; }; -- cgit v1.2.3