EasyQtSql_QueryResult.h

Go to the documentation of this file.

#ifndef EASYQTSQL_QUERYRESULT_H
#define EASYQTSQL_QUERYRESULT_H

/*
 * The MIT License (MIT)
 * Copyright 2018 Alexey Kramin
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
*/

#ifndef EASY_QT_SQL_MAIN

#include <QtSql>
#include "EasyQtSql_NonQueryResult.h"

#endif

class  QueryResult
{
   friend class Database;
   friend class Transaction;
   friend class PreparedQuery;   

public:

   QSqlQuery &unwrappedQuery()
   {
      return m_query;
   }

   bool next()
   {
      bool res = m_query.next();

      if ( ! m_firstRowFetched)
      {
         m_fieldNames.clear();

         QSqlRecord record = m_query.record();

         for (int i = 0; i < record.count(); ++i)
         {
            m_fieldNames.append(record.fieldName(i));
         }

         m_firstRowFetched = true;
      }

      return res;
   }

   bool previous()
   {
      return m_query.previous();
   }

   bool nextResult()
   {
      m_firstRowFetched = false;

      bool res = m_query.nextResult();

      return res;
   }

   bool first()
   {
      return m_query.first();
   }

   bool last()
   {
      return m_query.last();
   }

   bool seek(int index, bool relative = false)
   {
      return m_query.seek(index, relative);
   }

   int at() const
   {
      return m_query.at();
   }

   bool isActive() const
   {
      return m_query.isActive();
   }

   bool isValid() const
   {
      return m_query.isValid();
   }

   bool isForwardOnly() const
   {
      return m_query.isForwardOnly();
   }

   int size() const
   {
      return m_query.size();
   }

   int numRowsAffected() const
   {
      return m_query.numRowsAffected();
   }

   QSqlError lastError() const
   {
      return m_query.lastError();
   }

   QString lastQuery() const
   {
      return m_query.lastQuery();
   }

   QString executedQuery() const
   {
      return m_query.executedQuery();
   }

   QVariant value(int column) const
   {
      return m_query.value(column);
   }

   QVariant value(const QString &colName) const
   {
      return m_query.value(colName);
   }

   QVariant boundValue(int column) const
   {
      return m_query.boundValue(column);
   }

   QVariant boundValue(const QString &aliasName) const
   {
      const int index = m_bindValueAlias.value(aliasName.trimmed().toLower(), -1);

      QVariant res;

      if (index >= 0)
      {
         res = boundValue(index);
      }

      return res;
   }

   QVariantList boundValues() const
   {
      QList<QVariant> list = m_query.boundValues().values();

      return list;
   }

   QVariantMap toMap() const
   {
      QVariantMap res;

      fetchMap(res);

      return res;
   }

   QVariantList toList() const
   {
      QVariantList res;

      fetchList(res);

      return res;
   }

   QStringList toStringList() const
   {
      QStringList res;

      fetchStringList(res);

      return res;
   }

   QVector<QVariant> toVector() const
   {
      QVector<QVariant> res;

      fetchVector(res);

      return res;
   }

   template <typename T>
   QVector<T> toVector(bool skipNullValues = false) const
   {
      QVector<T> res;

      res.reserve(m_fieldNames.count());

      for (int i = 0; i < m_fieldNames.count(); ++i)
      {
         const QVariant &value = m_query.value(i);

         if (!value.canConvert<T>())
            continue;

         if (skipNullValues && value.isNull())
            continue;

         res.append(value.value<T>());
      }

      return res;
   }

   QVector<int> parseToIntVector(int base = 10, bool skipNullValues = false) const
   {
      QVector<int> res;

      res.reserve(m_fieldNames.count());

      for (int i = 0; i < m_fieldNames.count(); ++i)
      {
         const QVariant &value = m_query.value(i);

         if (!value.canConvert<int>())
            continue;

         if (skipNullValues && value.isNull())
            continue;

         bool ok = false;
         int iValue = 0;

         if ( ((value.type() == QVariant::String) || (value.type() == QVariant::ByteArray)))
         {
            const QString str = value.toString();

            iValue = str.toInt(&ok, base);
         }
         else
         {
            iValue = value.toInt(&ok);
         }

         if (ok)
         {
            res.append(iValue);
         }
      }

      return res;
   }

   template <typename T>
   T scalar() const
   {
      return m_query.value(0).value<T>();
   }

   QVariant scalar() const
   {
      return m_query.value(0);
   }

   void fetchVars(int &value) const
   {
      value = m_query.value(m_fetchIndex).toInt();

      m_fetchIndex = 0;
   }

   void fetchVars(double &value) const
   {
      value = m_query.value(m_fetchIndex).toInt();

      m_fetchIndex = 0;
   }

   void fetchVars(QString &value) const
   {
      value = m_query.value(m_fetchIndex).toString();

      m_fetchIndex = 0;
   }

   void fetchVars(bool &value) const
   {
      value = m_query.value(m_fetchIndex).toBool();

      m_fetchIndex = 0;
   }

   void fetchVars(QDate &value) const
   {
      value = m_query.value(m_fetchIndex).toDate();

      m_fetchIndex = 0;
   }

   void fetchVars(QDateTime &value) const
   {
      value = m_query.value(m_fetchIndex).toDateTime();

      m_fetchIndex = 0;
   }

   void fetchVars(QTime &value) const
   {
      value = m_query.value(m_fetchIndex).toTime();

      m_fetchIndex = 0;
   }

   void fetchVars(QByteArray &value) const
   {
      value = m_query.value(m_fetchIndex).toByteArray();

      m_fetchIndex = 0;
   }

   void fetchVars(QVariant &value) const
   {
      value = m_query.value(m_fetchIndex);

      m_fetchIndex = 0;
   }

   template <typename... Rest> void fetchVars(int &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toInt();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(double &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toDouble();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(QString &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toString();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(bool &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toBool();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(QDate &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toDate();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(QDateTime &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toDateTime();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(QTime &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toTime();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(QByteArray &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++).toByteArray();

      fetchVars(rest...);
   }

   template <typename... Rest> void fetchVars(QVariant &value, Rest&... rest) const
   {
      value = m_query.value(m_fetchIndex++);

      fetchVars(rest...);
   }

   void fetchObject(QObject &object) const
   {
      const QMetaObject *metaobject = object.metaObject();
      const int count = metaobject->propertyCount();

      const QVariantMap map = toMap();

      for (int i = 0; i < count; ++i)
      {
         QMetaProperty metaproperty = metaobject->property(i);

         if (metaproperty.isWritable())
         {
            QLatin1String sName(metaproperty.name());

            if (map.contains(sName))
            {
               object.setProperty(sName.data(), map.value(sName));
            }
         }
      }
   }

   template<typename T>
   void fetchGadget(T &gadget) const
   {
      const QMetaObject &metaobject = gadget.staticMetaObject;

      const int count = metaobject.propertyCount();

      const QVariantMap map = toMap();

      for (int i = 0; i < count; ++i)
      {
         QMetaProperty metaproperty = metaobject.property(i);

         if (metaproperty.isWritable())
         {
            QLatin1String sName(metaproperty.name());

            if (map.contains(sName))
            {
               metaproperty.writeOnGadget(&gadget, map.value(sName));
            }
         }
      }
   }

   void fetchMap(QVariantMap &map) const
   {
      map.clear();

      for (int i = 0; i < m_fieldNames.count(); ++i)
      {
         map.insert(m_fieldNames.at(i), m_query.value(i));
      }
   }

   void fetchList(QVariantList &list) const
   {
      list.clear();

      for (int i = 0; i < m_fieldNames.count(); ++i)
      {
         list.append(m_query.value(i));
      }
   }

   void fetchVector(QVector<QVariant> &vector) const
   {
      vector.clear();
      vector.reserve(m_fieldNames.count());

      for (int i = 0; i < m_fieldNames.count(); ++i)
      {
         vector.append(m_query.value(i));
      }
   }

   void fetchStringList(QStringList &list) const
   {
      list.clear();

      for (int i = 0; i < m_fieldNames.count(); ++i)
      {
         list.append(m_query.value(i).toString());
      }
   }

private:

   QueryResult()
   { }

   explicit QueryResult(const QSqlQuery &query)
    : m_query(query)
   { }

   QueryResult(const QSqlQuery &query, const QMap<QString, int> &bindValueAliasMap)
    : m_query(query)
    , m_bindValueAlias(bindValueAliasMap)
   { }

private:
   QSqlQuery   m_query;
   QStringList m_fieldNames;
   QMap<QString, int> m_bindValueAlias;
   mutable int m_fetchIndex = 0;
   bool m_firstRowFetched = false;
};

#endif // EASYQTSQL_QUERYRESULT_H