#3035 The INSTEAD OF triggers on Views are now honored when present. Add/Delete row in the View Window now appears if respective INSTEAD OF trigger is present for the View.

Author: Paweł Salawa

ChangeLog.md

@@ -47,6 +47,7 @@
 - ADDED: #5290 Execute From File Dialog now supports 3 execution modes, allowing SQLite CLI dot commands in the executed file.
 - ADDED: #4873 Execute From File Dialog remembers its settings for another use.
 - ADDED: #4225 Foreign Key constraint configuration dialogs now warns about using foreign column that is neither PRIMARY KEY nor UNIQUE.
+- ADDED: #3035 The INSTEAD OF triggers on Views are now honored when present. Add/Delete row in the View Window now appears if respective INSTEAD OF trigger is present for the View.
 - ADDED: #5085 Added 'Cut' entry to context menu of data Grid View.
 - ADDED: #4709 Added option in configuration to sort data by single-click on a header. Ehnanced data header tooltips to include this information there.
 - ADDED: #3566 Added option in configuration to make the Enter key move to the next row, if it was used to finish data editing in Grid View. The option is also available from the Grid's context menu.

Letos/gui/datagrid/sqldatasourcequerymodel.cpp

@@ -1,5 +1,6 @@
 #include "sqldatasourcequerymodel.h"
 #include "common/utils_sql.h"
+#include "services/notifymanager.h"
 
 SqlDataSourceQueryModel::SqlDataSourceQueryModel(QObject *parent) :
     SqlQueryModel(parent)
@@ -88,6 +89,132 @@ QString SqlDataSourceQueryModel::regExpFilterValueProcessor(const QString& value
     return pattern.arg(escapeString(value));
 }
 
+bool SqlDataSourceQueryModel::commitAddedRow(const QList<SqlQueryItem*>& itemsInRow, QList<CommitSuccessfulHandler>& successfulCommitHandlers)
+{
+    if (columns.size() != itemsInRow.size())
+    {
+        qCritical() << "Tried to SqlDataSourceQueryModel::commitAddedRow() with number of columns in argument different than model resolved for the table.";
+        return false;
+    }
+
+    // Check that just in case:
+    if (columns.size() == 0)
+    {
+        qCritical() << "Tried to SqlDataSourceQueryModel::commitAddedRow() with number of resolved columns in the table equal to 0!";
+        return false;
+    }
+
+    // Prepare column placeholders and their values
+    QStringList colNameList;
+    QStringList bindParams;
+    QList<QVariant> args;
+    prepareColumnsAndBindParams(itemsInRow, colNameList, bindParams, args);
+
+    // Prepare SQL query
+    QString sql = getInsertSql(colNameList, bindParams);
+
+    // Execute query
+    SqlQueryPtr result = db->exec(sql, args);
+
+    // Handle error
+    if (result->isError())
+    {
+        QString errMsg = tr("Error while committing new row: %1").arg(result->getErrorText());
+        for (SqlQueryItem* item : itemsInRow)
+            item->setCommittingError(true, errMsg);
+
+        notifyError(errMsg);
+        return false;
+    }
+
+    // Take values from RETURNING clause to get actual values (because of DEFAULT, AUTOINCR).
+    QList<SqlResultsRowPtr> rows = result->getAll();
+    if (rows.size() != 1)
+    {
+        qCritical() << "After inserting new row to the table, number of rows returned from the query != 1. This should not happen. Number:" << rows.size();
+        return false;
+    }
+
+    QList<QVariant> rowValues = rows.first()->valueList();
+    if (columns.size() != rowValues.size())
+    {
+        qCritical() << "Tried to SqlDataSourceQueryModel::commitAddedRow() with number of columns in argument different than RETURNING values from the INSERT.";
+        return false;
+    }
+
+    return commitAddedRowPostprocess(itemsInRow, rowValues, result->getInsertRowId(), successfulCommitHandlers);
+}
+
+bool SqlDataSourceQueryModel::commitDeletedRow(const QList<SqlQueryItem*>& itemsInRow, QList<CommitSuccessfulHandler>& successfulCommitHandlers)
+{
+    if (itemsInRow.size() == 0)
+    {
+        qCritical() << "Tried to SqlDataSourceQueryModel::commitDeletedRow() with number of items equal to 0!";
+        return false;
+    }
+
+    RowId rowId = getRowIdForRow(itemsInRow);
+    if (rowId.isEmpty())
+        return false;
+
+    CommitDeleteQueryBuilder queryBuilder;
+    queryBuilder.setTableOrView(getTableOrView());
+    queryBuilder.setRowId(rowId);
+
+    QString sql = queryBuilder.build();
+    QHash<QString, QVariant> args = queryBuilder.getQueryArgs();
+
+    SqlQueryPtr result = db->exec(sql, args);
+    if (result->isError())
+    {
+        QString errMsg = tr("Error while deleting row from %1: %2").arg(getTableOrView(), result->getErrorText());
+        for (SqlQueryItem* item : itemsInRow)
+            item->setCommittingError(true, errMsg);
+
+        notifyError(errMsg);
+        return false;
+    }
+
+    if (!SqlQueryModel::commitDeletedRow(itemsInRow, successfulCommitHandlers))
+        qCritical() << "Could not delete row from SqlQueryView while committing row deletion.";
+
+    return commitDeletedRowPostprocess(itemsInRow, result->getAll().size(), successfulCommitHandlers);
+}
+
+QString SqlDataSourceQueryModel::getInsertSql(QStringList& colNameList, QStringList& sqlValues)
+{
+    static_qstring(insertTpl, "INSERT INTO %1 %2 %3 RETURNING *");
+    static_qstring(valuesTpl, "VALUES (%1)");
+    static_qstring(columnsTpl, "(%1)");
+
+    QString wrappedTableName = getDataSource();
+    QString colNames = colNameList.join(", ");
+    if (colNameList.isEmpty())
+        return insertTpl.arg(wrappedTableName, "", "DEFAULT VALUES");
+    else
+        return insertTpl.arg(wrappedTableName, columnsTpl.arg(colNames), valuesTpl.arg(sqlValues.join(", ")));
+}
+
+void SqlDataSourceQueryModel::prepareColumnsAndBindParams(const QList<SqlQueryItem*>& itemsInRow, QStringList& colNameList,
+                                           QStringList& bindParams, QList<QVariant>& args)
+{
+    SqlQueryItem* item = nullptr;
+    int i = 0;
+    for (SqlQueryModelColumnPtr& modelColumn : columns)
+    {
+        item = itemsInRow[i++];
+        if (!modelColumn->canEdit())
+            continue;
+
+        if (item->isUntouched() && modelColumn->hasDefaultValueForInsert())
+            continue;
+
+        colNameList << wrapObjIfNeeded(modelColumn->column);
+        bindParams << ":arg" + QString::number(i);
+        args << item->getValue();
+    }
+}
+
 void SqlDataSourceQueryModel::applySqlFilter(const QString& value)
 {
     if (value.isEmpty())
@@ -146,7 +273,34 @@ QString SqlDataSourceQueryModel::getDatabasePrefix()
     return wrapObjIfNeeded(database) + ".";
 }
 
-QString SqlDataSourceQueryModel::getDataSource()
+QString SqlDataSourceQueryModel::CommitDeleteQueryBuilder::build()
+{
+    QString dbAndTable;
+    if (!database.isNull())
+        dbAndTable += database+".";
+
+    dbAndTable += tableOrView;
+    QString conditions = RowIdConditionBuilder::build();
+
+    static_qstring(sql, "DELETE FROM %1 WHERE %2 RETURNING 1;");
+    return sql.arg(dbAndTable, conditions);
+}
+
+
+QString SqlDataSourceQueryModel::SelectColumnsQueryBuilder::build()
+{
+    QString dbAndTable;
+    if (!database.isNull())
+        dbAndTable += database+".";
+
+    dbAndTable += tableOrView;
+    QString conditions = RowIdConditionBuilder::build();
+
+    static_qstring(sql, "SELECT %1 FROM %2 WHERE %3 LIMIT 1;");
+    return sql.arg(columns.join(", "), dbAndTable, conditions);
+}
+
+void SqlDataSourceQueryModel::SelectColumnsQueryBuilder::addColumn(const QString& col)
 {
-    return QString();
+    columns << col;
 }

Letos/gui/datagrid/sqldatasourcequerymodel.h

@@ -4,6 +4,9 @@
 #include "gui_global.h"
 #include "sqlquerymodel.h"
 
+/**
+ * @brief The SqlDataSourceQueryModel class is an abstract class for models that are based on a single data source, like a table or a view.
+ */
 class GUI_API_EXPORT SqlDataSourceQueryModel : public SqlQueryModel
 {
     public:
@@ -23,23 +26,53 @@ class GUI_API_EXPORT SqlDataSourceQueryModel : public SqlQueryModel
         void resetFilter();
 
     protected:
+        class CommitDeleteQueryBuilder : public CommitUpdateQueryBuilder
+        {
+            public:
+                QString build();
+        };
+
+        class SelectColumnsQueryBuilder : public CommitUpdateQueryBuilder
+        {
+            public:
+                QString build();
+                void addColumn(const QString& col);
+        };
+
         typedef std::function<QString(const QString&)> FilterValueProcessor;
 
         static QString stringFilterValueProcessor(const QString& value);
         static QString strictFilterValueProcessor(const QString& value);
         static QString regExpFilterValueProcessor(const QString& value);
 
+        bool commitAddedRow(const QList<SqlQueryItem*>& itemsInRow, QList<CommitSuccessfulHandler>& successfulCommitHandlers);
+        bool commitDeletedRow(const QList<SqlQueryItem*>& itemsInRow, QList<CommitSuccessfulHandler>& successfulCommitHandlers);
+        void prepareColumnsAndBindParams(const QList<SqlQueryItem*>& itemsInRow,
+                                    QStringList& colNameList, QStringList& sqlValues, QList<QVariant>& args);
+        QString getInsertSql(QStringList& colNameList, QStringList& sqlValues);
+        QString getDatabasePrefix();
         void applyFilter(const QString& value, FilterValueProcessor valueProc);
         void applyFilter(const QStringList& values, FilterValueProcessor valueProc);
 
-        QString getDatabasePrefix();
+        virtual bool commitAddedRowPostprocess(const QList<SqlQueryItem*>& itemsInRow, const QList<QVariant>& rowValues, const RowId& rowId,
+                                        QList<SqlQueryModel::CommitSuccessfulHandler>& successfulCommitHandlers) = 0;
+        virtual bool commitDeletedRowPostprocess(const QList<SqlQueryItem*>& itemsInRow, int deletedRowCount,
+                                        QList<SqlQueryModel::CommitSuccessfulHandler>& successfulCommitHandlers) = 0;
+        virtual RowId getRowIdForRow(const QList<SqlQueryItem*>& itemsInRow) = 0;
 
         /**
          * @brief Get the data source for this object.
          * Default implementation returns an empty string. Working implementation
-         * (i.e. for a table) should return the data source string.
+         * (i.e. for a table) should return the data source string (i.e. dbname.table),
+         * both parts of name already wrapped if needed.
+         */
+        virtual QString getDataSource() = 0;
+
+        /**
+         * @brief Just table or view part of the datasource
+         * @return
          */
-        virtual QString getDataSource();
+        virtual QString getTableOrView() = 0;
 
         QString database;
 };

Letos/gui/datagrid/sqlquerymodel.cpp

@@ -509,7 +509,7 @@ void SqlQueryModel::refreshGeneratedColumns(const QList<SqlQueryItem*>& items, Q
             continue;
 
         builder.setDatabase(wrapObjIfNeeded(table.getDatabase()));
-        builder.setTable(wrapObjIfNeeded(table.getTable()));
+        builder.setTableOrView(wrapObjIfNeeded(table.getTable()));
 
         QHash<RowId, QSet<SqlQueryItem*>> itemsPerRowId;
         for (SqlQueryItem* item : itemsIt.value())
@@ -538,7 +538,7 @@ QHash<SqlQueryItem*, QVariant> SqlQueryModel::readCellValues(SelectCellsQueryBui
     // Handling error
     if (results->isError())
     {
-        qCritical() << "Could not load cell values for table" << queryBuilder.getTable() << ", so defaulting them with NULL. Error from database was:"
+        qCritical() << "Could not load cell values for table" << queryBuilder.getTableOrView() << ", so defaulting them with NULL. Error from database was:"
                     << results->getErrorText();
 
         for (SqlQueryItem* item : concatSet(itemsPerRowId.values()))
@@ -549,7 +549,7 @@ QHash<SqlQueryItem*, QVariant> SqlQueryModel::readCellValues(SelectCellsQueryBui
 
     if (!results->hasNext())
     {
-        qCritical() << "Could not load cell values for table" << queryBuilder.getTable() << ", so defaulting them with NULL. There were no result rows.";
+        qCritical() << "Could not load cell values for table" << queryBuilder.getTableOrView() << ", so defaulting them with NULL. There were no result rows.";
 
         for (SqlQueryItem* item : concatSet(itemsPerRowId.values()))
             values[item] = QVariant();
@@ -563,7 +563,7 @@ QHash<SqlQueryItem*, QVariant> SqlQueryModel::readCellValues(SelectCellsQueryBui
         SqlResultsRowPtr row = results->next();
         if (row->valueList().size() != queryBuilder.getColumnCount())
         {
-            qCritical() << "Could not load cell values for table" << queryBuilder.getTable() << ", so defaulting them with NULL. Number of columns from results was invalid:"
+            qCritical() << "Could not load cell values for table" << queryBuilder.getTableOrView() << ", so defaulting them with NULL. Number of columns from results was invalid:"
                         << row->valueList().size() << ", while expected:" << queryBuilder.getColumnCount();
 
             for (SqlQueryItem* item : concatSet(itemsPerRowId.values()))
@@ -880,7 +880,7 @@ bool SqlQueryModel::commitEditedRow(const QList<SqlQueryItem*>& itemsInRow, QLis
         queryBuilder.setRowId(rowId);
 
         // Database and table
-        queryBuilder.setTable(wrapObjIfNeeded(table.getTable()));
+        queryBuilder.setTableOrView(wrapObjIfNeeded(table.getTable()));
         if (!table.getDatabase().isNull())
         {
             QString tableDb = getDatabaseForCommit(table.getDatabase());
@@ -2228,7 +2228,7 @@ bool SqlQueryModel::isExecutionInProgress() const
 void SqlQueryModel::CommitUpdateQueryBuilder::clear()
 {
     database.clear();
-    table.clear();
+    tableOrView.clear();
     columns.clear();
     queryArgs.clear();
     conditions.clear();
@@ -2240,9 +2240,9 @@ void SqlQueryModel::CommitUpdateQueryBuilder::setDatabase(const QString& databas
     this->database = database;
 }
 
-void SqlQueryModel::CommitUpdateQueryBuilder::setTable(const QString& table)
+void SqlQueryModel::CommitUpdateQueryBuilder::setTableOrView(const QString& tableOrView)
 {
-    this->table = table;
+    this->tableOrView = tableOrView;
 }
 
 void SqlQueryModel::CommitUpdateQueryBuilder::setColumn(const QString& column)
@@ -2279,7 +2279,7 @@ QString SqlQueryModel::CommitUpdateQueryBuilder::build()
     if (!database.isNull())
         dbAndTable += database + ".";
 
-    dbAndTable += table;
+    dbAndTable += tableOrView;
 
     int argIndex = 0;
     QString arg;
@@ -2337,7 +2337,7 @@ QString SqlQueryModel::SelectCellsQueryBuilder::build()
     if (!database.isNull())
         dbAndTable += database + ".";
 
-    dbAndTable += table;
+    dbAndTable += tableOrView;
 
     QStringList selectColumns;
     for (const QString& col : columns)
@@ -2364,7 +2364,7 @@ QString SqlQueryModel::SelectCellsQueryBuilder::build()
 void SqlQueryModel::SelectCellsQueryBuilder::clear()
 {
     database = QString();
-    table = QString();
+    tableOrView = QString();
     rowIdColumns.clear();
     columns.clear();
     conditions.clear();
@@ -2378,9 +2378,9 @@ void SqlQueryModel::SelectCellsQueryBuilder::setDatabase(const QString& database
     this->database = database;
 }
 
-void SqlQueryModel::SelectCellsQueryBuilder::setTable(const QString& table)
+void SqlQueryModel::SelectCellsQueryBuilder::setTableOrView(const QString& tableOrView)
 {
-    this->table = table;
+    this->tableOrView = tableOrView;
 }
 
 void SqlQueryModel::SelectCellsQueryBuilder::addColumn(const QString& column)
@@ -2402,9 +2402,9 @@ int SqlQueryModel::SelectCellsQueryBuilder::getColumnCount() const
     return columns.size();
 }
 
-QString SqlQueryModel::SelectCellsQueryBuilder::getTable() const
+QString SqlQueryModel::SelectCellsQueryBuilder::getTableOrView() const
 {
-    return table;
+    return tableOrView;
 }
 
 QString SqlQueryModel::SelectCellsQueryBuilder::getDatabase() const