10#include "searchstore.h"
13#include <QSharedPointer>
19#include <QJsonDocument>
24const int defaultLimit = 100000;
26class Akonadi::Search::QueryPrivate
33 uint m_limit = defaultLimit;
36 int m_yearFilter = -1;
37 int m_monthFilter = -1;
42 QVariantMap m_customOptions;
50Query::Query(
const Term &t)
56Query::Query(
const Query &rhs)
57 : d(new QueryPrivate(*rhs.d))
61Query::~Query() =
default;
63void Query::setTerm(
const Term &t)
68Term Query::term()
const
80 for (
const QString &type : typeList) {
85void Query::setType(
const QString &type)
101QString Query::searchString()
const
103 return d->m_searchString;
108 d->m_searchString = str;
111uint Query::limit()
const
121uint Query::offset()
const
126void Query::setOffset(uint offset)
128 d->m_offset = offset;
133 d->m_yearFilter = year;
134 d->m_monthFilter = month;
135 d->m_dayFilter = day;
138int Query::yearFilter()
const
140 return d->m_yearFilter;
143int Query::monthFilter()
const
145 return d->m_monthFilter;
148int Query::dayFilter()
const
150 return d->m_dayFilter;
155 d->m_sortingOption = option;
160 return d->m_sortingOption;
166 d->m_sortingProperty = property;
169QString Query::sortingProperty()
const
171 return d->m_sortingProperty;
176 d->m_customOptions.insert(option, value);
181 return d->m_customOptions.value(option);
184QVariantMap Query::customOptions()
const
186 return d->m_customOptions;
189void Query::removeCustomOption(
const QString &option)
191 d->m_customOptions.remove(option);
199 Q_ASSERT_X(!types().isEmpty(),
"Akonadi::Search::Query::exec",
"A query is being initialized without a type");
200 if (types().isEmpty()) {
207 const auto typeList{types()};
208 for (
const QString &type : typeList) {
209 if (!store->types().contains(type)) {
216 storeMatch = store.data();
225 int id = storeMatch->
exec(*
this);
226 return {id, storeMatch};
233 if (!d->m_types.isEmpty()) {
234 map[QStringLiteral(
"type")] = d->m_types;
237 if (d->m_limit != defaultLimit) {
238 map[QStringLiteral(
"limit")] = d->m_limit;
242 map[QStringLiteral(
"offset")] = d->m_offset;
245 if (!d->m_searchString.isEmpty()) {
246 map[QStringLiteral(
"searchString")] = d->m_searchString;
249 if (d->m_term.isValid()) {
250 map[QStringLiteral(
"term")] =
QVariant(d->m_term.toVariantMap());
253 if (d->m_yearFilter >= 0) {
254 map[QStringLiteral(
"yearFilter")] = d->m_yearFilter;
256 if (d->m_monthFilter >= 0) {
257 map[QStringLiteral(
"monthFilter")] = d->m_monthFilter;
259 if (d->m_dayFilter >= 0) {
260 map[QStringLiteral(
"dayFilter")] = d->m_dayFilter;
263 if (d->m_sortingOption !=
SortAuto) {
264 map[QStringLiteral(
"sortingOption")] =
static_cast<int>(d->m_sortingOption);
266 if (!d->m_sortingProperty.isEmpty()) {
267 map[QStringLiteral(
"sortingProperty")] = d->m_sortingProperty;
270 if (!d->m_customOptions.isEmpty()) {
271 map[QStringLiteral(
"customOptions")] = d->m_customOptions;
287 query.d->m_types =
map[QStringLiteral(
"type")].toStringList();
289 if (
map.contains(QStringLiteral(
"limit"))) {
290 query.d->m_limit =
map[QStringLiteral(
"limit")].toUInt();
292 query.d->m_limit = defaultLimit;
295 query.d->m_offset =
map[QStringLiteral(
"offset")].toUInt();
296 query.d->m_searchString =
map[QStringLiteral(
"searchString")].toString();
297 query.d->m_term = Term::fromVariantMap(map[QStringLiteral(
"term")].
toMap());
299 if (
map.contains(QStringLiteral(
"yearFilter"))) {
300 query.d->m_yearFilter =
map[QStringLiteral(
"yearFilter")].toInt();
302 if (
map.contains(QStringLiteral(
"monthFilter"))) {
303 query.d->m_monthFilter =
map[QStringLiteral(
"monthFilter")].toInt();
305 if (
map.contains(QStringLiteral(
"dayFilter"))) {
306 query.d->m_dayFilter =
map[QStringLiteral(
"dayFilter")].toInt();
309 if (
map.contains(QStringLiteral(
"sortingOption"))) {
310 int option =
map.value(QStringLiteral(
"sortingOption")).toInt();
311 query.d->m_sortingOption =
static_cast<SortingOption
>(option);
314 if (
map.contains(QStringLiteral(
"sortingProperty"))) {
315 query.d->m_sortingProperty =
map.value(QStringLiteral(
"sortingProperty")).
toString();
318 if (
map.contains(QStringLiteral(
"customOptions"))) {
319 QVariant var =
map[QStringLiteral(
"customOptions")];
321 query.d->m_customOptions =
map[QStringLiteral(
"customOptions")].toMap();
323 QVariantHash hash = var.
toHash();
327 for (; it !=
end; ++it) {
328 query.d->m_customOptions.
insert(it.key(), it.value());
339 url.
setScheme(QStringLiteral(
"akonadisearch"));
352Query Query::fromSearchUrl(
const QUrl &url)
360 return Query::fromJSON(jsonString.
toUtf8());
369bool Query::operator==(
const Query &rhs)
const
371 if (rhs.d->m_limit != d->m_limit || rhs.d->m_offset != d->m_offset || rhs.d->m_dayFilter != d->m_dayFilter || rhs.d->m_monthFilter != d->m_monthFilter
372 || rhs.d->m_yearFilter != d->m_yearFilter || rhs.d->m_customOptions != d->m_customOptions || rhs.d->m_searchString != d->m_searchString
373 || rhs.d->m_sortingProperty != d->m_sortingProperty || rhs.d->m_sortingOption != d->m_sortingOption) {
377 if (rhs.d->m_types.size() != d->m_types.size()) {
381 for (
const QString &type :
std::as_const(rhs.d->m_types)) {
382 if (!d->m_types.contains(type)) {
387 return d->m_term == rhs.d->m_term;
@ SortProperty
The results are returned based on the explicit property specified.
@ SortAuto
The results are returned in the order the SearchStore decides should be ideal.
void setLimit(uint limit)
Only a maximum of limit results will be returned.
void addCustomOption(const QString &option, const QVariant &value)
Adds a custom option which any search backend could use to configure the query result.
void setDateFilter(int year, int month=-1, int day=-1)
Filter the results in the specified date range.
void addType(const QString &type)
Add a type to the results of the query.
void setSearchString(const QString &str)
Set some text which should be used to search for Items.
void setSortingProperty(const QString &property)
Sets the property that should be used for sorting.
virtual int exec(const Query &query)=0
Executes the particular query synchronously.
static List searchStores()
Gives a list of available search stores.
Akonadi search infrastructure.
char * toString(const EngineQuery &query)
const QVariantMap toMap(const MODEL &model)
KSERVICE_EXPORT KService::List query(FilterFunc filterFunc)
const QList< QKeySequence > & end()
QJsonDocument fromJson(const QByteArray &json, QJsonParseError *error)
QJsonObject object() const const
void setObject(const QJsonObject &object)
QByteArray toJson(JsonFormat format) const const
QJsonObject fromVariantMap(const QVariantMap &map)
QVariantMap toVariantMap() const const
iterator insert(const_iterator before, parameter_type value)
QString fromUtf8(QByteArrayView str)
bool isEmpty() const const
QByteArray toUtf8() const const
QFuture< void > map(Iterator begin, Iterator end, MapFunctor &&function)
QString scheme() const const
void setQuery(const QString &query, ParsingMode mode)
void setScheme(const QString &scheme)
void addQueryItem(const QString &key, const QString &value)
QString queryItemValue(const QString &key, QUrl::ComponentFormattingOptions encoding) const const
QHash< QString, QVariant > toHash() const const
int userType() const const