Basic support for update in Crud implementation, error reporting and transfering data to modified set is still missing.
This commit is contained in:
eelke
parent
3fb32f1200
commit
d626c19e14
15 changed files with 530 additions and 83 deletions
|
|
@ -7,17 +7,19 @@
|
|||
#include "GlobalIoService.h"
|
||||
#include "SqlFormattingUtils.h"
|
||||
#include "WorkManager.h"
|
||||
#include "Pgsql_oids.h"
|
||||
#include <QtConcurrent>
|
||||
#include <QFuture>
|
||||
#include <QFutureWatcher>
|
||||
#include "Pgsql_oids.h"
|
||||
|
||||
#include "Pgsql_Params.h"
|
||||
#include <string>
|
||||
|
||||
CrudModel::CrudModel(ASyncWindow *async_window)
|
||||
: m_asyncWindow(async_window)
|
||||
, m_dbConn(*getGlobalAsioIoService())
|
||||
{
|
||||
qDebug("CrudModel created");
|
||||
connect(&m_dbConn, &ASyncDBConnection::onStateChanged, this, &CrudModel::connectionStateChanged);
|
||||
}
|
||||
|
||||
|
|
@ -26,7 +28,6 @@ CrudModel::~CrudModel()
|
|||
m_dbConn.closeConnection();
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Strategy
|
||||
* when ordered by primary key, offset and limit work very quickly so we can get away with not loading
|
||||
|
|
@ -61,13 +62,13 @@ QVariant CrudModel::headerData(int section, Qt::Orientation orientation, int rol
|
|||
|
||||
|
||||
// Basic functionality:
|
||||
int CrudModel::rowCount(const QModelIndex &parent) const
|
||||
int CrudModel::rowCount(const QModelIndex &/*parent*/) const
|
||||
{
|
||||
|
||||
return m_roData ? m_roData->rows() : 0;
|
||||
}
|
||||
|
||||
int CrudModel::columnCount(const QModelIndex &parent) const
|
||||
int CrudModel::columnCount(const QModelIndex &/*parent*/) const
|
||||
{
|
||||
return m_roData ? m_roData->cols() : 0;
|
||||
}
|
||||
|
|
@ -77,40 +78,82 @@ Oid CrudModel::getType(int column) const
|
|||
return m_roData ? m_roData->type(column) : InvalidOid;
|
||||
}
|
||||
|
||||
QVariant CrudModel::getData(const QModelIndex &index) const
|
||||
CrudModel::Value CrudModel::getData(const QModelIndex &index) const
|
||||
{
|
||||
QVariant r;
|
||||
Value value;
|
||||
if (m_roData) {
|
||||
int rij = index.row();
|
||||
int col = index.column();
|
||||
if (m_roData->null(col, rij)) {
|
||||
r = "null";
|
||||
}
|
||||
else {
|
||||
Oid o = m_roData->type(col);
|
||||
auto value = m_roData->get(col, rij);
|
||||
switch (o) {
|
||||
case Pgsql::bool_oid:
|
||||
r = bool(value); //s = (s == "t") ? "TRUE" : "FALSE";
|
||||
break;
|
||||
default: {
|
||||
QString s = value;
|
||||
if (s.length() > 256) {
|
||||
s.truncate(256);
|
||||
}
|
||||
r = s;
|
||||
}
|
||||
|
||||
//Oid o = m_roData->type(col);
|
||||
// First see if we have buffered editted values that still need saving
|
||||
boost::optional<Value> val = m_pendingRowList.getValue(col, rij);
|
||||
if (!val) {
|
||||
// No pending save have a look if we have modified saved data in the modified list
|
||||
auto find_res = m_modifiedRowList.find(rij);
|
||||
if (find_res != m_modifiedRowList.end()) {
|
||||
val = find_res->second.data()[col];
|
||||
}
|
||||
}
|
||||
|
||||
//Value value;
|
||||
// If we did not have pending or modified data
|
||||
if (!val) {
|
||||
// Then we are going to read the original data.
|
||||
if (!m_roData->null(col, rij)) {
|
||||
value = std::string(m_roData->val(col, rij));
|
||||
}
|
||||
}
|
||||
else {
|
||||
value = *val;
|
||||
}
|
||||
}
|
||||
return r;
|
||||
return value;
|
||||
}
|
||||
|
||||
QVariant CrudModel::data(const QModelIndex &index, int role) const
|
||||
{
|
||||
QVariant v;
|
||||
if (role == Qt::EditRole || role == Qt::DisplayRole) {
|
||||
v = getData(index);
|
||||
if (role == Qt::EditRole) {
|
||||
// int row = index.row();
|
||||
// if (m_pendingChanges.needsToSave(row)) {
|
||||
//// if (savePendingChanges())
|
||||
//// startEditingRow();
|
||||
// }
|
||||
auto value = getData(index);
|
||||
if (value) {
|
||||
// Oid o = m_roData->type(index.column());
|
||||
// if (o == Pgsql::bool_oid) {
|
||||
// v = *value == "t"; //s = (s == "t") ? "TRUE" : "FALSE";
|
||||
// }
|
||||
// else {
|
||||
QString s = QString::fromUtf8(value->c_str());
|
||||
v = s;
|
||||
// }
|
||||
}
|
||||
|
||||
}
|
||||
else if (role == Qt::DisplayRole) {
|
||||
auto value = getData(index);
|
||||
if (value) {
|
||||
Oid o = m_roData->type(index.column());
|
||||
if (o == Pgsql::bool_oid) {
|
||||
if (value)
|
||||
v = *value == "t"; //s = (s == "t") ? "TRUE" : "FALSE";
|
||||
else
|
||||
v = "null";
|
||||
}
|
||||
else {
|
||||
QString s = QString::fromUtf8(value->c_str());
|
||||
if (s.length() > 256) {
|
||||
s.truncate(256);
|
||||
}
|
||||
v = s;
|
||||
}
|
||||
}
|
||||
else {
|
||||
v = "null";
|
||||
}
|
||||
}
|
||||
else if (role == Qt::UserRole) {
|
||||
v = getType(index.column());
|
||||
|
|
@ -176,3 +219,163 @@ Qt::ItemFlags CrudModel::flags(const QModelIndex &) const
|
|||
{
|
||||
return Qt::ItemIsSelectable + Qt::ItemIsEditable + Qt::ItemIsEnabled;
|
||||
}
|
||||
|
||||
bool CrudModel::setData(const QModelIndex &index, const QVariant &value, int role)
|
||||
{
|
||||
if (role == Qt::EditRole) {
|
||||
int row = index.row();
|
||||
int col = index.column();
|
||||
//m_pendingRowList.getRow(row);
|
||||
|
||||
Value val;
|
||||
// Oid o = m_roData->type(index.column());
|
||||
// if (o == Pgsql::bool_oid) {
|
||||
// val = value.Bool ? "t" : "f";
|
||||
// }
|
||||
// else {
|
||||
std::string s = value.toString().toUtf8().data();
|
||||
if (!s.empty()) {
|
||||
if (s == "''")
|
||||
s.clear();
|
||||
val = s;
|
||||
}
|
||||
// }
|
||||
m_pendingRowList.setValue(col, row, val);
|
||||
|
||||
emit dataChanged(index, index, QVector<int>() << role);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
const CrudModel::ModifiedRow* CrudModel::getModifiedRow(int row) const
|
||||
{
|
||||
auto iter = m_modifiedRowList.find(row);
|
||||
if (iter == m_modifiedRowList.end())
|
||||
return nullptr;
|
||||
else
|
||||
return &iter->second;
|
||||
}
|
||||
|
||||
CrudModel::PKeyValues CrudModel::getPKeyForRow(int row) const
|
||||
{
|
||||
PKeyValues values;
|
||||
values.reserve(m_primaryKey->fkey.size());
|
||||
|
||||
auto mod_row = getModifiedRow(row);
|
||||
if (mod_row){
|
||||
for (auto attnum : m_primaryKey->key) {
|
||||
int col = attnum - 1; // Assume column ordering matches table, also we assume know special columns like oid are shown
|
||||
values.push_back(*(mod_row->data()[col]));
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (auto attnum : m_primaryKey->key) {
|
||||
int col = attnum - 1; // Assume column ordering matches table, also we assume know special columns like oid are shown
|
||||
values.push_back(m_roData->get(col, row).c_str());
|
||||
}
|
||||
}
|
||||
|
||||
return values;
|
||||
}
|
||||
|
||||
QString CrudModel::columnName(int col) const
|
||||
{
|
||||
return m_roData->getColName(col);
|
||||
}
|
||||
|
||||
|
||||
|
||||
void CrudModel::updateRow(const PendingRow &pending_row)
|
||||
{
|
||||
auto pkey_values = getPKeyForRow(pending_row.row());
|
||||
|
||||
QString buffer;
|
||||
QTextStream q(&buffer);
|
||||
q << "UPDATE ";
|
||||
q << genFQTableName(*m_database->catalogue(), m_table);
|
||||
q << " AS d\n SET ";
|
||||
|
||||
auto data = pending_row.data();
|
||||
Pgsql::Params params;
|
||||
if (!data.empty()) {
|
||||
int param = 0;
|
||||
for (auto e : data) {
|
||||
if (param > 0)
|
||||
q << ",";
|
||||
|
||||
q << quoteIdent(columnName(e.first))
|
||||
<< "=$" << ++param;
|
||||
|
||||
if (e.second)
|
||||
params.add(e.second->c_str(), getType(e.first));
|
||||
else
|
||||
params.add(nullptr, getType(e.first));
|
||||
}
|
||||
|
||||
q << "\nWHERE ";
|
||||
int i = 0;
|
||||
for (auto attnum : m_primaryKey->key) {
|
||||
int col = attnum - 1; // Assume column ordering matches table, also we assume know special columns like oid are shown
|
||||
params.add(pkey_values[i].c_str(), getType(col));
|
||||
if (i > 0)
|
||||
q << " AND ";
|
||||
q << quoteIdent(columnName(col)) << "=$" << ++param;
|
||||
++i;
|
||||
}
|
||||
q << "\nRETURNING *";
|
||||
q.flush();
|
||||
|
||||
|
||||
m_dbConn.send(buffer.toUtf8().data(), params,
|
||||
[this] (Expected<std::shared_ptr<Pgsql::Result>> result, qint64) {
|
||||
|
||||
} );
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool CrudModel::savePendingChanges()
|
||||
{
|
||||
// need to start async store of changes
|
||||
|
||||
// modified results are only known after updates/inserts have returned the new values
|
||||
// (new values can be modified by triggers and such things)
|
||||
|
||||
// do we leave panding changes in the list until async task complete? But then we do not know which
|
||||
// ones we are storing because user can add new ones.
|
||||
|
||||
// We could also clear the pending list and keep a copy in the async task but then display would revert back
|
||||
// to original values until save has completed.
|
||||
|
||||
// Moving them to modified list doesn't seem a good idea either because we would have to undo the changes
|
||||
// when the save fails.
|
||||
|
||||
|
||||
|
||||
// PendingRowList copy = m_pendingRowList;
|
||||
//
|
||||
|
||||
|
||||
for (const auto& row : m_pendingRowList) {
|
||||
// int row_number = row.first;
|
||||
// if (row_number >= 0) {
|
||||
//// update
|
||||
// }
|
||||
updateRow(row.second);
|
||||
|
||||
}
|
||||
m_pendingRowList.clear();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CrudModel::submit()
|
||||
{
|
||||
return savePendingChanges();
|
||||
}
|
||||
|
||||
void CrudModel::revert()
|
||||
{
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@
|
|||
#include "Pgsql_Connection.h"
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
#include <boost/optional.hpp>
|
||||
|
||||
|
|
@ -25,13 +26,27 @@ class ASyncWindow;
|
|||
* - hide columns (will not be retrieved can greatly speed up things when you disable wide columns)
|
||||
* - can use foreign keys to display dropdown
|
||||
*
|
||||
* How to load data?
|
||||
* - 2D array of QVariants won't be efficient
|
||||
* - 2D array of strings
|
||||
* - We do know the type of a single column is fixed
|
||||
* - Keep data in Result and only load data in replacement rows
|
||||
* std::string has short string optimization so this probably means
|
||||
* that a two dimensional array of std::string objects could actually be quite efficient!
|
||||
*
|
||||
* Need to keep track of changes from the original. Things to track
|
||||
* - new data being entered for existing row
|
||||
* - new data for new row
|
||||
* - current data of modified row
|
||||
* - current data of new row
|
||||
* - which rows are deleted
|
||||
* We need to be able to:
|
||||
* - determine row count easily
|
||||
* - find specific row from table easily
|
||||
* - support resorting (without requerying)
|
||||
* //- support custom filtering (without requerying)
|
||||
*
|
||||
* Keep data as much in original result
|
||||
* - use redirect list to go from index to actual row in the result
|
||||
* - use an additional map index by original row number containing changed data
|
||||
* - might be beneficial to have vector<bool> in sync with original list to signal changes from the result
|
||||
* this could prevent doing a lot of slower searches in the changed row set by only doing this when the direty markes
|
||||
* has been set vector<bool> takes 1 bit per value making it very efficient and fast. We also could put a bit in the mapping
|
||||
* vector but this probably would double the size of that list taking 32 times the size of vector<bool>.
|
||||
*
|
||||
*/
|
||||
class CrudModel: public QAbstractTableModel {
|
||||
Q_OBJECT
|
||||
|
|
@ -52,13 +67,15 @@ public:
|
|||
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;
|
||||
|
||||
public slots:
|
||||
virtual bool submit() override;
|
||||
virtual void revert() override;
|
||||
|
||||
private:
|
||||
ASyncWindow * m_asyncWindow;
|
||||
std::shared_ptr<OpenDatabase> m_database;
|
||||
PgClass m_table;
|
||||
boost::optional<PgConstraint> m_primaryKey;
|
||||
ASyncDBConnection m_dbConn;
|
||||
bool callLoadData = false;
|
||||
using PKeyValues = std::vector<std::string>;
|
||||
|
||||
|
||||
|
||||
// using RowData = std::vector<std::string>;
|
||||
|
|
@ -69,58 +86,157 @@ private:
|
|||
// */
|
||||
// using RowList = std::vector<RowDataPtr>;
|
||||
|
||||
std::shared_ptr<Pgsql::Result> m_roData;
|
||||
void loadData();
|
||||
void loadIntoModel(std::shared_ptr<Pgsql::Result> data);
|
||||
|
||||
// std::shared_ptr<RowList> resultToRowList(std::shared_ptr<Pgsql::Result> result);
|
||||
|
||||
using Value = boost::optional<std::string>;
|
||||
|
||||
/** Remembers the values that have been applies to a row after the original result was retrieved.
|
||||
/** Used to remember the changes that have been made to rows.
|
||||
*
|
||||
* For simplicity it also holds the values for columns that have not been changed.
|
||||
*/
|
||||
class ModifiedRow {
|
||||
public:
|
||||
|
||||
ModifiedRow(int row, const std::vector<Value> &values)
|
||||
: m_row(row), m_values(values)
|
||||
{}
|
||||
const auto& data() const { return m_values; }
|
||||
int row() const { return m_row; }
|
||||
private:
|
||||
int m_row;
|
||||
std::vector<Value> m_values;
|
||||
};
|
||||
using ModifiedRowList = std::map<int, ModifiedRow>;
|
||||
|
||||
/** Manages the changes for the current row
|
||||
/** Similar to a modified row but it only stores values for columns that actually have been edited.
|
||||
*
|
||||
*/
|
||||
class PendingChanges {
|
||||
class PendingRow {
|
||||
public:
|
||||
using ValueMap = std::map<int16_t, 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_currentRow;
|
||||
std::vector<std::string> m_currentPKeyValues; ///< The values to use for updating the row, for new rows this list is empty
|
||||
std::map<int16_t, Value> m_values; ///< values that need to be applied
|
||||
int m_row;
|
||||
ValueMap m_values;
|
||||
};
|
||||
|
||||
using DeletedList = std::vector<int>; // These are the original indexes before there were any modifications
|
||||
|
||||
PendingChanges m_pendingChanges;
|
||||
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);
|
||||
}
|
||||
|
||||
boost::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 boost::none;
|
||||
}
|
||||
|
||||
auto begin() { return m_rows.begin(); }
|
||||
auto end() { return m_rows.end(); }
|
||||
|
||||
void clear() { m_rows.clear(); }
|
||||
|
||||
private:
|
||||
Map m_rows;
|
||||
};
|
||||
|
||||
|
||||
|
||||
ASyncWindow * m_asyncWindow;
|
||||
std::shared_ptr<OpenDatabase> m_database;
|
||||
PgClass m_table;
|
||||
boost::optional<PgConstraint> m_primaryKey;
|
||||
ASyncDBConnection m_dbConn;
|
||||
bool callLoadData = false;
|
||||
|
||||
std::shared_ptr<Pgsql::Result> m_roData;
|
||||
|
||||
PendingRowList m_pendingRowList;
|
||||
|
||||
/** Maintains a list of all modified rows.
|
||||
*
|
||||
* The key values are the indexes of the row before any rows were deleted.
|
||||
*/
|
||||
ModifiedRowList m_modifiedRowList;
|
||||
|
||||
|
||||
// Alternative, vector of rows
|
||||
class Row {
|
||||
public:
|
||||
int resultRow; ///< row index in original result, -1 for new rows
|
||||
std::vector<Value> currentValues; ///
|
||||
|
||||
};
|
||||
using RedirectVec = std::vector<int>;
|
||||
/// In sync with the actual table, used to efficiently find the correct row in the result
|
||||
RedirectVec m_redirectVector;
|
||||
|
||||
|
||||
QVariant getData(const QModelIndex &index) const;
|
||||
void loadData();
|
||||
void loadIntoModel(std::shared_ptr<Pgsql::Result> data);
|
||||
|
||||
Value getData(const QModelIndex &index) const;
|
||||
Oid getType(int column) const;
|
||||
|
||||
///
|
||||
/// \brief columnName
|
||||
/// \param col
|
||||
/// \return
|
||||
///
|
||||
QString columnName(int col) const;
|
||||
|
||||
///
|
||||
/// \brief getModifiedRow searches for the specified row in the modified set
|
||||
/// \param row
|
||||
/// \return Pointer to the modified element or nullptr if there is no modification
|
||||
///
|
||||
const ModifiedRow* getModifiedRow(int row) const;
|
||||
|
||||
///
|
||||
/// \brief getPKeyForRow retrieve the primary key of the specified row
|
||||
///
|
||||
/// This function should not be called when there is no primarykey. (Editing should be disabled anyway in that case)
|
||||
///
|
||||
/// \param row Actual result row not intermeddiat model row
|
||||
/// \return
|
||||
///
|
||||
PKeyValues getPKeyForRow(int row) const;
|
||||
|
||||
bool savePendingChanges();
|
||||
|
||||
void updateRow(const PendingRow &pending_row);
|
||||
private slots:
|
||||
|
||||
void connectionStateChanged(ASyncDBConnection::State state);
|
||||
|
|
|
|||
|
|
@ -21,6 +21,10 @@ CrudTab::CrudTab(MainWindow *parent)
|
|||
m_crudModel = new CrudModel(parent);
|
||||
ui->tableView->setModel(m_crudModel);
|
||||
|
||||
ui->tableView->setSelectionMode(QAbstractItemView::SingleSelection);
|
||||
//auto selection_model = ui->tableView->selectionModel();
|
||||
// connect(ui->tableView->selectionModel(), &QItemSelectionModel::currentRowChanged, this,
|
||||
// &CrudTab::tableView_currentRowChanged);
|
||||
}
|
||||
|
||||
CrudTab::~CrudTab()
|
||||
|
|
@ -41,3 +45,8 @@ void CrudTab::setConfig(std::shared_ptr<OpenDatabase> db, const PgClass &table)
|
|||
// highlighter->setTypes(*cat->types());
|
||||
m_crudModel->setConfig(db, table);
|
||||
}
|
||||
|
||||
//void CrudTab::tableView_currentRowChanged(const QModelIndex ¤t, const QModelIndex &previous)
|
||||
//{
|
||||
|
||||
//}
|
||||
|
|
|
|||
|
|
@ -32,6 +32,9 @@ private:
|
|||
PgClass m_table;
|
||||
|
||||
CrudModel *m_crudModel = nullptr;
|
||||
|
||||
private slots:
|
||||
// void tableView_currentRowChanged(const QModelIndex ¤t, const QModelIndex &previous);
|
||||
};
|
||||
|
||||
#endif // CRUDTAB_H
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue