Improvements to the CrudModel

The new data of modified rows is now stored directly within the row_mapping
also changed how new rows are handled so the new empty row for inserting
is not a special case but is part of the list.

pglab/crud/CrudModel.h

@@ -0,0 +1,263 @@
+#ifndef CRUDMODEL_H
+#define CRUDMODEL_H
+
+#include "ASyncDBConnection.h"
+#include "Pgsql_Connection.h"
+
+#include "IntegerRange.h"
+#include "catalog/PgClass.h"
+#include "catalog/PgConstraint.h"
+#include <QAbstractTableModel>
+#include <map>
+#include <memory>
+#include <set>
+#include <tuple>
+#include <vector>
+#include <optional>
+
+class PgConstraint;
+class OpenDatabase;
+
+class CrudModel: public QAbstractTableModel {
+	Q_OBJECT
+public:
+	explicit CrudModel(QObject *parent = nullptr);
+	~CrudModel() override;
+
+	void setConfig(std::shared_ptr<OpenDatabase> db, const PgClass &table);
+
+
+	QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+
+
+	// Basic functionality:
+	int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+	int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+
+	virtual QVariant data(const QModelIndex &index, int role) const override;
+	virtual Qt::ItemFlags flags(const QModelIndex &) const override;
+
+	virtual bool setData(const QModelIndex &index, const QVariant &value, int role) override;
+
+	void loadData();
+
+	std::tuple<bool, QString> removeRows(const std::set<IntegerRange<int>> &row_ranges);
+	bool removeRows(int row, int count, const QModelIndex &parent = QModelIndex()) override;
+
+public slots:
+	virtual bool submit() override;
+	virtual void revert() override;
+
+private:
+	using PKeyValues = std::vector<std::string>;
+
+
+	class ColumnSort {
+	public:
+		enum Direction { Ascending, Descending };
+		enum NullSorting {
+			Default, ///< Behaves like NULL values are larger then non NULL values ASC NULLS LAST or DESC NULLS FIRST
+			First,
+			Last };
+
+		std::string columnName;
+		Direction direction = Direction::Ascending;
+		NullSorting nulls = NullSorting::Default;
+
+		std::string toSql() const
+		{
+			std::string res = columnName;
+			if (direction == Direction::Descending)
+				res += " DESC";
+			if (nulls == NullSorting::First)
+				res += " NULLS FIRST";
+			else if (nulls == NullSorting::Last)
+				res += " NULLS LAST";
+		}
+
+	};
+
+	using Value = std::optional<std::string>;
+
+	/** Similar to a modified row but it only stores values for columns that actually have been edited.
+	 *
+	 */
+	class PendingRow {
+	public:
+		using ValueMap = std::map<int, Value>;
+
+		explicit PendingRow(int row)
+			: m_row(row)
+		{}
+
+		const auto& data() const { return m_values; }
+
+		int row() const	{ return m_row; }
+
+		void setValue(int col, const Value &val)
+		{
+			m_values.insert_or_assign(col, val);
+		}
+
+	private:
+		int m_row;
+		ValueMap m_values;
+	};
+
+
+	class PendingRowList {
+	public:
+		using Map = std::map<int, PendingRow>;
+
+		PendingRow& getRow(int row)
+		{
+			auto iter = m_rows.lower_bound(row);
+			if (iter != m_rows.end() && iter->first == row) {
+				return iter->second;
+			}
+			else {
+				return m_rows.insert(iter, {row, PendingRow(row)})->second;
+			}
+		}
+
+		void setValue(int col, int row, const Value &value)
+		{
+			auto iter = m_rows.find(row);
+			if (iter == m_rows.end()) {
+				iter = m_rows.insert({row, PendingRow(row)}).first;
+			}
+			iter->second.setValue(col, value);
+		}
+
+		std::optional<Value> getValue(int col, int row) const
+		{
+			auto iter = m_rows.find(row);
+			if (iter != m_rows.end()) {
+				auto &r = iter->second;
+				auto cell = r.data().find(col);
+				if (cell != r.data().end())
+					return cell->second;
+
+			}
+			return std::nullopt;
+		}
+
+		auto begin() { return m_rows.begin(); }
+		auto end() { return m_rows.end(); }
+
+		void clear() { m_rows.clear(); }
+
+		Map m_rows;
+	};
+
+	class RowMapping {
+	public:
+		bool pending = false; ///< Row has pending changes, look first in pending for current data
+
+		int rowKey = -1; ///< value to use as key/index into the data lists
+
+		RowMapping() = default;
+        explicit RowMapping(int row_key, std::vector<Value> data)
+			: rowKey(row_key)
+            , modifiedRow(std::move(data))
+		{}
+
+        RowMapping(int row_key)
+            : rowKey(row_key)
+        {}
+
+        bool isModified() const
+        {
+            return !modifiedRow.empty();
+        }
+
+        Value modifiedValue(int columnIndex) const
+        {
+            return modifiedRow[columnIndex];
+        }
+
+        void setModifiedRowData(std::vector<Value> data)
+        {
+            modifiedRow = std::move(data);
+        }
+
+        bool isNew() const
+        {
+            // row in m_roData, thus it is not new
+            if (modifiedRow.empty())
+                return false;
+
+            // if all elements are empty then this is a new row
+            for (auto &c : modifiedRow)
+                if (c.has_value())
+                    return false;
+
+            return true;
+        }
+    private:
+        std::vector<Value> modifiedRow;
+	};
+
+	using RowMappingVector = std::vector<RowMapping>;
+
+	std::shared_ptr<OpenDatabase> m_database;
+	std::optional<PgClass> m_table;
+	std::optional<PgConstraint> m_primaryKey;
+	ASyncDBConnection m_dbConn;
+
+	bool callLoadData = false;
+
+	std::shared_ptr<Pgsql::Result> m_roData;
+
+	PendingRowList m_pendingRowList;
+
+	/// Keeps track of mapping grid rows to data rows
+    RowMappingVector m_rowMapping;
+
+    /// call on initial load to fill in the mappings
+	void initRowMapping();
+
+    Value getLatestData(int column, int row) const;
+    Value getLatestData(const QModelIndex &index) const
+    {
+        return getLatestData(index.column(), index.row());
+    }
+    Value getSavedData(int columnIndex, int rowIndex) const;
+    Value getSavedData(const RowMapping &row_mapping, int columnIndex) const;
+
+	Oid getType(int column) const;
+
+	QString columnName(int col) const;
+
+    /// Get the PKey values from when the row was last restored or retrieved.
+    Pgsql::Params getPKeyParamsForRow(int row) const;
+
+	bool savePendingChanges();
+
+    std::tuple<QString, Pgsql::Params> createUpdateQuery(const Pgsql::Params &pkey_params, const PendingRow &pending_row);
+	std::tuple<QString, Pgsql::Params> createInsertQuery(const PendingRow &pending_row);
+	std::tuple<QString, Pgsql::Params> createDeleteStatement(const PKeyValues &pkey_values);
+
+	QString createDeleteStatement() const;
+    std::tuple<bool, std::vector<Value>> saveRow(const PendingRow &pending_row);
+
+	void appendNewRow();
+
+    int lastRowKey = -1;
+	int allocNewRowKey() { return ++lastRowKey; }
+	/// Convert an attnum from the database catalog to the corresponding column in the model
+	///
+	/// \todo still assumes columns are in order, all being shown and no special column like oid shown.
+	int attNumToCol(int attnum) const { return attnum - 1; }
+
+    void RemoveRangesOfRowsFromModel(const std::set<IntegerRange<int>> &row_ranges);
+    void RemoveRangeOfRowsFromModel(IntegerRange<int> row_range);
+
+    bool IsLastRow(RowMappingVector::iterator mapping_iter) const;
+private slots:
+
+	void loadIntoModel(std::shared_ptr<Pgsql::Result> data);
+	void connectionStateChanged(ASyncDBConnection::State state);
+};
+
+#endif // CRUDMODEL_H