sqlitebrowser/src/ForeignKeyEditorDelegate.cpp

#include "sqlitedb.h"
#include "ForeignKeyEditorDelegate.h"

#include <QComboBox>
#include <QLineEdit>
#include <QPushButton>
#include <QHBoxLayout>

class ForeignKeyEditor : public QWidget
{
    Q_OBJECT

public:
    explicit ForeignKeyEditor(QWidget* parent = nullptr)
        : QWidget(parent)
        , tablesComboBox(new QComboBox(this))
        , idsComboBox(new QComboBox(this))
        , clauseEdit(new QLineEdit(this))
        , m_btnReset(new QPushButton(tr("&Reset"), this))
    {
        idsComboBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
        clauseEdit->setPlaceholderText(tr("Foreign key clauses (ON UPDATE, ON DELETE etc.)"));

        QHBoxLayout* layout = new QHBoxLayout(this);
        layout->addWidget(tablesComboBox);
        layout->addWidget(idsComboBox);
        layout->addWidget(clauseEdit);
        layout->addWidget(m_btnReset);
        layout->setSpacing(0);
        layout->setMargin(0);
        setLayout(layout);

        connect(m_btnReset, &QPushButton::clicked, [&]
        {
            tablesComboBox->setCurrentIndex(-1);
            idsComboBox->setCurrentIndex(-1);
            clauseEdit->clear();
        });

        connect(tablesComboBox, static_cast<void(QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
                [=](int index)
        {
            // reset ids combo box
            idsComboBox->setCurrentIndex(-1);

            // disable clauses editor if none of tables is selected
            bool enableClausesEditor = (index!= -1);
            clauseEdit->setEnabled(enableClausesEditor);
        });
    }

    QString getSql() const
    {
        if (tablesComboBox->currentText().isEmpty())
            return QString();

        const QString table     = sqlb::escapeIdentifier(tablesComboBox->currentText());
        const QString clauses   = clauseEdit->text();

        QString id = idsComboBox->currentText();
        if (!id.isEmpty())
            id = QString("(%1)").arg(sqlb::escapeIdentifier(id));

        return QString("%1%2 %3")
                .arg(table)
                .arg(id)
                .arg(clauses)
                .trimmed();
    }

    QComboBox* tablesComboBox;
    QComboBox* idsComboBox;
    QLineEdit* clauseEdit; // for ON CASCADE and such

private:
    QPushButton* m_btnReset;
};

ForeignKeyEditorDelegate::ForeignKeyEditorDelegate(const DBBrowserDB& db, sqlb::Table& table, QObject* parent)
    : QStyledItemDelegate(parent)
    , m_db(db)
    , m_table(table)
{
    for(auto it=m_db.schemata.constBegin();it!=m_db.schemata.constEnd();++it)
    {
        for(auto jt=it->constBegin();jt!=it->constEnd();++jt)
        {
            if((*jt)->type() == sqlb::Object::Types::Table)
            {
                QString tableName = (*jt)->name();
                m_tablesIds.insert(tableName, (*jt).dynamicCast<sqlb::Table>()->fieldNames());
            }
        }
    }
}

QWidget* ForeignKeyEditorDelegate::createEditor(QWidget* parent, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
    Q_UNUSED(option)
    Q_UNUSED(index)

    ForeignKeyEditor* editor = new ForeignKeyEditor(parent);
    editor->setAutoFillBackground(true);

    connect(editor->tablesComboBox, static_cast<void(QComboBox::*)(const QString&)>(&QComboBox::currentIndexChanged),
            [=](const QString& tableName)
    {
        QComboBox* box = editor->idsComboBox;
        box->clear();
        box->addItem(QString());                // for those heroes who don't like to specify key explicitly
        box->addItems(m_tablesIds[tableName]);
        box->setCurrentIndex(0);
    });

    editor->tablesComboBox->clear();
    editor->tablesComboBox->addItems(m_tablesIds.keys());

    return editor;
}

void ForeignKeyEditorDelegate::setEditorData(QWidget* editor, const QModelIndex& index) const
{
    ForeignKeyEditor* fkEditor = static_cast<ForeignKeyEditor*>(editor);

    int column = index.row(); // weird? I know right
    sqlb::FieldPtr field = m_table.fields().at(column);
    QSharedPointer<sqlb::ForeignKeyClause> fk = m_table.constraint({field}, sqlb::Constraint::ForeignKeyConstraintType).dynamicCast<sqlb::ForeignKeyClause>();
    if (!fk.isNull()) {
        fkEditor->tablesComboBox->setCurrentText(fk->table());
        fkEditor->clauseEdit->setText(fk->constraint());
        if (!fk->columns().isEmpty())
            fkEditor->idsComboBox->setCurrentText(fk->columns().first());
    } else {
        fkEditor->tablesComboBox->setCurrentIndex(-1);
    }
}

void ForeignKeyEditorDelegate::setModelData(QWidget* editor, QAbstractItemModel* model, const QModelIndex& index) const
{
    ForeignKeyEditor* fkEditor = static_cast<ForeignKeyEditor*>(editor);
    QString sql = fkEditor->getSql();

    int column = index.row();
    sqlb::FieldPtr field = m_table.fields().at(column);
    if (sql.isEmpty()) {
        // Remove the foreign key
        m_table.removeConstraints({field}, sqlb::Constraint::ConstraintTypes::ForeignKeyConstraintType);
    } else {
        // Set the foreign key
        sqlb::ForeignKeyClause* fk = new sqlb::ForeignKeyClause;

        const QString table     = fkEditor->tablesComboBox->currentText();
        const QString id        = fkEditor->idsComboBox->currentText();
        const QString clause    = fkEditor->clauseEdit->text();

        fk->setTable(table);

        if (!id.isEmpty())
            fk->setColumns({id});

        if (!clause.trimmed().isEmpty()) {
            fk->setConstraint(clause);
        }

        m_table.setConstraint({field}, sqlb::ConstraintPtr(fk));
    }

    model->setData(index, sql);
}

void ForeignKeyEditorDelegate::updateEditorGeometry(QWidget* editor, const QStyleOptionViewItem& option, const QModelIndex& index) const
{
    Q_UNUSED(index)

    editor->setGeometry(option.rect);
}

void ForeignKeyEditorDelegate::updateTablesList(const QString& oldTableName)
{
    // this is used for recursive table constraints when
    // table column references column within same table
    m_tablesIds.remove(oldTableName);
    m_tablesIds.insert(m_table.name(), m_table.fieldNames());
}

#include "ForeignKeyEditorDelegate.moc"