450 lines
10 KiB
C++
450 lines
10 KiB
C++
#include "DatabaseWindow.h"
|
|
#include "About.h"
|
|
#include "ui_DatabaseWindow.h"
|
|
#include "util.h"
|
|
#include "crud/CrudTab.h"
|
|
#include "catalog/widgets/CatalogTablesPage.h"
|
|
#include "OpenDatabase.h"
|
|
#include "catalog/PgDatabaseCatalog.h"
|
|
#include "ConnectionController.h"
|
|
#include "MasterController.h"
|
|
#include <QAction>
|
|
#include <QApplication>
|
|
#include <QtConcurrent>
|
|
#include <QCloseEvent>
|
|
#include <QFileDialog>
|
|
#include <QMenuBar>
|
|
#include <QMessageBox>
|
|
#include <QMetaMethod>
|
|
#include <QMimeData>
|
|
#include <QStandardPaths>
|
|
#include <QStatusBar>
|
|
#include <QTableView>
|
|
|
|
#include "EditTableWidget.h"
|
|
#include "CodeGenerator.h"
|
|
#include "querytool/QueryTool.h"
|
|
#include <serverinspector/ServerInspector.h>
|
|
|
|
namespace pg = Pgsql;
|
|
|
|
DatabaseWindow::DatabaseWindow(MasterController *master, QWidget *parent)
|
|
: QMainWindow(parent)
|
|
, ui(new Ui::DatabaseWindow)
|
|
, m_masterController(master)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
connect(ui->mainTabs, &QTabWidget::tabCloseRequested, this, &DatabaseWindow::mainTabCloseRequested);
|
|
connect(ui->mainTabs, &QTabWidget::currentChanged, this, &DatabaseWindow::currentMainTabChanged);
|
|
|
|
setAcceptDrops(true);
|
|
}
|
|
|
|
DatabaseWindow::~DatabaseWindow()
|
|
{
|
|
delete ui;
|
|
}
|
|
|
|
void DatabaseWindow::addPage(QWidget* page, QString caption)
|
|
{
|
|
ui->mainTabs->addTab(page, caption);
|
|
ui->mainTabs->setCurrentWidget(page);
|
|
}
|
|
|
|
void DatabaseWindow::setTabCaptionForWidget(QWidget *widget, const QString &caption, const QString &hint)
|
|
{
|
|
auto index = ui->mainTabs->indexOf(widget);
|
|
ui->mainTabs->setTabText(index, caption);
|
|
ui->mainTabs->setTabToolTip(index, hint);
|
|
}
|
|
|
|
void DatabaseWindow::setTabIcon(QWidget *widget, const QString &iconname)
|
|
{
|
|
auto index = ui->mainTabs->indexOf(widget);
|
|
auto n = ":/icons/16x16/" + iconname;
|
|
ui->mainTabs->setTabIcon(index, QIcon(n));
|
|
}
|
|
|
|
void DatabaseWindow::newCodeGenPage(QString query, std::shared_ptr<const Pgsql::Result> dbres)
|
|
{
|
|
auto cgtab = new CodeGenerator(this);
|
|
cgtab->Init(m_database->catalog(), query, dbres);
|
|
addPage(cgtab, "Codegen");
|
|
}
|
|
|
|
QueryTool *DatabaseWindow::GetActiveQueryTool()
|
|
{
|
|
auto widget = ui->mainTabs->currentWidget();
|
|
auto qt = dynamic_cast<QueryTool*>(widget);
|
|
return qt;
|
|
}
|
|
|
|
CrudTab *DatabaseWindow::GetActiveCrud()
|
|
{
|
|
auto widget = ui->mainTabs->currentWidget();
|
|
auto ct = dynamic_cast<CrudTab*>(widget);
|
|
return ct;
|
|
}
|
|
|
|
void DatabaseWindow::closeEvent(QCloseEvent *event)
|
|
{
|
|
for (int idx = 0; idx < ui->mainTabs->count(); ++idx)
|
|
{
|
|
if (!canCloseTab(idx))
|
|
{
|
|
event->ignore();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void DatabaseWindow::setConfig(const ConnectionConfig &config)
|
|
{
|
|
m_config = config;
|
|
try
|
|
{
|
|
QString title = "pglab - ";
|
|
title += m_config.name();
|
|
setWindowTitle(title);
|
|
|
|
auto cfg = m_config;
|
|
auto qthis = QPointer(this);
|
|
QtConcurrent::run([cfg]
|
|
{
|
|
return OpenDatabase::createOpenDatabase(cfg);
|
|
}
|
|
).then(qApp, [qthis](OpenDatabase::OpenDatabaseSPtr db)
|
|
{
|
|
if (qthis)
|
|
qthis.data()->catalogLoaded(db);
|
|
}
|
|
).onFailed(qApp, [qthis](OpenDatabaseException &ex)
|
|
{
|
|
if (qthis) {
|
|
QMessageBox::critical(qthis.data(), "Error reading database",
|
|
ex.text());
|
|
qthis.data()->close();
|
|
}
|
|
}
|
|
);
|
|
|
|
}
|
|
catch (std::runtime_error &ex)
|
|
{
|
|
QMessageBox::critical(this, "Error reading database",
|
|
QString::fromUtf8(ex.what()));
|
|
close();
|
|
}
|
|
}
|
|
|
|
void DatabaseWindow::newCreateTablePage()
|
|
{
|
|
auto w = new EditTableWidget(m_database, this);
|
|
ui->mainTabs->addTab(w, "Create table");
|
|
}
|
|
|
|
void DatabaseWindow::newCrudPage(Oid tableoid)
|
|
{
|
|
CrudTab *ct = new CrudTab(this, this);
|
|
ct->addAction(ui->actionRefreshCrud);
|
|
addPage(ct, "crud");
|
|
ct->setConfig(tableoid);
|
|
}
|
|
|
|
void DatabaseWindow::newCatalogInspectorPage(QString caption, NamespaceFilter filter)
|
|
{
|
|
if (!m_database)
|
|
return; // would be better if we queued the operation for later
|
|
|
|
auto ct = new CatalogInspector(m_database, this);
|
|
ct->addAction(ui->actionRefreshCatalog);
|
|
|
|
addPage(ct, caption);
|
|
ct->setNamespaceFilter(filter);
|
|
|
|
connect(ct->tablesPage(), &CatalogTablesPage::tableSelected, this, &DatabaseWindow::tableSelected);
|
|
}
|
|
|
|
void DatabaseWindow::newServerInspectorPage()
|
|
{
|
|
auto si = new ServerInspector(m_database, this);
|
|
addPage(si, tr("Server"));
|
|
}
|
|
|
|
void DatabaseWindow::closeTab(int index)
|
|
{
|
|
if (index < 0)
|
|
return;
|
|
|
|
if (canCloseTab(index))
|
|
{
|
|
QWidget *widget = ui->mainTabs->widget(index);
|
|
ui->mainTabs->removeTab(index);
|
|
delete widget;
|
|
}
|
|
}
|
|
|
|
bool DatabaseWindow::canCloseTab(int index) const
|
|
{
|
|
QWidget *widget = ui->mainTabs->widget(index);
|
|
auto mp = dynamic_cast<ManagedPage*>(widget);
|
|
if (mp)
|
|
return mp->CanClose(true);
|
|
|
|
return true;
|
|
}
|
|
|
|
void DatabaseWindow::openSqlFile(QString file_name)
|
|
{
|
|
if (!file_name.isEmpty())
|
|
{
|
|
auto *ct = new QueryTool(this, this);
|
|
if (ct->load(file_name))
|
|
{
|
|
ct->addAction(ui->actionExecute_query);
|
|
addPage(ct, ct->title());
|
|
}
|
|
else
|
|
delete ct;
|
|
}
|
|
}
|
|
|
|
void DatabaseWindow::catalogLoaded(OpenDatabase::OpenDatabaseSPtr db)
|
|
{
|
|
try
|
|
{
|
|
m_database = db;
|
|
on_actionNew_Query_triggered();
|
|
}
|
|
catch (const OpenDatabaseException &ex)
|
|
{
|
|
QMessageBox::critical(this, "Error reading database", ex.text());
|
|
close();
|
|
}
|
|
}
|
|
|
|
void DatabaseWindow::tableSelected(Oid tableoid)
|
|
{
|
|
newCrudPage(tableoid);
|
|
}
|
|
|
|
void DatabaseWindow::InvokeCopyIfPresent(QWidget *w)
|
|
{
|
|
const QMetaObject *meta = w->metaObject();
|
|
int i = meta->indexOfMethod("copy()");
|
|
if (i != -1)
|
|
{
|
|
QMetaMethod method = meta->method(i);
|
|
method.invoke(w, Qt::AutoConnection);
|
|
}
|
|
}
|
|
|
|
void DatabaseWindow::mainTabCloseRequested(int index)
|
|
{
|
|
closeTab(index);
|
|
}
|
|
|
|
void DatabaseWindow::currentMainTabChanged(int)
|
|
{
|
|
auto widget = ui->mainTabs->currentWidget();
|
|
auto qt = dynamic_cast<QueryTool*>(widget);
|
|
auto ct = dynamic_cast<CrudTab*>(widget);
|
|
auto ci = dynamic_cast<CatalogInspector*>(widget);
|
|
|
|
ui->menuQuery->menuAction()->setVisible(qt != nullptr);
|
|
ui->menuCatalog->menuAction()->setVisible(ci != nullptr);
|
|
ui->menuCRUD->menuAction()->setVisible(ct != nullptr);
|
|
}
|
|
|
|
void DatabaseWindow::setTitleForWidget(QWidget *widget, QString title, QString hint)
|
|
{
|
|
int i = ui->mainTabs->indexOf(widget);
|
|
if (i >= 0)
|
|
{
|
|
ui->mainTabs->setTabText(i, title);
|
|
ui->mainTabs->setTabToolTip(i, hint);
|
|
}
|
|
}
|
|
|
|
void DatabaseWindow::setIconForWidget(QWidget *widget, QIcon icon)
|
|
{
|
|
int i = ui->mainTabs->indexOf(widget);
|
|
if (i >= 0)
|
|
ui->mainTabs->setTabIcon(i, icon);
|
|
}
|
|
|
|
|
|
std::shared_ptr<OpenDatabase> DatabaseWindow::openDatabase()
|
|
{
|
|
return m_database;
|
|
}
|
|
|
|
|
|
void DatabaseWindow::showStatusBarMessage(QString message)
|
|
{
|
|
statusBar()->showMessage(message);
|
|
}
|
|
|
|
void DatabaseWindow::dragEnterEvent(QDragEnterEvent *event)
|
|
{
|
|
if (event->mimeData()->hasUrls())
|
|
event->acceptProposedAction();
|
|
}
|
|
|
|
void DatabaseWindow::dropEvent(QDropEvent *event)
|
|
{
|
|
foreach (const QUrl &url, event->mimeData()->urls())
|
|
{
|
|
QString file_name = url.toLocalFile();
|
|
qDebug() << "Dropped file:" << file_name;
|
|
openSqlFile(file_name);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void DatabaseWindow::on_actionAbout_triggered()
|
|
{
|
|
ShowAboutDialog(this);
|
|
}
|
|
|
|
|
|
void DatabaseWindow::on_actionCancel_query_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::cancel);
|
|
}
|
|
|
|
|
|
void DatabaseWindow::on_actionClose_triggered()
|
|
{
|
|
ui->mainTabs->tabCloseRequested(ui->mainTabs->currentIndex());
|
|
}
|
|
|
|
|
|
void DatabaseWindow::on_actionCopy_triggered()
|
|
{
|
|
QWidget *w = QApplication::focusWidget();
|
|
if (w == nullptr)
|
|
return;
|
|
|
|
QTableView *tv = dynamic_cast<QTableView*>(w);
|
|
if (tv)
|
|
copySelectionToClipboard(tv);
|
|
else
|
|
InvokeCopyIfPresent(w);
|
|
}
|
|
|
|
|
|
void DatabaseWindow::on_actionCopy_as_C_string_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::copyQueryAsCString);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionCopy_as_raw_C_string_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::copyQueryAsRawCppString);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionExecute_query_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::execute);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionExplain_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::explain, false);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionExplain_analyze_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::explain, true);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionExport_data_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::exportData);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionGenerate_code_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::generateCode);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionInspect_information_schema_triggered()
|
|
{
|
|
newCatalogInspectorPage("information_schema", NamespaceFilter::InformationSchema);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionInspect_pg_catalog_triggered()
|
|
{
|
|
newCatalogInspectorPage("pg_catalog", NamespaceFilter::PgCatalog);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionInspect_user_schemas_triggered()
|
|
{
|
|
newCatalogInspectorPage("Schema", NamespaceFilter::User);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionInspect_server_triggered()
|
|
{
|
|
newServerInspectorPage();
|
|
}
|
|
|
|
void DatabaseWindow::on_actionNew_Query_triggered()
|
|
{
|
|
auto *ct = new QueryTool(this, this);
|
|
ct->addAction(ui->actionExecute_query);
|
|
addPage(ct, "new");
|
|
ct->newdoc();
|
|
|
|
}
|
|
|
|
void DatabaseWindow::on_actionOpen_Query_triggered()
|
|
{
|
|
QString home_dir = QStandardPaths::locate(QStandardPaths::HomeLocation, "", QStandardPaths::LocateDirectory);
|
|
QString file_name = QFileDialog::getOpenFileName(this,
|
|
tr("Open sql query"), home_dir, tr("SQL files (*.sql *.txt)"));
|
|
openSqlFile(file_name);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionSave_Query_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::save);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionPaste_lang_string_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::pasteLangString);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionRefreshCatalog_triggered()
|
|
{
|
|
m_database->refresh();
|
|
}
|
|
|
|
void DatabaseWindow::on_actionRefreshCrud_triggered()
|
|
{
|
|
CallOnActiveCrud(&CrudTab::refresh);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionSave_query_as_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::saveAs);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionSave_copy_of_query_as_triggered()
|
|
{
|
|
CallOnActiveQueryTool(&QueryTool::saveCopyAs);
|
|
}
|
|
|
|
void DatabaseWindow::on_actionShow_connection_manager_triggered()
|
|
{
|
|
m_masterController->connectionController()->showConnectionManager();
|
|
}
|
|
|
|
void DatabaseWindow::on_actionManual_triggered()
|
|
{
|
|
OpenManual();
|
|
}
|
|
|