Czy można zastąpić te wszystkie modele jedną klasą wirtualną?

Poniżej wrzucam kod całego jednego modelu

#include "sqlquerymodelproducer.h"
#include <QDebug>
#include <QSqlRecord>
#include <QVariant>
#include <QFont>
#include <QColor>

SqlQueryModelProducer::SqlQueryModelProducer(QObject *parent, QSqlDatabase *dbConnect) : QSqlQueryModel{parent}
{
    db = new QSqlDatabase(*dbConnect);

    QString userData = "SELECT pIDproducent, pProducent FROM tProducent";

    this->setQuery(userData, *db);

    this->query().exec();
}

int SqlQueryModelProducer::rowCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    int row=0;

    QString rows = "SELECT count(*) FROM tProducent";

    QSqlQuery queryRow(*db);
    queryRow.exec(rows);

    QSqlRecord recRow;
    if(queryRow.first()){
        recRow = queryRow.record();
        row = recRow.value(0).toInt();

        return row;
    }
    else{
        return row;
    }

    return row;
}

int SqlQueryModelProducer::columnCount(const QModelIndex &parent) const
{
    Q_UNUSED(parent);
    int column=0;

    QString columns = "SELECT count(*) FROM PRAGMA_table_info('tProducent')";

    QSqlQuery queryColumn(*db);
    queryColumn.exec(columns);

    QSqlRecord recColumn;
    if(queryColumn.first()){
        recColumn = queryColumn.record();
        column = recColumn.value(0).toInt();

        return column;
    }
    else{
        return column;
    }

    return column;
}

QVariant SqlQueryModelProducer::headerData(int section, Qt::Orientation orientation, int role) const
{
    if(role==Qt::DisplayRole && orientation==Qt::Horizontal){
        if(section==1){
            QVariant header1;
            header1 = "Producent";

            return header1;
        }
    }

    if(role==Qt::DisplayRole && orientation==Qt::Vertical){
        return QString("%1").arg(section+1);
    }

    return QVariant();
}

QVariant SqlQueryModelProducer::data(const QModelIndex &index, int role) const
{
    QVariant myData;

    if(index.isValid()){
        if(role==Qt::DisplayRole || role==Qt::EditRole){
            myData = QSqlQueryModel::data(index,role);
        }

        if(role==Qt::TextAlignmentRole && (index.column()==1 || index.column()==2)){
            return Qt::AlignCenter;
        }

        if(role==Qt::BackgroundRole && index.row() % 2 == 0){
            QColor color;
            color.setRgb(242,242,242,255);

            myData = color;
        }

        if(role==Qt::BackgroundRole && index.row() % 2 == 1){
            QColor color;
            color.setRgb(217,217,217,170);

            myData = color;
        }
        return myData;
    }
    else if(!index.isValid()){
        return QVariant();
    }

    return QVariant();
}

bool SqlQueryModelProducer::setData(const QModelIndex &index, const QVariant &value, int role)
{
    QModelIndex pID = QSqlQueryModel::index(index.row(),0,QModelIndex());
    int _pID = data(pID,Qt::EditRole | Qt::DisplayRole).toInt();

    bool isSet=false;

    if(!index.isValid()){
        return false;
    }
    else if(index.column()<1){
        return false;
    }
    else{
        if(role==Qt::EditRole || role==Qt::DisplayRole){
            if(index.column()==1){
                isSet = producer(_pID, value.toString());
                emit dataChanged(index,index,{Qt::EditRole | Qt::DisplayRole});

                this->refresh();
                return isSet;
            }
        }
    }
    return false;
}

Qt::ItemFlags SqlQueryModelProducer::flags(const QModelIndex &index) const
{
    Qt::ItemFlags flag = QSqlQueryModel::flags(index);

    if(index.column()==1){
        flag |= Qt::ItemIsEditable;

        return flag;
    }

    return flag;
}

bool SqlQueryModelProducer::producer(int pID, const QString &pProducer)
{
    QSqlQuery queryUpdateProducer;
    QVariant _pID;

    _pID = pID;

    QString strUpdateProducer = "UPDATE tProducent SET pProducent = ? WHERE pIDproducent = ?";

    queryUpdateProducer.prepare(strUpdateProducer);
    queryUpdateProducer.addBindValue(pProducer);
    queryUpdateProducer.addBindValue(_pID.toString());

    return queryUpdateProducer.exec();
}

void SqlQueryModelProducer::myAddRow()
{
    QSqlQuery lastID, addRecord;
    QString strGetID = "SELECT pIDproducent FROM tProducent";
    lastID.prepare(strGetID);

    if(lastID.exec()){
        if(lastID.last() == lastID.isValid()){
            QString strAddRecord = "INSERT INTO tProducent (pProducent) VALUES (:Producent)";

            if(this->pProducer.isEmpty()){
                emit messageOfNumber(1);
            }
            else{
                addRecord.prepare(strAddRecord);
                addRecord.bindValue(":Producent",this->pProducer);

                addRecord.exec();
                addRecord.clear();

                this->pProducer.clear();

                refresh();

                emit producerIsSet();
                emit messageOfNumber(0);
            }
        }
    }
    else if(!lastID.exec()){
        emit messageOfNumber(-1);
    }
}

void SqlQueryModelProducer::myRemoveRow()
{
    QModelIndex getIDfromTable;
    QVariant getIDtoRemove;

    QSqlQuery currentID, removeRow;
    QString strGetCurrentID = "SELECT pIDproducent FROM tProducent";
    currentID.prepare(strGetCurrentID);

    int i=0;

    if(currentID.exec()){
        while (currentID.next()){
            i=currentID.at();
            if(i==this->row){
                getIDfromTable=index(i,0,QModelIndex());
                getIDtoRemove=getIDfromTable.data();
                this->row=-1;
            }
        }
    }

    QString strRemoveRow = "DELETE FROM tProducent WHERE pIDproducent = (?)";
    removeRow.prepare(strRemoveRow);
    removeRow.addBindValue(getIDtoRemove.toString(),QSql::In);
    removeRow.exec();

    refresh();
}

void SqlQueryModelProducer::refresh()
{
    this->query().clear();

    this->setQuery("SELECT pIDproducent, pProducent FROM tProducent");

    this->query().exec();
}

void SqlQueryModelProducer::setProducer(const QString &pProducer)
{
    this->pProducer = pProducer;
}

SqlQueryModelProducer::~SqlQueryModelProducer()
{
    this->query().clear();
    delete this->db;
}

Większość rzeczy się powtarza, tylko zmieniają się zapytania do bazy danych. Więc pytanie jest takie - jeżeli powiedzmy 90% rzeczy jest takich samych w jednym modelu, to czy można ten model napisać jako virtualny i abym miał modele dopasowane do różnych tabel w bazie ? Może nie jasno napisałem ale ten model wyświetla dane z tabeli producent i chciałbym napisać ten sam model ale jako virtualny dla tabeli Pracownik z tym, że zamieniłbym tylko zapytania do bazy. Czy w tym przypadku uzasadnione jest zastosowanie klasy virtualnej ?

zkubinski napisał(a):

Większość rzeczy się powtarza, tylko zmieniają się zapytania do bazy danych. Więc pytanie jest takie - jeżeli powiedzmy 90% rzeczy jest takich samych w jednym modelu, to czy można ten model napisać jako virtualny i abym miał modele dopasowane do różnych tabel w bazie ? Może nie jasno napisałem ale ten model wyświetla dane z tabeli producent i chciałbym napisać ten sam model ale jako virtualny dla tabeli Pracownik z tym, że zamieniłbym tylko zapytania do bazy. Czy w tym przypadku uzasadnione jest zastosowanie klasy virtualnej ?

QSqlTableModel

Patrząc po kodzie, który wrzuciłeś, na obecnym etapie samemu niczego lepszego nie napiszesz, więc naucz się używać tego co Qt oferuje 'od ręki'.