pgLab/mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

#include "QueryResultModel.h"
#include "QueryExplainModel.h"
#include "sqlhighlighter.h"
#include <QTextTable>
#include <QTimer>
#include <windows.h>
#include "json/json.h"
#include "explaintreemodelitem.h"

//#include <thread>

namespace pg = Pgsql;

const char * test_query =

//"SELECT id, program, version, lic_bedrijf, lic_plaats, "
//"lic_number, callstack_crc_1, callstack_crc_2, callstack_crc_3, exception_class, "
//"exception_message \nFROM foutrapport"

"SELECT f1.id, f1.program, f1.version, f1.lic_number, f1.callstack_crc_1, f1.callstack_crc_2, array_agg(f2.id) \n"
"FROM foutrapport f1 JOIN foutrapport f2 USING (callstack_crc_2) \n"
"WHERE f1.actief  \n"
"GROUP BY f1.id"
;

MainWindow::MainWindow(QWidget *parent)
	: QMainWindow(parent)
	, ui(new Ui::MainWindow)
//	, queryCancel(nullptr)
{
	ui->setupUi(this);

	QFont font;
	font.setFamily("Source Code Pro");
	font.setFixedPitch(true);
	font.setPointSize(10);
	ui->queryEdit->setFont(font);
	highlighter.reset(new SqlHighlighter(ui->queryEdit->document()));
	ui->queryEdit->setPlainText(test_query);
	ui->connectionStringEdit->setText("user=postgres dbname=foutrapport password=admin");

	QAction *action;
	action = ui->mainToolBar->addAction("connect");
	connect(action, &QAction::triggered, this, &MainWindow::startConnect);

//	action = ui->mainToolBar->addAction("execute");
//	connect(action, &QAction::triggered, this, &MainWindow::performQuery);

//	action = ui->mainToolBar->addAction("explain");
//	connect(action, &QAction::triggered, this, &MainWindow::performExplain);

//	action = ui->mainToolBar->addAction("cancel");
//	connect(action, &QAction::triggered, this, &MainWindow::cancel_query);

	m_dbConnection.setStateCallback([this](ASyncDBConnection::State st)
		{
			QueueTask([this, st]() { connectionStateChanged(st); });
		});
}

MainWindow::~MainWindow()
{
	m_dbConnection.closeConnection();
	m_dbConnection.setStateCallback(nullptr);

}

void MainWindow::QueueTask(TSQueue::t_Callable c)
{
	m_taskQueue.add(c);
	// Theoretically this needs to be only called if the queue was empty because otherwise it already would
	// be busy emptying the queue. For now however I think it is safer to call it just to make sure.
	QMetaObject::invokeMethod(this, "processCallableQueue",	Qt::QueuedConnection); // queues on main thread
}

void MainWindow::processCallableQueue()
{
	if (!m_taskQueue.empty()) {
		auto c = m_taskQueue.pop();
		c();
		if (!m_taskQueue.empty()) {
			QTimer::singleShot(0, this, SLOT(processCallableQueue()));
		}
	}
}

void MainWindow::connectionStateChanged(ASyncDBConnection::State state)
{
	QString status_str;
	switch (state) {
	case ASyncDBConnection::State::NotConnected:
		status_str = tr("Geen verbinding");
		break;
	case ASyncDBConnection::State::Connecting:
		status_str = tr("Verbinden");
		break;
	case ASyncDBConnection::State::Connected:
		status_str = tr("Verbonden");
		break;
	case ASyncDBConnection::State::QuerySend:
		status_str = tr("Query verstuurd");
		break;
	case ASyncDBConnection::State::CancelSend:
		status_str = tr("Query geannuleerd");
		break;
	}
	statusBar()->showMessage(status_str);
}

void MainWindow::startConnect()
{
//	if (connection == nullptr) {
//		connection = std::make_unique<pg::Connection>();
//	}
//	QString connstr = ui->connectionStringEdit->text();
//	bool ok = connection->connectStart(connstr + " application_name=Ivory client_encoding=utf8");
//	if (ok && connection->status() != CONNECTION_BAD) {
//		// Start polling
//		int s = connection->socket();

//		connectingState.notifier = std::make_unique<QSocketNotifier>(s, QSocketNotifier::Write);
//		connect(connectingState.notifier.get(), &QSocketNotifier::activated, this, &MainWindow::socket_activate_connect);

//		connectingState.poll_state = PGRES_POLLING_WRITING;
//		statusBar()->showMessage(tr("Connecting"));
//	}
//	else {
//		statusBar()->showMessage(tr("Connecting fail"));
//	}

	std::string connstr = ui->connectionStringEdit->text().toUtf8().data();
	m_dbConnection.setupConnection(connstr);
}

//void MainWindow::socket_activate_connect(int )
//{
//	connectingState.poll_state = connection->connectPoll();


//	if (connectingState.poll_state == PGRES_POLLING_OK) {
//		connection->setNoticeReceiver(
//					std::bind(&MainWindow::processNotice, this, std::placeholders::_1));
//		statusBar()->showMessage(tr("Connected"));
//		connectingState.notifier.reset();
//	}
//	else if (connectingState.poll_state == PGRES_POLLING_FAILED) {
//		statusBar()->showMessage(tr("Connection failed"));
//		connectingState.notifier.reset();
//	}
//	else if (connectingState.poll_state == PGRES_POLLING_READING) {
//		statusBar()->showMessage(tr("Connecting.."));
//		connectingState.notifier = std::make_unique<QSocketNotifier>(connection->socket(), QSocketNotifier::Read);
//		connect(connectingState.notifier.get(), &QSocketNotifier::activated, this, &MainWindow::socket_activate_connect);
//	}
//	else if (connectingState.poll_state == PGRES_POLLING_WRITING) {
//		statusBar()->showMessage(tr("Connecting..."));
//		connectingState.notifier = std::make_unique<QSocketNotifier>(connection->socket(), QSocketNotifier::Write);
//		connect(connectingState.notifier.get(), &QSocketNotifier::activated, this, &MainWindow::socket_activate_connect);
//	}
//}


//void MainWindow::performQuery()
//{
//	ui->ResultView->setModel(nullptr);
//	resultModel.reset();
//	ui->messagesEdit->clear();

//	queryCancel = std::move(connection->getCancel());

//	QString command = ui->queryEdit->toPlainText();

//	std::thread([this,command]()
//		{
//			auto res = std::make_shared<Pgsql::Result>(connection->query(command));
//			QueueTask([this, res]() { query_ready(std::move(*res)); });
//		}).detach();
//}

//void MainWindow::query_ready(Pgsql::Result dbres)
//{
//	if (dbres) {
//		auto st = dbres.resultStatus();
//		if (st == PGRES_TUPLES_OK) {
//			resultModel.reset(new QueryResultModel(nullptr , std::move(dbres)));
//			ui->ResultView->setModel(resultModel.get());
//			statusBar()->showMessage(tr("Query ready."));
//		}
//		else {
//			if (st == PGRES_EMPTY_QUERY) {
//				statusBar()->showMessage(tr("Empty query."));
//			}
//			else if (st == PGRES_COMMAND_OK) {
//				statusBar()->showMessage(tr("Command OK."));
//			}
//			else if (st == PGRES_COPY_OUT) {
//				statusBar()->showMessage(tr("COPY OUT."));
//			}
//			else if (st == PGRES_COPY_IN) {
//				statusBar()->showMessage(tr("COPY IN."));
//			}
//			else if (st == PGRES_BAD_RESPONSE) {
//				statusBar()->showMessage(tr("BEAD RESPONSE."));
//			}
//			else if (st == PGRES_NONFATAL_ERROR) {
//				statusBar()->showMessage(tr("NON FATAL ERROR."));
//			}
//			else if (st == PGRES_FATAL_ERROR) {
//				statusBar()->showMessage(tr("FATAL ERROR."));
//			}
//			else if (st == PGRES_COPY_BOTH) {
//				statusBar()->showMessage(tr("COPY BOTH shouldn't happen is for replication."));
//			}
//			else if (st == PGRES_SINGLE_TUPLE) {
//				statusBar()->showMessage(tr("SINGLE TUPLE result."));
//			}
//			else {
//				statusBar()->showMessage(tr("No tuples returned, possibly an error..."));
//			}
//			receiveNotice(dbres.diagDetails());
//		}
//	}
//	else {
//		statusBar()->showMessage(tr("Query cancelled."));
//	}
//}

//void MainWindow::performExplain()
//{
//	ui->ResultView->setModel(nullptr);
//	resultModel.reset();
//	ui->messagesEdit->clear();

//	queryCancel = std::move(connection->getCancel());

//	QString command = "EXPLAIN (ANALYZE, VERBOSE, BUFFERS, FORMAT JSON) ";
//	command += ui->queryEdit->toPlainText();
////	explainFuture = std::async(std::launch::async, [this,command]()-> std::unique_ptr<ExplainRoot>
//   std::thread([this,command]()
//		{
//			std::shared_ptr<ExplainRoot> explain;
//			auto res = connection->query(command);
//			if (res.getCols() == 1 && res.getRows() == 1) {
//				std::string s = res.getVal(0, 0);
//				Json::Value root;   // will contains the root value after parsing.
//				Json::Reader reader;
//				bool parsingSuccessful = reader.parse(s, root);
//				if (parsingSuccessful) {
//					explain = ExplainRoot::createFromJson(root);
//				}
//			}
//			QueueTask([this, explain]() { explain_ready(explain); });
//		}).detach();
//}

//void MainWindow::explain_ready(ExplainRoot::SPtr explain)
//{
//	if (explain) {
//		explainModel.reset(new QueryExplainModel(nullptr, explain));
//		ui->explainTreeView->setModel(explainModel.get());
//		ui->explainTreeView->expandAll();
//		ui->explainTreeView->setColumnWidth(0, 200);
//		ui->explainTreeView->setColumnWidth(1, 80);
//		ui->explainTreeView->setColumnWidth(2, 80);
//		ui->explainTreeView->setColumnWidth(3, 80);
//		ui->explainTreeView->setColumnWidth(4, 80);
//		ui->explainTreeView->setColumnWidth(5, 80);
//		ui->explainTreeView->setColumnWidth(6, 600);
//		statusBar()->showMessage(tr("Explain ready."));
//	}
//	else {
//		statusBar()->showMessage(tr("Explain failed."));
//	}
//}

//void MainWindow::cancel_query()
//{
//	queryCancel.cancel();
//}

//void MainWindow::processNotice(const PGresult *result)
//{
//	qRegisterMetaType<Pgsql::ErrorDetails>("Pgsql::ErrorDetails");
//	pg::ErrorDetails details = pg::ErrorDetails::createErrorDetailsFromPGresult(result);
//	QMetaObject::invokeMethod(this, "receiveNotice", Qt::AutoConnection, Q_ARG(Pgsql::ErrorDetails, details)); // queues on main thread
//}

//void MainWindow::receiveNotice(Pgsql::ErrorDetails notice)
//{
//	QTextCursor cursor = ui->messagesEdit->textCursor();
//	cursor.movePosition(QTextCursor::End, QTextCursor::MoveAnchor);


////	QString msg;
////	cursor.insertText("TEST\r\n");

//	QTextTable *table = cursor.insertTable(4, 2);
//	if (table) {
//		table->cellAt(1, 0).firstCursorPosition().insertText("State");
//		table->cellAt(1, 1).firstCursorPosition().insertText(QString::fromStdString(notice.state));
//		table->cellAt(2, 0).firstCursorPosition().insertText("Primary");
//		table->cellAt(2, 1).firstCursorPosition().insertText(QString::fromStdString(notice.messagePrimary));
//		table->cellAt(3, 0).firstCursorPosition().insertText("Detail");
//		table->cellAt(3, 1).firstCursorPosition().insertText(QString::fromStdString(notice.messageDetail));
//	}
//}