No OneTemporary
Actions

Size

59 KB

Subscribers

None

View Options

	diff --git a/restruct.pro b/restruct.pro
	--- a/restruct.pro
	+++ b/restruct.pro
	@@ -1,48 +1,47 @@
	######################################################################
	# Project started 11.01.2008 at 13:10
	######################################################################

	QT += core gui
	greaterThan(QT_MAJOR_VERSION, 4): QT += widgets concurrent

	TEMPLATE = app
	TARGET = restruct
	DESTDIR = .
	BASEDIR = $$dirname(PWD)

	INCLUDEPATH += . ./src $$BASEDIR/include
	-PRECOMPILED_HEADER = ./src/stable.h
	DEFINES += KTOOLS_STATIC

	RESOURCES += resource/project.qrc

	SOURCES += src/restruct.cpp \
	src/mainwindow.cpp \
	src/updater.cpp \
	src/sqlerrordlg.cpp

	HEADERS += src/mainwindow.h \
	src/updater.h \
	src/psettings.h \
	src/sqlerrordlg.h


	LIBS += -L$$BASEDIR/lib -lktools -lpq

	win32 {
	RC_FILE = resource/project.rc
	LIBS += -luuid -loleaut32 -lgdi32 -luser32
	}
	win32-msvc* {
	CONFIG(debug, debug\|release) {
	QMAKE_LFLAGS *= /NODEFAULTLIB:msvcrt
	LIBS = $$replace(LIBS,-lktools,-lktoolsd)
	}
	DEFINES += _CRT_SECURE_NO_WARNINGS
	}

	#unix {
	# SOURCES += src/
	# HEADERS += src/
	#}

	diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
	--- a/src/mainwindow.cpp
	+++ b/src/mainwindow.cpp
	@@ -1,451 +1,462 @@
	-#include "stable.h"
	#include "mainwindow.h"
	#include "updater.h"
	#include "psettings.h"
	#include "sqlerrordlg.h"
	#include <sqlproc.h>
	#include <kactivityindicator.h>
	#include <ksettings.h>
	#include <ksds.h>
	#ifdef Q_OS_WIN32
	#include <klogon_win.h>
	#endif
	-
	+#include <QApplication>
	+#include <QCloseEvent>
	+#include <QEvent>
	+#include <QLabel>
	+#include <QFileDialog>
	+#include <QHBoxLayout>
	+#include <QVBoxLayout>
	+#include <QPushButton>
	+#include <QProgressBar>
	+#include <QtConcurrentRun>
	+#include <QShortcut>
	+#include <QStyle>
	+#include <QTextEdit>
	//---------------------------------------------------------------------------
	//---------------------------------------------------------------------------
	MainWindow::MainWindow( QWidget* parent, Qt::WindowFlags flags )
	: QDialog( parent, flags )
	, _exitCode( 0 )
	, _actionEventType( QEvent::User )
	, _errorCount( 0 )
	, _updater( new DatabaseUpdater )
	{
	setWindowTitle( QString::fromUtf8( "Создание/обновление базы данных" ) );
	setWindowFlags( windowFlags() & ~Qt::WindowContextHelpButtonHint );
	setSizeGripEnabled( true );

	QHBoxLayout* mainLayout = new QHBoxLayout;
	QVBoxLayout* leftLayout = new QVBoxLayout;
	QVBoxLayout* rightLayout = new QVBoxLayout;
	QHBoxLayout* bottomRightLayout = new QHBoxLayout;

	leftLayout->setContentsMargins( 0,
	2* style()->pixelMetric( QStyle::PM_LayoutTopMargin ),
	style()->pixelMetric( QStyle::PM_LayoutRightMargin ), 0 );

	QLabel* picture = new QLabel;
	picture->setPixmap( QPixmap( ":/picture.png" ) );

	//кнопки, скрытые до завершения процесса
	_btnSave = new QPushButton( QString::fromUtf8( "Сохранить" ) );
	_btnClose = new QPushButton( QString::fromUtf8( "Закрыть" ) );
	_btnSave->setVisible( false );
	_btnClose->setVisible( false );
	_btnClose->setDefault( true );

	leftLayout->addWidget( picture );
	leftLayout->addStretch();
	leftLayout->addWidget( _btnSave );
	leftLayout->addWidget( _btnClose );

	QLabel* label = new QLabel( QString::fromUtf8( "Протокол работы" ) );
	rightLayout->addWidget( label );

	_protocol = new QTextEdit();
	_protocol->setReadOnly( true );
	label->setBuddy( _protocol );
	rightLayout->addWidget( _protocol );

	//индикаторы выполнения
	_progress = new QProgressBar;
	_progress->setTextVisible( false );
	_ai = new KActivityIndicator( KActivityIndicator::Gray );
	_ai->setVisible( false );

	bottomRightLayout->addWidget( _progress );
	bottomRightLayout->addWidget( _ai );
	rightLayout->addLayout( bottomRightLayout );

	mainLayout->addLayout( leftLayout );
	mainLayout->addLayout( rightLayout );
	setLayout( mainLayout );

	//нажатие Esc не соединяется со слотом, чтобы окно не закрывалось
	new QShortcut( QKeySequence(Qt::Key_Escape), this );

	//соединить сигналы со слотами
	connect( _btnSave, SIGNAL(clicked()), this, SLOT(saveProtocol()) );
	connect( _btnClose, SIGNAL(clicked()), this, SLOT(closeDialog()) );

	//получить незадействованный тип события
	_actionEventType = QEvent::registerEventType();
	}

	MainWindow::~MainWindow()
	{
	delete _updater;
	}

	//---------------------------------------------------------------------------
	void MainWindow::showEvent( QShowEvent* a_event )
	{
	QDialog::showEvent( a_event );
	qApp->postEvent( this, new QEvent( QEvent::Type(_actionEventType) ) );
	}

	//---------------------------------------------------------------------------
	bool MainWindow::event( QEvent* a_event )
	{
	if ( a_event->type() == _actionEventType )
	{
	startExecution();
	a_event->accept();
	return true;
	}

	return QWidget::event( a_event );
	}

	//---------------------------------------------------------------------------
	void MainWindow::closeEvent( QCloseEvent* a_event )
	{
	if ( _futureWatcher.isRunning() )
	a_event->ignore();
	else
	a_event->accept();
	}

	//---------------------------------------------------------------------------
	void MainWindow::startExecution()
	{
	if ( _futureWatcher.isRunning() )
	return;

	ProgramSettings pset;

	processArguments( pset );
	logon( pset );

	connect( _updater, SIGNAL(progress(int)), _progress, SLOT(setValue(int)) );
	connect( _updater, SIGNAL(error(const QString&)), this, SLOT(error(const QString&)) );
	connect( _updater, SIGNAL(message(const QString&)), this, SLOT(message(const QString&)) );
	connect( _updater, SIGNAL(sqlError(const QString&,const QString&,const QString&)),
	this, SLOT(sqlError(const QString&,const QString&,const QString&)) );
	connect( _updater, SIGNAL(logConnectionParameters(const QString&,const QString&,const QString&)),
	this, SLOT(logConnectionParameters(const QString&,const QString&,const QString&)) );
	connect( &_futureWatcher, SIGNAL(finished()), this, SLOT(finishExecution()) );

	_ai->setVisible( true );
	_ai->start();

	//int rc = _updater.run( pset );
	QFuture<int> rc = QtConcurrent::run( _updater, &DatabaseUpdater::run, pset );
	_futureWatcher.setFuture( rc );
	}

	//---------------------------------------------------------------------------
	void MainWindow::finishExecution()
	{
	_ai->stop();
	_ai->setVisible( false );

	//проверяем число ошибок, т.к. при выполнении без транзакции run() всегда возвращает 0
	if ( _errorCount == 0 )
	{
	int before = _updater->revisionBefore();
	int after = _updater->revisionAfter();

	if ( before == after )
	message( QString::fromUtf8( "База данных в актуальном состоянии." ) );
	else if ( before == 0 )
	message( QString::fromUtf8( "База данных создана и обновлена до версии %1." ).arg( after ) );
	else
	message( QString::fromUtf8( "База данных версии %1 обновлена до версии %2." ).
	arg( before ).arg( after ) );
	_exitCode = (before & 0xFFFF) \| ((after & 0xFFFF) << 16);

	closeDialog(); //при успешном завершении, то окно закрывается автоматически
	}
	else
	{
	_btnClose->show();
	_btnSave->show();
	_btnClose->setFocus();
	message( QString::fromUtf8( "Выполнение прервано в результате ошибки."
	"<br>База данных не изменилась.") );
	_exitCode = -1;
	}
	}

	//---------------------------------------------------------------------------
	int MainWindow::executeAction()
	{
	ProgramSettings pset;

	processArguments( pset );
	logon( pset );

	_ai->start();
	DatabaseUpdater updater;

	connect( &updater, SIGNAL(progress(int)), _progress, SLOT(setValue(int)) );
	connect( &updater, SIGNAL(error(const QString&)), this, SLOT(error(const QString&)) );
	connect( &updater, SIGNAL(message(const QString&)), this, SLOT(message(const QString&)) );
	connect( &updater, SIGNAL(sqlError(const QString&,const QString&,const QString&)),
	this, SLOT(sqlError(const QString&,const QString&,const QString&)) );
	connect( &updater, SIGNAL(logConnectionParameters(const QString&,const QString&,const QString&)),
	this, SLOT(logConnectionParameters(const QString&,const QString&,const QString&)) );

	int rc = updater.run( pset );

	//проверяем число ошибок, т.к. при выполнении без транзакции run() всегда возвращает 0
	if ( _errorCount == 0 )
	{
	int before = updater.revisionBefore();
	int after = updater.revisionAfter();

	if ( before == after )
	message( QString::fromUtf8( "База данных в актуальном состоянии." ) );
	else if ( before == 0 )
	message( QString::fromUtf8( "База данных создана и обновлена до версии %1." ).arg( after ) );
	else
	message( QString::fromUtf8( "База данных версии %1 обновлена до версии %2." ).
	arg( before ).arg( after ) );
	rc = (before & 0xFFFF) \| ((after & 0xFFFF) << 16);
	}
	else
	{
	_btnClose->show();
	_btnSave->show();
	_btnClose->setFocus();
	message( QString::fromUtf8( "Выполнение прервано в результате ошибки."
	"<br>База данных не изменилась.") );
	rc = -1;
	}
	return rc;
	}

	void MainWindow::processArguments( ProgramSettings& a_pset )
	{
	QString USERNAME_PARAM( "username" );
	QString PASSWORD_PARAM( "password" );
	QString DATABASE_PARAM( "database" );
	QString DROPDB_PARAM( "dropdb" );
	QString HOST_PARAM( "host" );
	QString PORT_PARAM( "port" );
	QString FILE_PARAM( "file" );

	//заполнить параметры default значениями
	QHash<QString, QString> params;
	params.insert( USERNAME_PARAM, QString() );
	params.insert( PASSWORD_PARAM, QString() );
	params.insert( DATABASE_PARAM, QString() );
	params.insert( DROPDB_PARAM, QString() );
	params.insert( HOST_PARAM, QString() );
	params.insert( PORT_PARAM, QString() );
	params.insert( FILE_PARAM, QString() );

	//чтение аргументов
	QString key;
	QString curArg;
	QStringListIterator args( QApplication::arguments() );
	args.next(); //пропускаем первый параметр - имя программы
	while ( args.hasNext() )
	{
	curArg = args.next();

	if ( curArg.startsWith( "--" ) )
	{//обработка длинного параметра
	curArg.remove( 0, 2 );
	QMutableHashIterator<QString, QString> option( params );
	while ( option.hasNext() )
	{
	option.next();
	key = option.key();
	if ( curArg.startsWith( key ) && curArg.at( key.size() ) == '=' )
	option.setValue( curArg.right( curArg.size() - key.size() - 1 ) );
	}
	key.clear();
	}
	else if ( curArg.at( 0 ) == QChar('-') )
	{//обработка короткого параметра
	key.clear();
	switch ( curArg.at( 1 ).toLatin1() )
	{
	case 'U':
	key = USERNAME_PARAM;
	break;
	case 'd':
	key = DATABASE_PARAM;
	break;
	case 'f':
	key = FILE_PARAM;
	break;
	case 'h':
	key = HOST_PARAM;
	break;
	case 'p':
	key = PORT_PARAM;
	break;
	case 'W':
	key = PASSWORD_PARAM;
	break;
	case '0':
	params[ DROPDB_PARAM ] = '1';
	break;
	}
	}
	else
	{//обработка одиночного параметра
	if ( key.isEmpty() )
	key = FILE_PARAM;
	params[ key ] = curArg;
	key.clear();
	}
	}

	//записать прочитанные значения в структуру ProgramSettings
	a_pset.username = params.value( USERNAME_PARAM );
	a_pset.password = params.value( PASSWORD_PARAM );
	a_pset.database = params.value( DATABASE_PARAM );
	a_pset.host = params.value( HOST_PARAM );
	a_pset.port = params.value( PORT_PARAM );
	a_pset.controlFile = params.value( FILE_PARAM );
	a_pset.dropdb = !params.value( DROPDB_PARAM ).isEmpty();
	}

	//---------------------------------------------------------------------------
	void MainWindow::logon( ProgramSettings& a_pset )
	{
	if ( !a_pset.host.isEmpty() \|\| !a_pset.username.isEmpty() )
	return;

	#if defined(Q_OS_WIN)
	KLogon* logon = KLogon::create();
	if ( !logon )
	return;

	QString defaultDSN;

	HKEY k;
	DWORD cb = 0;
	QString valuename( "System Directory" );
	if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\irs\\b03"), 0, KEY_QUERY_VALUE, &k ) == ERROR_SUCCESS
	&& RegQueryValueEx( k, LPCTSTR(valuename.constData()), 0, 0, 0, &cb ) == ERROR_SUCCESS
	&& cb > 0 )
	{
	QString systemdir;
	systemdir.resize( (cb / sizeof(QChar)) - 1 );
	RegQueryValueEx( k, LPCTSTR(valuename.constData()), 0, 0, LPBYTE(systemdir.data()), &cb );
	RegCloseKey( k );

	KSettings systemini( systemdir + "/system.ini" );
	systemini.beginGroup( "Database" );
	defaultDSN = systemini.value( "DefaultDSN" ).toString();
	}
	QString username = QString::fromLocal8Bit( qgetenv( "USERNAME" ) );
	logon->setParent( winId() );
	logon->setUsername( username );
	if ( !defaultDSN.isNull() )
	logon->setDSN( defaultDSN );

	if ( !logon->execute() )
	emit message( QString::fromUtf8( "Отказ от ввода имени и пароля пользователя" ) );
	else
	{
	a_pset.host = logon->host();
	a_pset.username = logon->username();
	a_pset.password = logon->password();
	}

	delete logon;
	#else
	QString username = QString::fromLocal8Bit( getenv( "USER" ) );
	#endif
	}

	//---------------------------------------------------------------------------
	void MainWindow::logConnectionParameters( const QString& a_host,
	const QString& a_database,
	const QString& a_username )
	{
	message( QString::fromUtf8( "Подключение к базе данных<br>"
	"  Сервер: <b>%1</b><br>  База данных: <b>%2</b><br>"
	"  Пользователь: <b>%3</b>").arg( a_host, a_database, a_username ) );
	}

	//---------------------------------------------------------------------------
	void MainWindow::sqlError( const QString& a_dbError,
	const QString& a_commandDescription,
	const QString& a_command )
	{
	QString errorHtml;

	if ( !a_commandDescription.isEmpty() )
	errorHtml.append( QString::fromUtf8( "<font color=\"#0000FF\">Операция:</font><br>" ) ).
	append( a_commandDescription ).append( "<br>" );

	QString dbError = a_dbError;
	errorHtml.append( QString::fromUtf8( "<font color=\"#0000FF\">Сообщение об ошибке:</font><pre>" ) ).
	append( dbError.trimmed().replace( '\n', "<br>" ) ).append( "</pre>");

	if ( !a_command.isEmpty() )
	errorHtml.append( QString::fromUtf8( "<font color=\"#0000FF\">Текст команды:</font><pre>" ) ).
	append( a_command ).append( "</pre>" );

	errorHtmlToLog( errorHtml );
	}

	//---------------------------------------------------------------------------
	void MainWindow::error( const QString& a_error )
	{
	QString errorHtml = a_error;
	errorHtmlToLog( errorHtml.replace( '<', "<" ).replace( '>', ">" ).replace( '\n', "<br>" ) );
	}

	//---------------------------------------------------------------------------
	void MainWindow::errorHtmlToLog( const QString& a_errorHtml )
	{
	QString errorHtml = a_errorHtml;
	QTextCursor cursor = _protocol->textCursor();
	cursor.insertHtml( QString::fromUtf8( "<font color=\"#0000FF\">Ошибка</font><br>" ) );
	cursor.insertHtml( errorHtml );
	cursor.insertHtml( QString::fromUtf8( "<hr>" ) );
	_protocol->moveCursor( QTextCursor::End );
	++_errorCount;
	}

	//---------------------------------------------------------------------------
	void MainWindow::message( const QString& a_message )
	{
	QString message = a_message;
	_protocol->textCursor().insertHtml( message.replace( QChar('\n'), "<br>" ).append( "<br>" ) );
	_protocol->moveCursor( QTextCursor::End );
	}

	//---------------------------------------------------------------------------
	void MainWindow::closeDialog()
	{
	QDialog::done( _exitCode );
	}

	//---------------------------------------------------------------------------
	void MainWindow::saveProtocol()
	{
	QString filename = QFileDialog::getSaveFileName( this,
	QString::fromUtf8( "Сохранить протокол в файл…" ), QString(),
	QString::fromUtf8( "Текстовые файлы (.txt);;Все файлы (.*)" ) );
	if ( !filename.isEmpty() )
	{
	QFile outf( filename );
	if ( outf.open( QIODevice::WriteOnly \| QIODevice::Truncate ) )
	{
	QTextStream os( &outf );
	os.setGenerateByteOrderMark( true );
	os.setCodec( "UTF-8" );
	os << _protocol->toPlainText();
	}
	}
	}

	//!главное окно приложения
	diff --git a/src/restruct.cpp b/src/restruct.cpp
	--- a/src/restruct.cpp
	+++ b/src/restruct.cpp
	@@ -1,55 +1,57 @@
	-#include "stable.h"
	#include "mainwindow.h"
	+#include <QApplication>
	+#include <QDesktopWidget>
	+#include <QTranslator>

	#ifdef Q_OS_WIN32
	#include <qt_windows.h>
	#endif

	int main( int argc, char* argv[] )
	{

	//int width = 504;
	//int height = 262;
	int width = 679;
	int height = 420;

	QApplication app( argc, argv );

	//загрузка русской локализации библиотеки Qt
	QTranslator translator;
	translator.load( QString("qt_ru") );
	app.installTranslator(&translator);

	//создание главного окна
	MainWindow window;

	#ifdef Q_OS_WIN32
	//масштабирование для случая увеличенного шрифта
	HWND hwnd = (HWND)app.desktop()->winId();
	int dpi = GetDeviceCaps( GetDC(hwnd), LOGPIXELSY );
	if ( dpi != 96 )
	{
	width = (width * dpi) / 96;
	height = (height * dpi) / 96;
	}

	//шрифт окна такой же, как в системе подписи к иконкам
	LOGFONTW lf;
	SystemParametersInfoW( SPI_GETICONTITLELOGFONT, sizeof(lf), &lf, 0 );
	int fh = qAbs( (lf.lfHeight * 72) / dpi );
	QString fn( (const QChar*)lf.lfFaceName, wcslen(lf.lfFaceName) );
	window.setStyleSheet(
	QString( "*{ font-family: %1; font-size: %2pt; }" ).arg( fn ).arg( fh ) );
	#endif

	//перемещение главного окна в центр экрана
	window.setMinimumSize( width, height );
	QRect wg = window.geometry();
	wg.setSize( window.minimumSize() );
	wg.moveCenter( qApp->desktop()->screenGeometry().center() );
	window.setGeometry( wg );

	int exitCode = window.exec();
	return exitCode;
	}
	//!приложение restruct
	diff --git a/src/sqlerrordlg.cpp b/src/sqlerrordlg.cpp
	--- a/src/sqlerrordlg.cpp
	+++ b/src/sqlerrordlg.cpp
	@@ -1,45 +1,49 @@
	-#include "stable.h"
	+#include <QLabel>
	+#include <QHBoxLayout>
	+#include <QVBoxLayout>
	+#include <QPushButton>
	+#include <QTextEdit>
	#include "sqlerrordlg.h"

	//---------------------------------------------------------------------------
	//---------------------------------------------------------------------------
	SqlErrorDialog::SqlErrorDialog( QWidget* parent, Qt::WindowFlags flags )
	: QDialog( parent, flags )
	{
	setWindowTitle( QString::fromUtf8( "Список ошибок" ) );
	setWindowFlags( windowFlags() & ~Qt::WindowContextHelpButtonHint );
	setSizeGripEnabled( true );
	setMinimumSize( QSize( 512, 428 ) );

	QVBoxLayout* mainLayout = new QVBoxLayout( this );
	QHBoxLayout* layout = new QHBoxLayout;
	mainLayout->addLayout( layout );

	QLabel* label = new QLabel(
	QString( "Во время выполнения команд произошли\nследующие ошибки:" ) );
	layout->addWidget( label );
	layout->addStretch();

	_btnClose = new QPushButton( QString( "Закрыть" ) );
	_btnClose->setDefault( true );
	layout->addWidget( _btnClose );

	_errorLog = new QTextEdit;
	_errorLog->setReadOnly( true );
	mainLayout->addWidget( _errorLog );

	connect( _btnClose, SIGNAL(clicked()), this, SLOT(close()) );
	}

	SqlErrorDialog::~SqlErrorDialog()
	{
	}

	void SqlErrorDialog::setLogText( const QString& a_text )
	{
	_errorLog->clear();
	_errorLog->setHtml( a_text );
	}


	//!главное окно приложения
	diff --git a/src/stable.h b/src/stable.h
	deleted file mode 100644
	--- a/src/stable.h
	+++ /dev/null
	@@ -1,25 +0,0 @@
	-#include <QApplication>
	-#include <QCheckBox>
	-#include <QCloseEvent>
	-#include <QtConcurrentRun>
	-#include <QDesktopWidget>
	-#include <QDialog>
	-#include <QFile>
	-#include <QFileDialog>
	-#include <QGroupBox>
	-#include <QHash>
	-#include <QHBoxLayout>
	-#include <QLabel>
	-#include <QListWidget>
	-#include <QMessageBox>
	-#include <QProgressBar>
	-#include <QPushButton>
	-#include <QShortcut>
	-#include <QtDebug>
	-#include <QTemporaryFile>
	-#include <QTextCodec>
	-#include <QTextEdit>
	-#include <QTime>
	-#include <QTranslator>
	-#include <QVBoxLayout>
	-#include <QXmlStreamReader>
	diff --git a/src/stable.h.cpp b/src/stable.h.cpp
	deleted file mode 100644
	--- a/src/stable.h.cpp
	+++ /dev/null
	@@ -1,16 +0,0 @@
	-/*--------------------------------------------------------------------
	-* Precompiled header source file used by Visual Studio.NET to generate
	-* the .pch file.
	-*
	-* Due to issues with the dependencies checker within the IDE, it
	-* sometimes fails to recompile the PCH file, if we force the IDE to
	-* create the PCH file directly from the header file.
	-*
	-* This file is auto-generated by qmake since no PRECOMPILED_SOURCE was
	-* specified, and is used as the common stdafx.cpp. The file is only
	-* generated when creating .vcproj project files, and is not used for
	-* command line compilations by nmake.
	-*
	-* WARNING: All changes made in this file will be lost.
	---------------------------------------------------------------------*/
	-#include "stable.h"
	diff --git a/src/updater.cpp b/src/updater.cpp
	--- a/src/updater.cpp
	+++ b/src/updater.cpp
	@@ -1,875 +1,877 @@
	-#include "stable.h"
	#include "updater.h"
	#include "psettings.h"
	#include <ksds.h>
	#include <ksettings.h>
	#include <sqlproc.h>
	+#include <QCoreApplication>
	+#include <QDate>
	+#include <QDir>
	#include <QXmlStreamReader>

	DatabaseUpdater::DatabaseUpdater()
	: QObject()
	, _pset(0)
	, _revisionBefore(0)
	, _revisionAfter(0)
	{
	}

	DatabaseUpdater::~DatabaseUpdater()
	{
	delete _pset;
	}

	int DatabaseUpdater::run( ProgramSettings& a_pset )
	{
	_pset = new ProgramSettings( a_pset );
	if ( !checkArguments() )
	return -1;

	if ( !readConfig() )
	return -1;

	if ( !loadScriptsFromResource() )
	return -1;

	if ( !runScripts() )
	return -1;

	return 0;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::checkArguments()
	{
	if ( _pset->controlFile.isEmpty() )
	{
	emit error( QString::fromUtf8( "Не задан файл конфигурации." ) );
	return false;
	}

	//если не задано полное имя файла конфигурации, то искать его в текущем каталоге
	QString filename = _pset->controlFile;

	if ( !QDir::isAbsolutePath( filename ) )
	filename = QString( "%1/%2" ).arg( QDir::currentPath() ).arg( _pset->controlFile );

	//проверить наличие файла
	if ( !QFile::exists( filename ) )
	{
	emit error( QString::fromUtf8( "Не найден файл конфигурации\n" ) +
	QDir::toNativeSeparators( filename ) );
	return false;
	}

	_pset->controlFile = filename;
	return true;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::readConfig()
	{
	//открываем входной файл
	QFile controlFile( _pset->controlFile );
	if ( !controlFile.open( QIODevice::ReadOnly ) )
	{
	emit error( QString::fromUtf8( "Сбой при загрузке файла конфигурации:\n"
	"Невозможно открыть для чтения файл %1" ).arg( QDir::toNativeSeparators(
	_pset->controlFile ) ) );
	return false;
	}

	//парсим входной файл
	QXmlStreamReader xml;
	xml.setDevice( &controlFile );

	emit message( QString::fromUtf8( "Загрузка конфигурации из файла\n%1" ).
	arg( QDir::toNativeSeparators( _pset->controlFile ) ) );

	//идём по элементам документа
	while ( !xml.atEnd() )
	{
	xml.readNext();
	if ( xml.isStartElement() && xml.name() == "package" )
	if ( !readPackage( xml ) )
	return false;
	}

	if ( xml.hasError() )
	{
	emit error( QString::fromUtf8( "Сбой при загрузке файла конфигурации:\n"
	"Ошибка: %1, строка %2, позиция %3").
	arg( xml.errorString() ).arg( xml.lineNumber() ).arg( xml.columnNumber() ) );
	return false;
	}

	controlFile.close();

	//найти файл с расширением pkginfo и именем как у входного файла, если такого нет,
	//то использовать первый попавшийся файл с расширением pkginfo;
	//прочитать из него идентификатор пакета и имя базы данных;
	//если файла нет, то и не надо
	QFileInfo fi( controlFile );
	QStringList files = QDir( QFileInfo( controlFile ).path(), "*.pkginfo",
	QDir::NoSort, QDir::Files ).entryList();
	if ( !files.isEmpty() )
	{
	QString pkgfile = QFileInfo( controlFile ).completeBaseName() + ".pkginfo";

	if ( !files.contains( pkgfile, Qt::CaseInsensitive ) )
	pkgfile = files.at( 0 );

	pkgfile = QFileInfo( controlFile ).path() + '/' + pkgfile;
	emit message( QString::fromUtf8( "Загрузка конфигурации из файла\n%1" ).
	arg( QDir::toNativeSeparators( pkgfile ) ) );

	KSettings pkginfo( pkgfile );
	pkginfo.beginGroup( "package" );

	QString s = pkginfo.value( "dbname" ).toString();
	if ( !s.isEmpty() && _pset->database.isEmpty() )
	_pset->database = s;

	QStringList ver = pkginfo.value( "version" ).toString().split( QChar('.') );
	if ( ver.size() > 1 )
	{
	s = ver.at( 1 );
	bool ok;
	int i = s.toInt( &ok );
	if ( ok )
	_pset->dbVersion = i;
	}

	_pset->packageId = pkginfo.value( "id" ).toString();
	}

	//после загрузки конфигурации из файлов должно быть определено имя БД
	if ( _pset->database.isEmpty() )
	{
	emit error( QString::fromUtf8( "Не задано имя базы данных" ) );
	return false;
	}
	return true;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::readPackage( QXmlStreamReader& a_xml )
	{
	const QXmlStreamAttributes& packageAttrs = a_xml.attributes();
	QString packageId = packageAttrs.value( "id" ).toString();
	QString uriAttr = packageAttrs.value( "uri" ).toString();
	bool uri = !((uriAttr == "no") \|\| (uriAttr == "нет"));

	Package* package = new Package( packageId, uri );
	_packages.append( package );

	//собираем информацию о скриптах данного пакета
	const QString SCRIPT_NODE( "script" );
	const QString REVISION_ATTR( "revision" );
	const QString TRANSACTION_ATTR( "transaction" );
	const QString COMMENT_ATTR( "comment" );
	const QString SCRIPT_ATTR( "file" );
	const QString URI_DATA_ATTR( "udata" );
	const QString NO_REQUIRED_ATTR = QString::fromUtf8( "Неправильное содержание файла конфигурации:\n"
	"Не указан обязательный атрибут «%1» пакета «%2»" );

	while ( !a_xml.atEnd() )
	{
	a_xml.readNext();
	if ( a_xml.isStartElement() && a_xml.name() == SCRIPT_NODE )
	{
	const QXmlStreamAttributes& attrs = a_xml.attributes();
	//проверка наличия обязательных атрибутов
	if ( !attrs.hasAttribute( REVISION_ATTR ) )
	{
	emit error( NO_REQUIRED_ATTR.arg( REVISION_ATTR ).arg( packageId ) );
	return false;
	}
	if ( !attrs.hasAttribute( SCRIPT_ATTR ) )
	{
	emit error( NO_REQUIRED_ATTR.arg( SCRIPT_ATTR ).arg( packageId ) );
	return false;
	}
	//проверка правильности указания атрибутов
	bool ok;
	int revision = attrs.value( REVISION_ATTR ).toString().toInt( &ok );
	if ( !ok )
	{
	emit error( QString::fromUtf8(
	"Атрибут «revision» пакета «%1» должен быть числом" ).
	arg( packageId ) );
	return false;
	}

	//заносим информацию о скрипте в список скриптов пакета
	QString file = attrs.value( SCRIPT_ATTR ).toString();
	QString uriScript = attrs.value( URI_DATA_ATTR ).toString();
	QString comment = attrs.value( COMMENT_ATTR ).toString();
	QString strans = attrs.value( TRANSACTION_ATTR ).toString();
	bool transaction = !((strans == "0") \|\|
	(strans.compare( "no", Qt::CaseInsensitive ) == 0) \|\|
	(strans.compare( "нет", Qt::CaseInsensitive ) == 0));

	DatabaseScript* script = new DatabaseScript( revision, transaction,
	file, uriScript, comment );
	package->addScript( script );
	}
	}

	//упорядочить скрипты по возрастанию номеров ревизий
	package->sortScripts();

	return true;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::runScripts()
	{
	//определение пакета, скрипты которого будут выполняться
	Package* package = 0;
	QListIterator<Package*> it( _packages );
	while ( it.hasNext() )
	{
	package = it.next();
	if ( package->id() == _pset->packageId )
	break;
	else
	package = 0;
	}

	if ( !package )
	{
	emit error( QString::fromUtf8( "Для пакета «%1» не задано ни одного "
	"сценария создания базы данных" ).arg( _pset->packageId ) );
	return false;
	}

	//проверка наличия файлов со скриптами на диске
	QStringList paths;
	QFileInfo fi( _pset->controlFile );
	paths << fi.canonicalPath() << fi.canonicalPath() + "/script" << QDir::currentPath();

	DatabaseScript* script = 0;
	QListIterator<DatabaseScript*> it2( package->scripts() );
	while ( it2.hasNext() )
	{
	script = it2.next();
	if ( !script->findScript( paths ) )
	{
	emit error( QString::fromUtf8( "Не найден файл сценария создания "
	"базы данных %1" ).arg( script->script() ) );
	return false;
	}
	if ( package->uri() && !script->findUriScript( paths ) )
	{
	emit error( QString::fromUtf8( "Не найден файл условно-реальной "
	"информации %1" ).arg( script->uriScript() ) );
	return false;
	}
	}

	QString curDate = QDate::currentDate().toString( Qt::ISODate );
	SqlProcessor proc;
	SqlProcessor uriProc;

	emit message( QString::fromUtf8( "Подключение к серверу баз данных" ) );

	//пока идут служебные подключения к БД и запросы, подключаем только сигнал error
	connect( &proc, SIGNAL(error(const QString&,const QString&,const QString&)),
	this, SIGNAL(sqlError(const QString&,const QString&,const QString&)) );
	connect( &uriProc, SIGNAL(error(const QString&,const QString&,const QString&)),
	this, SIGNAL(sqlError(const QString&,const QString&,const QString&)) );

	qApp->processEvents( QEventLoop::ExcludeUserInputEvents );

	//---- template1 ----
	//попытка подключения к template1 и получение списка таблиц
	if ( !proc.connectdb( _pset->host, _pset->port, "template1", _pset->username,
	_pset->password ) )
	return false;

	QStringList template1Tables = databaseTableList( proc );
	int currentDatabaseRevision = 0; //БД нет или пустая

	//удаление БД если задано параметром при запуске программы
	bool dbExists = databaseExists( proc, _pset->database );
	if ( dbExists && _pset->dropdb )
	{
	emit message( QString::fromUtf8( "Удаление базы данных <b>%1</b>" ).arg( _pset->database ) );
	qApp->processEvents( QEventLoop::ExcludeUserInputEvents );

	if ( !dropDatabase( proc, _pset ) )
	return false;
	dbExists = false;
	}
	//создание БД если она не существует
	if ( !dbExists )
	{
	emit message( QString::fromUtf8( "Создание базы данных <b>%1</b>" ).arg( _pset->database ) );
	qApp->processEvents( QEventLoop::ExcludeUserInputEvents );

	if ( !createDatabase( proc, _pset ) )
	return false;
	}

	QString uriDatabase = _pset->database + "_u";
	if ( package->uri() )
	{
	//удаление учебной БД если задано параметром при запуске программы
	bool uriDbExists = databaseExists( proc, uriDatabase );
	if ( uriDbExists && _pset->dropdb )
	{
	emit message( QString::fromUtf8( "Удаление учебной базы данных <b>%1</b>" ).arg( uriDatabase ) );
	qApp->processEvents( QEventLoop::ExcludeUserInputEvents );

	if ( !dropDatabase( proc, _pset, uriDatabase ) )
	return false;
	uriDbExists = false;
	}
	//создание учебной БД если она не существует
	if ( !uriDbExists )
	{
	emit message( QString::fromUtf8( "Создание учебной базы данных <b>%1</b>" ).arg( uriDatabase ) );
	qApp->processEvents( QEventLoop::ExcludeUserInputEvents );

	if ( !createDatabase( proc, _pset, uriDatabase ) )
	return false;
	}
	}

	connect( &proc, SIGNAL(afterConnect(QString,QString,QString,QString,QString)),
	this, SLOT(afterConnect(QString,QString,QString,QString,QString)) );

	//---- database ----
	//подключение к созданной/существующей БД и получение списка таблиц
	if ( !proc.connectdb( _pset->host, _pset->port, _pset->database, _pset->username,
	_pset->password ) )
	return false;

	QStringList databaseTables = databaseTableList( proc );

	//подключение к учебной БД и получение списка таблиц
	QStringList uriDatabaseTables;
	if ( package->uri() )
	{
	//---- database_u ----
	if ( !uriProc.connectdb( _pset->host, _pset->port, uriDatabase,
	_pset->username, _pset->password ) )
	return false;

	uriDatabaseTables = databaseTableList( uriProc );
	}

	//считывание данных о версии БД из таблицы dm_version,
	//эта таблица существует только в основной БД, версия учебной должна совпадать
	bool legacyDatabase = false;
	proc.execSQL( "select relnatts from pg_class "
	"where relname='dm_version' and relkind='r'" );
	KSimpleDataSet data = proc.result();

	//если пустой результат запроса, значит таблицы dm_version нет в БД
	bool createDmVersion = data.size() == 0;

	//если таблица есть, то сравнить число её атрибутов с эталоном
	data.first();
	if ( data.isValid() && data.value( 0 ).toInt() != DM_VERSION_FIELDS_COUNT )
	{ //не та структура, удаляем таблицу
	if ( !proc.execSQL( "drop table dm_version" ) )
	return false;
	createDmVersion = true;
	}

	if ( createDmVersion )
	{ //БД уже существовала, а таблицы dm_version в ней нет, или не та структура
	if ( databaseTables != template1Tables )
	{
	legacyDatabase = true;
	currentDatabaseRevision = 1;
	}

	emit message( QString::fromUtf8( "Создание таблицы изменений БД" ) );
	proc.execSQL( "begin" );
	if ( !proc.execute( _createDmVersionScript ) )
	{
	emit error( QString::fromUtf8( "Сбой при создании таблицы изменений БД" ) );
	return false;
	}

	if ( legacyDatabase )
	{ //запись информации о версии №1 в unversioned БД
	if ( !proc.execSQL( QString::fromUtf8( "insert into dm_version "
	"(revision,package_id,comment,gen_date) values "
	"(1,'%1','Изначальная версия','%2')" ).arg(
	package->id(), curDate ) ) )
	return false;
	}
	proc.execSQL( "commit" );
	}
	else
	{
	proc.execSQL( QString("select max(revision), count(*) from dm_version "
	"where package_id='%1'" ).arg( package->id() ) );
	data = proc.result();
	data.first();
	if ( data.isValid() && (data.value( 1 ) > 0) )
	currentDatabaseRevision = data.value( 0 ).toInt();
	}

	//создание языка plpgsql
	if ( !createLanguagePlpgsql( proc, uriProc, package->uri() ) )
	return false;

	_revisionAfter = _revisionBefore = currentDatabaseRevision;

	//выполнение необходимых скриптов
	connect( &proc, SIGNAL(progress(int)), this, SIGNAL(progress(int)) );
	connect( &uriProc, SIGNAL(progress(int)), this, SIGNAL(progress(int)) );

	QListIterator<DatabaseScript*> iter( package->scripts() );
	while ( iter.hasNext() )
	{
	script = iter.next();
	int revision = script->revision();
	bool transaction = script->transaction();

	//если была найдена изначальная БД, то всё уже сделано для 1-й версии
	if ( (revision == 1) && legacyDatabase )
	continue;

	//пропускаем уже установленные версии БД
	if ( revision <= currentDatabaseRevision )
	continue;

	if ( revision == 1 )
	emit message( QString::fromUtf8( "Создание базы данных версии %1" ).arg( revision ) );
	else
	emit message( QString::fromUtf8( "Обновление базы данных до версии %1" ).arg( revision ) );

	//подготовка скрипта к выполнению
	QList<QByteArray> mainScript;
	QList<QByteArray> globalsScript;
	prepareScripts( script->script(), mainScript, globalsScript );

	//если в скрипте были команды создания глобальных объектов, то выполнить
	//их в отдельной транзакции
	if ( globalsScript.size() > 0 )
	{
	proc.execSQL( "begin" );
	if ( !proc.execute( globalsScript ) )
	return false;
	proc.execSQL( "commit" );
	}

	//выполнение скрипта
	if ( transaction )
	proc.execSQL( "begin" );

	if ( !proc.execute( mainScript ) )
	return false;

	//выполнение скриптов в учебной БД, если задано её создание
	if ( package->uri() )
	{
	if ( transaction )
	uriProc.execSQL( "begin" );

	if ( revision == 1 )
	emit message( QString::fromUtf8( "Создание учебной базы данных версии %1" ).arg( revision ) );
	else
	emit message( QString::fromUtf8( "Обновление учебной базы данных до версии %1" ).arg( revision ) );

	if ( !uriProc.execute( mainScript ) )
	{
	if ( transaction )
	proc.execSQL( "rollback" );
	return false;
	}
	if ( !script->uriScript().isEmpty() )
	{
	emit message( QString::fromUtf8( "Загрузка условной информации в учебную базу данных" ) );

	if ( !uriProc.execute( script->uriScript() ) )
	{
	if ( transaction )
	proc.execSQL( "rollback" );
	return false;
	}
	}
	if ( !uriProc.execute( _setSearchPathScript ) )
	return false;
	clearMaclabels( uriProc );
	if ( transaction )
	uriProc.execSQL( "commit" );
	}

	//сброс параметра search_path, он мог быть изменён при выполнении скрипта
	if ( !proc.execute( _setSearchPathScript ) )
	return false;

	//запись информации о версии в БД
	if ( !proc.execSQL( QString::fromUtf8( "insert into dm_version "
	"(revision,package_id,comment,gen_date) values "
	"(%1,'%2','%3','%4')" ).arg( revision ).
	arg( package->id() ).arg( script->comment() ).
	arg( curDate ) ) )
	return false;

	//сброс мандатных меток, если они есть в БД
	clearMaclabels( proc );

	if ( transaction )
	proc.execSQL( "commit" );

	_revisionAfter = revision;
	}
	return true;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::databaseExists( SqlProcessor& a_proc, const QString& a_dbname )
	{
	a_proc.execSQL( QString( "select 1 from pg_database where datname='%1\'" ).arg(a_dbname) );
	return a_proc.result().size() == 1;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::createDatabase( SqlProcessor& a_proc, ProgramSettings* a_pset,
	const QString& a_dbname )
	{
	if ( a_dbname.isEmpty() && a_pset->database.isEmpty() )
	return false;

	QString dbname = (a_dbname.isEmpty() ? a_pset->database : a_dbname );

	//если уже подключены к указанной БД, то отключение
	if ( a_proc.database() == dbname )
	a_proc.disconnectdb();

	//если не подключены, то подключение к template1
	if ( a_proc.database().isNull() )
	{
	if ( !a_proc.connectdb( a_pset->host, a_pset->port, QString( "template1" ),
	a_pset->username, a_pset->password ) )
	return false;
	}

	//если БД уже существует, то создавать не надо
	if ( databaseExists( a_proc, dbname ) )
	return true;

	return a_proc.execSQL( QString( "create database \"%1\"" ).arg(dbname) )
	&& a_proc.commandStatus() == QString( "CREATE DATABASE" );
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::dropDatabase( SqlProcessor& a_proc, ProgramSettings* a_pset,
	const QString& a_dbname )
	{
	if ( a_pset->database.isEmpty() )
	return false;

	QString dbname = (a_dbname.isEmpty() ? a_pset->database : a_dbname );

	//если уже подключены к указанной БД, то отключение
	if ( a_proc.database() == dbname )
	a_proc.disconnectdb();

	//если не подключены, то подключение к template1
	if ( a_proc.database().isNull() )
	{
	if ( !a_proc.connectdb( a_pset->host, a_pset->port, QString( "template1" ),
	a_pset->username, a_pset->password ) )
	return false;
	}

	//если БД не существует, то удалять не надо
	if ( !databaseExists( a_proc, dbname ) )
	return true;

	return a_proc.execSQL( QString( "drop database \"%1\"" ).arg(dbname) )
	&& a_proc.commandStatus() == QString( "DROP DATABASE" );
	}

	//---------------------------------------------------------------------------
	QStringList DatabaseUpdater::databaseTableList( SqlProcessor& a_proc )
	{
	//получение списка таблиц
	QStringList result;
	if ( !a_proc.execSQL( "select tablename from pg_tables order by tablename" ) )
	return result;

	KSimpleDataSet data = a_proc.result();
	data.first();
	while ( data.isValid() )
	{
	result.append( data.value( 0 ) );
	data.next();
	}
	return result;
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::loadScriptsFromResource()
	{
	QString errmess = QString::fromUtf8( "Сбой при чтении ресурсов программы" );
	SqlProcessor proc;

	QFile resFile( ":/dm_version.sql" );
	if ( !(resFile.open( QIODevice::ReadOnly ) ) )
	{
	emit error( errmess );
	return false;
	}
	_createDmVersionScript = proc.parse( resFile );

	resFile.close();
	resFile.setFileName( ":/create_helper_functions.sql");
	if ( !(resFile.open( QIODevice::ReadOnly ) ) )
	{
	emit error( errmess );
	return false;
	}
	_createHelperFunctionsScript = proc.parse( resFile );

	resFile.close();
	resFile.setFileName( ":/drop_helper_functions.sql");
	if ( !(resFile.open( QIODevice::ReadOnly ) ) )
	{
	emit error( errmess );
	return false;
	}
	_dropHelperFunctionsScript = proc.parse( resFile );

	resFile.close();
	resFile.setFileName( ":/set_search_path.sql");
	if ( !(resFile.open( QIODevice::ReadOnly ) ) )
	{
	emit error( errmess );
	return false;
	}
	_setSearchPathScript = proc.parse( resFile );

	return true;
	}

	//---------------------------------------------------------------------------
	// Подготавливает скрипт, считанный из файла, к выполнению в БД.
	// Команды анализируются и разделяются на два скрипта — основной и глобальных
	// объектов. Обработка заключается в следующем:
	// 1. Команды создания глобальных объектов
	// CREATE GROUP
	// CREATE USER
	// CREATE ROLE
	// CREATE TABLESPACE
	// заменяются вызовами функций-обёрток для их безопасного выполнения.
	// Эти вызовы вставляются в скрипт глобальных объектов. В этот же скрипт
	// добавляются команды создания функций-обёрток и их удаления.
	// 2. Команды установки кодировки клиента
	// SET CLIENT_ENCODING
	// SET NAMES
	// \encoding
	// добавляются в оба скрипта.
	// 3. Команда подключения языка plpgsql
	// CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE plpgsql
	// игнорируется и не попадает ни в один скрипт. Создание языка plpgsql
	// производится отдельно, перед началом выполнения скриптов.
	//---------------------------------------------------------------------------
	void DatabaseUpdater::prepareScripts( const QString& a_filename,
	QList<QByteArray>& oa_mainScript,
	QList<QByteArray>& oa_globalsScript )
	{
	//пропустим файл через парсер, на выходе список команд
	bool helperInjected = false;
	SqlProcessor proc;
	QList<QByteArray> result = proc.parse( a_filename );

	//обход списка и анализ команд
	QListIterator<QByteArray> it( result );
	while ( it.hasNext() )
	{
	const QByteArray originalLine = it.next();
	QByteArray line = originalLine.toLower();

	int i = 0;
	int end = line.size();

	//пропускаем первое слово, перед ним пробелов нет, парсер их убирает
	while ( i != end && !QChar(line.at( i )).isSpace() )
	++i;

	//анализируем первое слово
	QByteArray command1 = line.left( i );
	if ( command1 == "\\encoding" )
	{
	oa_mainScript.append( originalLine );
	oa_globalsScript.append( originalLine );
	continue;
	}

	//переход на начало второго слова
	while ( i != end && QChar(line.at( i )).isSpace() )
	++i;
	int p = i;
	//пропускаем второе слово
	while ( i != end && !QChar(line.at( i )).isSpace() )
	++i;
	//анализируем команду
	QByteArray command2 = line.mid( p, i - p );
	if ( command1 == "set" )
	{
	oa_mainScript.append( originalLine );
	if ( command2 == "names" \|\| command2 == "client_encoding" )
	oa_globalsScript.append( originalLine );
	}
	else if ( command1 == "create" )
	{
	if ( command2 == "group" \|\| command2 == "user" \|\|
	command2 == "role" \|\| command2 == "tablespace" )
	{ //добавляем в выходной скрипт globals вызов безопасной функции-обёртки
	if ( !helperInjected )
	{ //но сначала вставляем команды создания функций-обёрток
	helperInjected = true;
	QListIterator<QByteArray> helperIter( _createHelperFunctionsScript );
	while ( helperIter.hasNext() )
	oa_globalsScript.append( helperIter.next() );
	}
	//переход на начало имени объекта
	while ( i != end && QChar(line.at( i )).isSpace() )
	++i;

	QByteArray name;
	if ( i != end )
	{
	if ( line.at( i ) == '"' )
	{ //если имя объекта начинается с двойной кавычки, то пропуск до следующей
	//двойной кавычки
	++i; //пропустить открывающую двойную кавычку
	p = i;
	while ( i != end && line.at( i ) != '"' )
	++i;
	name = line.mid( p, i - p );
	if ( i != end )
	++i; //пропустить закрывающую двойную кавычку
	}
	else
	{ //пропуск до конца слова
	p = i;
	while ( i != end && !QChar(line.at( i )).isSpace() )
	++i;
	//т.к. имя без двойных кавычек, то перевести его в нижний регистр,
	//как это делает PostgreSQL
	name = line.mid( p, i - p ).toLower();
	if ( name.size() > 0 && name.at( name.size() - 1 ) == ';' )
	name.chop( 1 );
	}
	}

	QByteArray parameters( line.right( end - i ) );
	if ( parameters.size() > 0 && parameters.at( parameters.size() - 1 ) == ';' )
	parameters.chop( 1 );

	QByteArray safeCall( "select safe_create_" );
	safeCall.append( command2 ).append( "('" ).append( name ).append( "','" )
	.append( parameters ).append( "');" );

	oa_globalsScript.append( safeCall );
	}
	else if ( command2 == "trusted" \|\| command2 == "procedural" \|\|
	command2 == "language" )
	{ //create language не нужен
	continue;
	}
	else
	{ //create неглобального объекта, в основной скрипт
	oa_mainScript.append( originalLine );
	}
	}
	else
	{ //все остальные команды в основной скрипт
	oa_mainScript.append( originalLine );
	}
	} //цикл по командам

	if ( helperInjected )
	oa_globalsScript.append( _dropHelperFunctionsScript );
	}

	//---------------------------------------------------------------------------
	void DatabaseUpdater::clearMaclabels( SqlProcessor& a_proc )
	{
	a_proc.execSQL( "select distinct 1 from pg_attribute a join pg_class c "
	"on (a.attrelid=c.oid) where c.relname='pg_class' and a.attname='relmaclabel'" );
	if ( a_proc.result().size() == 1 )
	a_proc.execSQL( "update pg_class set relmaclabel=null" );
	}

	//---------------------------------------------------------------------------
	bool DatabaseUpdater::createLanguagePlpgsql( SqlProcessor& a_proc,
	SqlProcessor& a_uriProc,
	bool a_uri )
	{
	static const char* CREATE_SQL = "create language plpgsql";
	static const char* CHECK_SQL = "select 1 from pg_language where lanname='plpgsql'";

	a_proc.execSQL( CHECK_SQL );
	if ( a_proc.result().size() == 0 )
	{
	if ( !a_proc.execSQL( CREATE_SQL ) )
	return false;
	}
	if ( a_uri )
	{
	a_uriProc.execSQL( CHECK_SQL );
	if ( a_uriProc.result().size() == 0 )
	{
	if ( !a_uriProc.execSQL( CREATE_SQL ) )
	return false;
	}
	}
	return true;
	}

	//---------------------------------------------------------------------------
	void DatabaseUpdater::afterConnect( const QString& a_host, const QString& a_port,
	const QString& a_database, const QString& a_username,
	const QString& a_password )
	{
	Q_UNUSED(a_port);
	Q_UNUSED(a_password);
	emit logConnectionParameters( a_host, a_database, a_username );
	}

	//---------------------------------------------------------------------------
	//---------------------------------------------------------------------------
	bool DatabaseScript::findScript( const QStringList& a_paths )
	{
	_script.replace( QChar('\\'), QChar('/') );
	foreach( QString path, a_paths )
	{
	QDir dir( path );
	if ( dir.exists( _script ) )
	{
	_script = dir.absoluteFilePath( _script );
	return true;
	}
	}
	return false;
	}

	//---------------------------------------------------------------------------
	bool DatabaseScript::findUriScript( const QStringList& a_paths )
	{
	_uriScript.replace( QChar('\\'), QChar('/') );
	if ( _uriScript.isEmpty() )
	return true;

	foreach( QString path, a_paths )
	{
	QDir dir( path );
	if ( dir.exists( _uriScript ) )
	{
	_uriScript = dir.absoluteFilePath( _uriScript );
	return true;
	}
	}
	return false;
	}

File Metadata

Mime Type: text/x-diff
Expires: Wed, Jun 11, 8:13 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 126716

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions