Kexi API Documentation (2.0 alpha)
	Overview Class Hierarchy Classes Classes (annotated) Members Source Files

connection.cpp

Go to the documentation of this file.

/* This file is part of the KDE project
   Copyright (C) 2003-2006 Jaroslaw Staniek <js@iidea.pl>

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#include <kexidb/connection.h>

#include "error.h"
#include "connection_p.h"
#include "connectiondata.h"
#include "driver.h"
#include "driver_p.h"
#include "schemadata.h"
#include "tableschema.h"
#include "relationship.h"
#include "transaction.h"
#include "cursor.h"
#include "global.h"
#include "roweditbuffer.h"
#include "utils.h"
#include "dbproperties.h"
#include "lookupfieldschema.h"
#include "parser/parser.h"

#include <kexiutils/utils.h>
#include <kexiutils/identifier.h>

#include <qdir.h>
#include <qfileinfo.h>
#include <qguardedptr.h>
#include <qdom.h>

#include <klocale.h>
#include <kdebug.h>

#define KEXIDB_EXTENDED_TABLE_SCHEMA_VERSION 1

//#define KEXIDB_LOOKUP_FIELD_TEST

namespace KexiDB {

Connection::SelectStatementOptions::SelectStatementOptions()
 : identifierEscaping(Driver::EscapeDriver|Driver::EscapeAsNecessary)
 , alsoRetrieveROWID(false)
{
}

Connection::SelectStatementOptions::~SelectStatementOptions()
{
}

//================================================

ConnectionInternal::ConnectionInternal(Connection *conn)
 : connection(conn)
{
}

ConnectionInternal::~ConnectionInternal()
{
}

//================================================
class ConnectionPrivate
{
    public:
        ConnectionPrivate(Connection* const conn, ConnectionData &conn_data)
         : conn(conn)
         , conn_data(&conn_data)
         , tableSchemaChangeListeners(101)
         , m_parser(0)
         , tables_byname(101, false)
         , queries_byname(101, false)
         , kexiDBSystemTables(101)
         , dont_remove_transactions(false)
         , skip_databaseExists_check_in_useDatabase(false)
         , default_trans_started_inside(false)
         , isConnected(false)
         , autoCommit(true)
        {
            tableSchemaChangeListeners.setAutoDelete(true);
            obsoleteQueries.setAutoDelete(true);

            tables.setAutoDelete(true);
            tables_byname.setAutoDelete(false);//tables is owner, not me
            kexiDBSystemTables.setAutoDelete(true);//only system tables
            queries.setAutoDelete(true);
            queries_byname.setAutoDelete(false);//queries is owner, not me

            //reasonable sizes: TODO
            tables.resize(101);
            queries.resize(101);
        }
        ~ConnectionPrivate()
        {
            delete m_parser;
        }

        void errorInvalidDBContents(const QString& details) {
            conn->setError( ERR_INVALID_DATABASE_CONTENTS, i18n("Invalid database contents. ")+details);
        }

        QString strItIsASystemObject() const {
            return i18n("It is a system object.");
        }

        inline Parser *parser() { return m_parser ? m_parser : (m_parser = new Parser(conn)); }

        Connection* const conn; 
        QGuardedPtr<ConnectionData> conn_data; 

        Transaction default_trans;
        QValueList<Transaction> transactions;

        QPtrDict< QPtrList<Connection::TableSchemaChangeListenerInterface> > tableSchemaChangeListeners;

        QPtrList<QuerySchema> obsoleteQueries;


        KexiDB::ServerVersionInfo serverVersion;

        KexiDB::DatabaseVersionInfo databaseVersion;

        Parser *m_parser;

        QIntDict<TableSchema> tables;
        QDict<TableSchema> tables_byname;
        QIntDict<QuerySchema> queries;
        QDict<QuerySchema> queries_byname;

        QPtrDict<TableSchema> kexiDBSystemTables;

        DatabaseProperties* dbProperties;

        QString availableDatabaseName; 
        QString usedDatabase; 

        bool dont_remove_transactions : 1;

        bool skip_databaseExists_check_in_useDatabase : 1;

        bool default_trans_started_inside : 1;

        bool isConnected : 1;

        bool autoCommit : 1;

        bool readOnly : 1;
};

}//namespace KexiDB

//================================================
using namespace KexiDB;

QStringList KexiDB_kexiDBSystemTableNames;

Connection::Connection( Driver *driver, ConnectionData &conn_data )
    : QObject()
    ,KexiDB::Object()
    ,d(new ConnectionPrivate(this, conn_data))
    ,m_driver(driver)
    ,m_destructor_started(false)
{
    d->dbProperties = new DatabaseProperties(this);
    m_cursors.setAutoDelete(true);
//  d->transactions.setAutoDelete(true);
    //reasonable sizes: TODO
    m_cursors.resize(101);
//  d->transactions.resize(101);//woohoo! so many transactions?
    m_sql.reserve(0x4000);
}

void Connection::destroy()
{
    disconnect();
    //do not allow the driver to touch me: I will kill myself.
    m_driver->d->connections.take( this );
}

Connection::~Connection()
{
    m_destructor_started = true;
//  KexiDBDbg << "Connection::~Connection()" << endl;
    delete d->dbProperties;
    delete d;
    d = 0;
/*  if (m_driver) {
        if (m_is_connected) {
            //delete own table schemas
            d->tables.clear();
            //delete own cursors:
            m_cursors.clear();
        }
        //do not allow the driver to touch me: I will kill myself.
        m_driver->m_connections.take( this );
    }*/
}

ConnectionData* Connection::data() const
{
    return d->conn_data;
}

bool Connection::connect()
{
    clearError();
    if (d->isConnected) {
        setError(ERR_ALREADY_CONNECTED, i18n("Connection already established.") );
        return false;
    }

    d->serverVersion.clear();
    if (!(d->isConnected = drv_connect(d->serverVersion))) {
        setError(m_driver->isFileDriver() ?
            i18n("Could not open \"%1\" project file.").arg(QDir::convertSeparators(d->conn_data->fileName()))
            : i18n("Could not connect to \"%1\" database server.").arg(d->conn_data->serverInfoString()) );
    }
    return d->isConnected;
}

bool Connection::isDatabaseUsed() const
{
    return !d->usedDatabase.isEmpty() && d->isConnected && drv_isDatabaseUsed();
}

void Connection::clearError()
{
    Object::clearError();
    m_sql = QString::null;
}

bool Connection::disconnect()
{
    clearError();
    if (!d->isConnected)
        return true;

    if (!closeDatabase())
        return false;

    bool ok = drv_disconnect();
    if (ok)
        d->isConnected = false;
    return ok;
}

bool Connection::isConnected() const
{
    return d->isConnected;
}

bool Connection::checkConnected()
{
    if (d->isConnected) {
        clearError();
        return true;
    }
    setError(ERR_NO_CONNECTION, i18n("Not connected to the database server.") );
    return false;
}

bool Connection::checkIsDatabaseUsed()
{
    if (isDatabaseUsed()) {
        clearError();
        return true;
    }
    setError(ERR_NO_DB_USED, i18n("Currently no database is used.") );
    return false;
}

QStringList Connection::databaseNames(bool also_system_db)
{
    KexiDBDbg << "Connection::databaseNames("<<also_system_db<<")"<< endl;
    if (!checkConnected())
        return QStringList();

    QString tmpdbName;
    //some engines need to have opened any database before executing "create database"
    if (!useTemporaryDatabaseIfNeeded(tmpdbName))
        return QStringList();

    QStringList list, non_system_list;

    bool ret = drv_getDatabasesList( list );

    if (!tmpdbName.isEmpty()) {
        //whatever result is - now we have to close temporary opened database:
        if (!closeDatabase())
            return QStringList();
    }

    if (!ret)
        return QStringList();

    if (also_system_db)
        return list;
    //filter system databases:
    for (QStringList::ConstIterator it = list.constBegin(); it!=list.constEnd(); ++it) {
        KexiDBDbg << "Connection::databaseNames(): " << *it << endl;
        if (!m_driver->isSystemDatabaseName(*it)) {
            KexiDBDbg << "add " << *it << endl;
            non_system_list << (*it);
        }
    }
    return non_system_list;
}

bool Connection::drv_getDatabasesList( QStringList &list )
{
    list.clear();
    return true;
}

bool Connection::drv_databaseExists( const QString &dbName, bool ignoreErrors )
{
    QStringList list = databaseNames(true);//also system
    if (error()) {
        return false;
    }

    if (list.find( dbName )==list.end()) {
        if (!ignoreErrors)
            setError(ERR_OBJECT_NOT_FOUND, i18n("The database \"%1\" does not exist.").arg(dbName));
        return false;
    }

    return true;
}

bool Connection::databaseExists( const QString &dbName, bool ignoreErrors )
{
//  KexiDBDbg << "Connection::databaseExists(" << dbName << "," << ignoreErrors << ")" << endl;
    if (!checkConnected())
        return false;
    clearError();

    if (m_driver->isFileDriver()) {
        //for file-based db: file must exists and be accessible
//js: moved from useDatabase():
        QFileInfo file(d->conn_data->fileName());
        if (!file.exists() || ( !file.isFile() && !file.isSymLink()) ) {
            if (!ignoreErrors)
                setError(ERR_OBJECT_NOT_FOUND, i18n("Database file \"%1\" does not exist.")
                .arg(QDir::convertSeparators(d->conn_data->fileName())) );
            return false;
        }
        if (!file.isReadable()) {
            if (!ignoreErrors)
                setError(ERR_ACCESS_RIGHTS, i18n("Database file \"%1\" is not readable.")
                .arg(QDir::convertSeparators(d->conn_data->fileName())) );
            return false;
        }
        if (!file.isWritable()) {
            if (!ignoreErrors)
                setError(ERR_ACCESS_RIGHTS, i18n("Database file \"%1\" is not writable.")
                .arg(QDir::convertSeparators(d->conn_data->fileName())) );
            return false;
        }
        return true;
    }

    QString tmpdbName;
    //some engines need to have opened any database before executing "create database"
    const bool orig_skip_databaseExists_check_in_useDatabase = d->skip_databaseExists_check_in_useDatabase;
    d->skip_databaseExists_check_in_useDatabase = true;
    bool ret = useTemporaryDatabaseIfNeeded(tmpdbName);
    d->skip_databaseExists_check_in_useDatabase = orig_skip_databaseExists_check_in_useDatabase;
    if (!ret)
        return false;

    ret = drv_databaseExists(dbName, ignoreErrors);

    if (!tmpdbName.isEmpty()) {
        //whatever result is - now we have to close temporary opened database:
        if (!closeDatabase())
            return false;
    }

    return ret;
}

#define createDatabase_CLOSE \
    { if (!closeDatabase()) { \
        setError(i18n("Database \"%1\" created but could not be closed after creation.").arg(dbName) ); \
        return false; \
    } }

#define createDatabase_ERROR \
    { createDatabase_CLOSE; return false; }


bool Connection::createDatabase( const QString &dbName )
{
    if (!checkConnected())
        return false;

    if (databaseExists( dbName )) {
        setError(ERR_OBJECT_EXISTS, i18n("Database \"%1\" already exists.").arg(dbName) );
        return false;
    }
    if (m_driver->isSystemDatabaseName( dbName )) {
        setError(ERR_SYSTEM_NAME_RESERVED, 
            i18n("Cannot create database \"%1\". This name is reserved for system database.").arg(dbName) );
        return false;
    }
    if (m_driver->isFileDriver()) {
        //update connection data if filename differs
        d->conn_data->setFileName( dbName );
    }

    QString tmpdbName;
    //some engines need to have opened any database before executing "create database"
    if (!useTemporaryDatabaseIfNeeded(tmpdbName))
        return false;

    //low-level create
    if (!drv_createDatabase( dbName )) {
        setError(i18n("Error creating database \"%1\" on the server.").arg(dbName) );
        closeDatabase();//sanity
        return false;
    }

    if (!tmpdbName.isEmpty()) {
        //whatever result is - now we have to close temporary opened database:
        if (!closeDatabase())
            return false;
    }

    if (!tmpdbName.isEmpty() || !m_driver->d->isDBOpenedAfterCreate) {
        //db need to be opened
        if (!useDatabase( dbName, false/*not yet kexi compatible!*/ )) {
            setError(i18n("Database \"%1\" created but could not be opened.").arg(dbName) );
            return false;
        }
    }
    else {
        //just for the rule
        d->usedDatabase = dbName;
    }

    Transaction trans;
    if (m_driver->transactionsSupported()) {
        trans = beginTransaction();
        if (!trans.active())
            return false;
    }
//not needed since closeDatabase() rollbacks transaction: TransactionGuard trans_g(this);
//  if (error())
//      return false;

    //-create system tables schema objects
    if (!setupKexiDBSystemSchema())
        return false;

    //-physically create system tables
    for (QPtrDictIterator<TableSchema> it(d->kexiDBSystemTables); it.current(); ++it) {
        if (!drv_createTable( it.current()->name() ))
            createDatabase_ERROR;
    }

/* moved to KexiProject...

    //-create default part info
    TableSchema *ts;
    if (!(ts = tableSchema("kexi__parts")))
        createDatabase_ERROR;
    FieldList *fl = ts->subList("p_id", "p_name", "p_mime", "p_url");
    if (!fl)
        createDatabase_ERROR;
    if (!insertRecord(*fl, QVariant(1), QVariant("Tables"), QVariant("kexi/table"), QVariant("http://koffice.org/kexi/")))
        createDatabase_ERROR;
    if (!insertRecord(*fl, QVariant(2), QVariant("Queries"), QVariant("kexi/query"), QVariant("http://koffice.org/kexi/")))
        createDatabase_ERROR;
*/

    //-insert KexiDB version info:
    TableSchema *t_db = tableSchema("kexi__db");
    if (!t_db)
        createDatabase_ERROR;
    if ( !insertRecord(*t_db, "kexidb_major_ver", KexiDB::version().major)
        || !insertRecord(*t_db, "kexidb_minor_ver", KexiDB::version().minor))
        createDatabase_ERROR;

    if (trans.active() && !commitTransaction(trans))
        createDatabase_ERROR;

    createDatabase_CLOSE;
    return true;
}

#undef createDatabase_CLOSE
#undef createDatabase_ERROR

bool Connection::useDatabase( const QString &dbName, bool kexiCompatible, bool *cancelled, MessageHandler* msgHandler )
{
    if (cancelled)
        *cancelled = false;
    KexiDBDbg << "Connection::useDatabase(" << dbName << "," << kexiCompatible <<")" << endl;
    if (!checkConnected())
        return false;

    if (dbName.isEmpty())
        return false;
    QString my_dbName = dbName;
//  if (my_dbName.isEmpty()) {
//      const QStringList& db_lst = databaseNames();
//      if (!db_lst.isEmpty())
//          my_dbName = db_lst.first();
//  }
    if (d->usedDatabase == my_dbName)
        return true; //already used

    if (!d->skip_databaseExists_check_in_useDatabase) {
        if (!databaseExists(my_dbName, false /*don't ignore errors*/))
            return false; //database must exist
    }

    if (!d->usedDatabase.isEmpty() && !closeDatabase()) //close db if already used
        return false;

    d->usedDatabase = "";

    if (!drv_useDatabase( my_dbName, cancelled, msgHandler )) {
        if (cancelled && *cancelled)
            return false;
        QString msg(i18n("Opening database \"%1\" failed.").arg( my_dbName ));
        if (error())
            setError( this, msg );
        else
            setError( msg );
        return false;
    }

    //-create system tables schema objects
    if (!setupKexiDBSystemSchema())
        return false;

    if (kexiCompatible && my_dbName.lower()!=anyAvailableDatabaseName().lower()) {
        //-get global database information
        int num;
        bool ok;
//      static QString notfound_str = i18n("\"%1\" database property not found");
        num = d->dbProperties->value("kexidb_major_ver").toInt(&ok);
        if (!ok)
            return false;
        d->databaseVersion.major = num;
/*      if (true!=querySingleNumber(
            "select db_value from kexi__db where db_property=" + m_driver->escapeString(QString("kexidb_major_ver")), num)) {
            d->errorInvalidDBContents(notfound_str.arg("kexidb_major_ver"));
            return false;
        }*/
        num = d->dbProperties->value("kexidb_minor_ver").toInt(&ok);
        if (!ok)
            return false;
        d->databaseVersion.minor = num;
/*      if (true!=querySingleNumber(
            "select db_value from kexi__db where db_property=" + m_driver->escapeString(QString("kexidb_minor_ver")), num)) {
            d->errorInvalidDBContents(notfound_str.arg("kexidb_minor_ver"));
            return false;
        }*/

#if 0 //this is already checked in DriverManagerInternal::lookupDrivers()
        //** error if major version does not match
        if (m_driver->versionMajor()!=KexiDB::versionMajor()) {
            setError(ERR_INCOMPAT_DATABASE_VERSION,
                i18n("Database version (%1) does not match Kexi application's version (%2)")
                .arg( QString("%1.%2").arg(versionMajor()).arg(versionMinor()) )
                .arg( QString("%1.%2").arg(KexiDB::versionMajor()).arg(KexiDB::versionMinor()) ) );
            return false;
        }
        if (m_driver->versionMinor()!=KexiDB::versionMinor()) {
            //js TODO: COMPATIBILITY CODE HERE!
            //js TODO: CONVERSION CODE HERE (or signal that conversion is needed)
        }
#endif
    }
    d->usedDatabase = my_dbName;
    return true;
}

bool Connection::closeDatabase()
{
    if (d->usedDatabase.isEmpty())
        return true; //no db used
    if (!checkConnected())
        return true;

    bool ret = true;

    if (m_driver->transactionsSupported()) {
        //rollback all transactions
        QValueList<Transaction>::ConstIterator it;
        d->dont_remove_transactions=true; //lock!
        for (it=d->transactions.constBegin(); it!= d->transactions.constEnd(); ++it) {
            if (!rollbackTransaction(*it)) {//rollback as much as you can, don't stop on prev. errors
                ret = false;
            }
            else {
                KexiDBDbg << "Connection::closeDatabase(): transaction rolled back!" << endl;
                KexiDBDbg << "Connection::closeDatabase(): trans.refcount==" <<
                 ((*it).m_data ? QString::number((*it).m_data->refcount) : "(null)") << endl;
            }
        }
        d->dont_remove_transactions=false; //unlock!
        d->transactions.clear(); //free trans. data
    }

    //delete own cursors:
    m_cursors.clear();
    //delete own schemas
    d->tables.clear();
    d->kexiDBSystemTables.clear();
    d->queries.clear();

    if (!drv_closeDatabase())
        return false;

    d->usedDatabase = "";
//  KexiDBDbg << "Connection::closeDatabase(): " << ret << endl;
    return ret;
}

QString Connection::currentDatabase() const
{
    return d->usedDatabase;
}

bool Connection::useTemporaryDatabaseIfNeeded(QString &tmpdbName)
{
    if (!m_driver->isFileDriver() && m_driver->beh->USING_DATABASE_REQUIRED_TO_CONNECT
     && !isDatabaseUsed()) {
        //we have no db used, but it is required by engine to have used any!
        tmpdbName = anyAvailableDatabaseName();
        if (tmpdbName.isEmpty()) {
            setError(ERR_NO_DB_USED, i18n("Cannot find any database for temporary connection.") );
            return false;
        }
        const bool orig_skip_databaseExists_check_in_useDatabase = d->skip_databaseExists_check_in_useDatabase;
        d->skip_databaseExists_check_in_useDatabase = true;
        bool ret = useDatabase(tmpdbName, false);
        d->skip_databaseExists_check_in_useDatabase = orig_skip_databaseExists_check_in_useDatabase;
        if (!ret) {
            setError(errorNum(), 
                i18n("Error during starting temporary connection using \"%1\" database name.")
                .arg(tmpdbName) );
            return false;
        }
    }
    return true;
}

bool Connection::dropDatabase( const QString &dbName )
{
    if (!checkConnected())
        return false;

    QString dbToDrop;
    if (dbName.isEmpty() && d->usedDatabase.isEmpty()) {
        if (!m_driver->isFileDriver()
         || (m_driver->isFileDriver() && d->conn_data->fileName().isEmpty()) ) {
            setError(ERR_NO_NAME_SPECIFIED, i18n("Cannot drop database - name not specified.") );
            return false;
        }
        //this is a file driver so reuse previously passed filename
        dbToDrop = d->conn_data->fileName();
    }
    else {
        if (dbName.isEmpty()) {
            dbToDrop = d->usedDatabase;
        } else {
            if (m_driver->isFileDriver()) //lets get full path
                dbToDrop = QFileInfo(dbName).absFilePath();
            else
                dbToDrop = dbName;
        }
    }

    if (dbToDrop.isEmpty()) {
        setError(ERR_NO_NAME_SPECIFIED, i18n("Cannot delete database - name not specified.") );
        return false;
    }

    if (m_driver->isSystemDatabaseName( dbToDrop )) {
        setError(ERR_SYSTEM_NAME_RESERVED, i18n("Cannot delete system database \"%1\".").arg(dbToDrop) );
        return false;
    }

    if (isDatabaseUsed() && d->usedDatabase == dbToDrop) {
        //we need to close database because cannot drop used this database
        if (!closeDatabase())
            return false;
    }

    QString tmpdbName;
    //some engines need to have opened any database before executing "drop database"
    if (!useTemporaryDatabaseIfNeeded(tmpdbName))
        return false;

    //ok, now we have access to dropping
    bool ret = drv_dropDatabase( dbToDrop );

    if (!tmpdbName.isEmpty()) {
        //whatever result is - now we have to close temporary opened database:
        if (!closeDatabase())
            return false;
    }
    return ret;
}

QStringList Connection::objectNames(int objType, bool* ok)
{
    QStringList list;

    if (!checkIsDatabaseUsed()) {
        if(ok) 
            *ok = false;
        return list;
    }

    QString sql;
    if (objType==KexiDB::AnyObjectType)
        sql = "SELECT o_name FROM kexi__objects";
    else
        sql = QString::fromLatin1("SELECT o_name FROM kexi__objects WHERE o_type=%1").arg(objType);

    Cursor *c = executeQuery(sql);
    if (!c) {
        if(ok) 
            *ok = false;
        return list;
    }

    for (c->moveFirst(); !c->eof(); c->moveNext()) {
        QString name = c->value(0).toString();
        if (KexiUtils::isIdentifier( name )) {
            list.append(name);
        }
    }

    if (!deleteCursor(c)) {
        if(ok)
            *ok = false;
        return list;
    }

    if(ok)
        *ok = true;
    return list;
}

QStringList Connection::tableNames(bool also_system_tables)
{
    bool ok = true;
    QStringList list = objectNames(TableObjectType, &ok);
    if (also_system_tables && ok) {
        list += Connection::kexiDBSystemTableNames();
    }
    return list;
}

const QStringList& Connection::kexiDBSystemTableNames()
{
    if (KexiDB_kexiDBSystemTableNames.isEmpty()) {
        KexiDB_kexiDBSystemTableNames
        << "kexi__objects"
        << "kexi__objectdata"
        << "kexi__fields"
//      << "kexi__querydata"
//      << "kexi__queryfields"
//      << "kexi__querytables"
        << "kexi__db"
        ;
    }
    return KexiDB_kexiDBSystemTableNames;
}

KexiDB::ServerVersionInfo* Connection::serverVersion() const
{
    return isConnected() ? &d->serverVersion : 0;
}

KexiDB::DatabaseVersionInfo* Connection::databaseVersion() const
{
    return isDatabaseUsed() ? &d->databaseVersion : 0;
}

DatabaseProperties& Connection::databaseProperties()
{
    return *d->dbProperties;
}

QValueList<int> Connection::tableIds()
{
    return objectIds(KexiDB::TableObjectType);
}

QValueList<int> Connection::queryIds()
{
    return objectIds(KexiDB::QueryObjectType);
}

QValueList<int> Connection::objectIds(int objType)
{
    QValueList<int> list;

    if (!checkIsDatabaseUsed())
        return list;

    Cursor *c = executeQuery(
        QString::fromLatin1("SELECT o_id, o_name FROM kexi__objects WHERE o_type=%1").arg(objType));
    if (!c)
        return list;
    for (c->moveFirst(); !c->eof(); c->moveNext())
    {
        QString tname = c->value(1).toString(); //kexi__objects.o_name
        if (KexiUtils::isIdentifier( tname )) {
            list.append(c->value(0).toInt()); //kexi__objects.o_id
        }
    }

    deleteCursor(c);

    return list;
}

QString Connection::createTableStatement( const KexiDB::TableSchema& tableSchema ) const
{
// Each SQL identifier needs to be escaped in the generated query.
    QString sql;
    sql.reserve(4096);
    sql = "CREATE TABLE " + escapeIdentifier(tableSchema.name()) + " (";
    bool first=true;
    Field::ListIterator it( tableSchema.m_fields );
    Field *field;
    for (;(field = it.current())!=0; ++it) {
        if (first)
            first = false;
        else
            sql += ", ";
        QString v = escapeIdentifier(field->name()) + " ";
        const bool autoinc = field->isAutoIncrement();
        const bool pk = field->isPrimaryKey() || (autoinc && m_driver->beh->AUTO_INCREMENT_REQUIRES_PK);
//TODO: warning: ^^^^^ this allows only one autonumber per table when AUTO_INCREMENT_REQUIRES_PK==true!
        if (autoinc && m_driver->beh->SPECIAL_AUTO_INCREMENT_DEF) {
            if (pk)
                v += m_driver->beh->AUTO_INCREMENT_TYPE + " " + m_driver->beh->AUTO_INCREMENT_PK_FIELD_OPTION;
            else
                v += m_driver->beh->AUTO_INCREMENT_TYPE + " " + m_driver->beh->AUTO_INCREMENT_FIELD_OPTION;
        }
        else {
            if (autoinc && !m_driver->beh->AUTO_INCREMENT_TYPE.isEmpty())
                v += m_driver->beh->AUTO_INCREMENT_TYPE;
            else
                v += m_driver->sqlTypeName(field->type(), field->precision());

            if (field->isUnsigned())
                v += (" " + m_driver->beh->UNSIGNED_TYPE_KEYWORD);

            if (field->isFPNumericType() && field->precision()>0) {
                if (field->scale()>0)
                    v += QString::fromLatin1("(%1,%2)").arg(field->precision()).arg(field->scale());
                else
                    v += QString::fromLatin1("(%1)").arg(field->precision());
            }
            else if (field->type()==Field::Text && field->length()>0)
                v += QString::fromLatin1("(%1)").arg(field->length());

            if (autoinc)
                v += (" " +
                (pk ? m_driver->beh->AUTO_INCREMENT_PK_FIELD_OPTION : m_driver->beh->AUTO_INCREMENT_FIELD_OPTION));
            else
    //TODO: here is automatically a single-field key created
                if (pk)
                    v += " PRIMARY KEY";
            if (!pk && field->isUniqueKey())
                v += " UNIQUE";
            if (!autoinc && !pk && field->isNotNull())
                v += " NOT NULL"; //only add not null option if no autocommit is set
            if (field->defaultValue().isValid()) {
                QString valToSQL( m_driver->valueToSQL( field, field->defaultValue() ) );
                if (!valToSQL.isEmpty()) //for sanity
                    v += QString::fromLatin1(" DEFAULT ") + valToSQL;
            }
        }
        sql += v;
    }
    sql += ")";
    return sql;
}

//yeah, it is very efficient:
#define C_A(a) , const QVariant& c ## a

#define V_A0 m_driver->valueToSQL( tableSchema.field(0), c0 )
#define V_A(a) +","+m_driver->valueToSQL( \
    tableSchema.field(a) ? tableSchema.field(a)->type() : Field::Text, c ## a )

//      KexiDBDbg << "******** " << QString("INSERT INTO ") + 
//          escapeIdentifier(tableSchema.name()) + 
//          " VALUES (" + vals + ")" <<endl; 

#define C_INS_REC(args, vals) \
    bool Connection::insertRecord(KexiDB::TableSchema &tableSchema args) {\
        return executeSQL( \
         QString("INSERT INTO ") + escapeIdentifier(tableSchema.name()) + " VALUES (" + vals + ")" \
        ); \
    }

#define C_INS_REC_ALL \
C_INS_REC( C_A(0), V_A0 ) \
C_INS_REC( C_A(0) C_A(1), V_A0 V_A(1) ) \
C_INS_REC( C_A(0) C_A(1) C_A(2), V_A0 V_A(1) V_A(2) ) \
C_INS_REC( C_A(0) C_A(1) C_A(2) C_A(3), V_A0 V_A(1) V_A(2) V_A(3) ) \
C_INS_REC( C_A(0) C_A(1) C_A(2) C_A(3) C_A(4), V_A0 V_A(1) V_A(2) V_A(3) V_A(4) ) \
C_INS_REC( C_A(0) C_A(1) C_A(2) C_A(3) C_A(4) C_A(5), V_A0 V_A(1) V_A(2) V_A(3) V_A(4) V_A(5) ) \
C_INS_REC( C_A(0) C_A(1) C_A(2) C_A(3) C_A(4) C_A(5) C_A(6), V_A0 V_A(1) V_A(2) V_A(3) V_A(4) V_A(5) V_A(6) ) \
C_INS_REC( C_A(0) C_A(1) C_A(2) C_A(3) C_A(4) C_A(5) C_A(6) C_A(7), V_A0 V_A(1) V_A(2) V_A(3) V_A(4) V_A(5) V_A(6) V_A(7) )

C_INS_REC_ALL

#undef V_A0
#undef V_A
#undef C_INS_REC

#define V_A0 value += m_driver->valueToSQL( flist->first(), c0 );
#define V_A( a ) value += ("," + m_driver->valueToSQL( flist->next(), c ## a ));
//#define V_ALAST( a ) valueToSQL( flist->last(), c ## a )


#define C_INS_REC(args, vals) \
    bool Connection::insertRecord(FieldList& fields args) \
    { \
        QString value; \
        Field::List *flist = fields.fields(); \
        vals \
        return executeSQL( \
            QString("INSERT INTO ") + \
        ((fields.fields()->first() && fields.fields()->first()->table()) ? \
            escapeIdentifier(fields.fields()->first()->table()->name()) : \
            "??") \
        + "(" + fields.sqlFieldsList(m_driver) + ") VALUES (" + value + ")" \
        ); \
    }

C_INS_REC_ALL

#undef C_A
#undef V_A
#undef V_ALAST
#undef C_INS_REC
#undef C_INS_REC_ALL

bool Connection::insertRecord(TableSchema &tableSchema, QValueList<QVariant>& values)
{
// Each SQL identifier needs to be escaped in the generated query.
    Field::List *fields = tableSchema.fields();
    Field *f = fields->first();
//  QString s_val;
//  s_val.reserve(4096);
    m_sql = QString::null;
    QValueList<QVariant>::ConstIterator it = values.constBegin();
//  int i=0;
    while (f && (it!=values.end())) {
        if (m_sql.isEmpty())
            m_sql = QString("INSERT INTO ") +
                escapeIdentifier(tableSchema.name()) +
                " VALUES (";
        else
            m_sql += ",";
        m_sql += m_driver->valueToSQL( f, *it );
//      KexiDBDbg << "val" << i++ << ": " << m_driver->valueToSQL( f, *it ) << endl;
        ++it;
        f=fields->next();
    }
    m_sql += ")";

//  KexiDBDbg<<"******** "<< m_sql << endl;
    return executeSQL(m_sql);
}

bool Connection::insertRecord(FieldList& fields, QValueList<QVariant>& values)
{
// Each SQL identifier needs to be escaped in the generated query.
    Field::List *flist = fields.fields();
    Field *f = flist->first();
    if (!f)
        return false;
//  QString s_val;
//  s_val.reserve(4096);
    m_sql = QString::null;
    QValueList<QVariant>::ConstIterator it = values.constBegin();
//  int i=0;
    while (f && (it!=values.constEnd())) {
        if (m_sql.isEmpty())
            m_sql = QString("INSERT INTO ") +
                escapeIdentifier(flist->first()->table()->name()) + "(" +
                fields.sqlFieldsList(m_driver) + ") VALUES (";
        else
            m_sql += ",";
        m_sql += m_driver->valueToSQL( f, *it );
//      KexiDBDbg << "val" << i++ << ": " << m_driver->valueToSQL( f, *it ) << endl;
        ++it;
        f=flist->next();
    }
    m_sql += ")";

    return executeSQL(m_sql);
}

bool Connection::executeSQL( const QString& statement )
{
    m_sql = statement; //remember for error handling
    if (!drv_executeSQL( m_sql )) {
        m_errMsg = QString::null; //clear as this could be most probably jsut "Unknown error" string.
        m_errorSql = statement;
        setError(this, ERR_SQL_EXECUTION_ERROR, i18n("Error while executing SQL statement."));
        return false;
    }
    return true;
}

QString Connection::selectStatement( KexiDB::QuerySchema& querySchema,
    const QValueList<QVariant>& params, 
    const SelectStatementOptions& options) const
{
//"SELECT FROM ..." is theoretically allowed "
//if (querySchema.fieldCount()<1)
//      return QString::null;
// Each SQL identifier needs to be escaped in the generated query.

    if (!querySchema.statement().isEmpty())
        return querySchema.statement();

    Field *f;
    uint number = 0;
    bool singleTable = querySchema.tables()->count() <= 1;
    if (singleTable) {
        //make sure we will have single table:
        for (Field::ListIterator it = querySchema.fieldsIterator(); (f = it.current()); ++it, number++) {
            if (querySchema.isColumnVisible(number) && f->table() && f->table()->lookupFieldSchema( *f )) {
                //uups, no, there's at least one left join
                singleTable = false;
                break;
            }
        }
    }

    QString sql; //final sql string
    sql.reserve(4096);
//unused    QString s_from_additional; //additional tables list needed for lookup fields
    QString s_additional_joins; //additional joins needed for lookup fields
    QString s_additional_fields; //additional fields to append to the fields list
    uint internalUniqueTableAliasNumber = 0; //used to build internalUniqueTableAliases
    number = 0;
    for (Field::ListIterator it = querySchema.fieldsIterator(); (f = it.current()); ++it, number++) {
        if (querySchema.isColumnVisible(number)) {
            if (!sql.isEmpty())
                sql += QString::fromLatin1(", ");

            if (f->isQueryAsterisk()) {
                if (!singleTable && static_cast<QueryAsterisk*>(f)->isSingleTableAsterisk()) //single-table *
                    sql += escapeIdentifier(f->table()->name(), options.identifierEscaping) +
                           QString::fromLatin1(".*");
                else //all-tables * (or simplified table.* when there's only one table)
                    sql += QString::fromLatin1("*");
            }
            else {
                if (f->isExpression()) {
                    sql += f->expression()->toString();
                }
                else {
                    if (!f->table()) //sanity check
                        return QString::null;

                    QString tableName;
                    int tablePosition = querySchema.tableBoundToColumn(number);
                    if (tablePosition>=0)
                        tableName = querySchema.tableAlias(tablePosition);
                    if (tableName.isEmpty())
                        tableName = f->table()->name();

                    if (!singleTable) {
                        sql += (escapeIdentifier(tableName, options.identifierEscaping) + ".");
                    }
                    sql += escapeIdentifier(f->name(), options.identifierEscaping);
                }
                QString aliasString = QString(querySchema.columnAlias(number));
                if (!aliasString.isEmpty())
                    sql += (QString::fromLatin1(" AS ") + aliasString);
            }
            LookupFieldSchema *lookupFieldSchema = f->table() ? f->table()->lookupFieldSchema( *f ) : 0;
            if (lookupFieldSchema) {
                // Lookup field schema found
                // Now we also need to fetch "visible" value from the lookup table, not only the value of binding.
                // -> build LEFT OUTER JOIN clause for this purpose (LEFT, not INNER because the binding can be broken)
                // "LEFT OUTER JOIN lookupTable ON thisTable.thisField=lookupTable.boundField"
                LookupFieldSchema::RowSource& rowSource = lookupFieldSchema->rowSource();
                if (rowSource.type()==LookupFieldSchema::RowSource::Table) {
                    TableSchema *lookupTable = querySchema.connection()->tableSchema( rowSource.name() );
                    Field *visibleField = 0;
                    Field *boundField = 0;
                    if (lookupTable && lookupFieldSchema->boundColumn()>=0 
                        && (uint)lookupFieldSchema->boundColumn() < lookupTable->fieldCount()
                        && (visibleField = lookupTable->field( lookupFieldSchema->visibleColumn()))
                        && (boundField = lookupTable->field( lookupFieldSchema->boundColumn() )))
                    {
                        //add LEFT OUTER JOIN
                        if (!s_additional_joins.isEmpty())
                            s_additional_joins += QString::fromLatin1(" ");
                        QString internalUniqueTableAlias( QString("__kexidb_") + lookupTable->name() + "_"
                            + QString::number(internalUniqueTableAliasNumber++) );
                        s_additional_joins += QString("LEFT OUTER JOIN %1 AS %2 ON %3.%4=%5.%6")
                            .arg(escapeIdentifier(lookupTable->name(), options.identifierEscaping))
                            .arg(internalUniqueTableAlias)
                            .arg(escapeIdentifier(f->table()->name(), options.identifierEscaping))
                            .arg(escapeIdentifier(f->name(), options.identifierEscaping))
                            .arg(internalUniqueTableAlias)
                            .arg(escapeIdentifier(boundField->name(), options.identifierEscaping));

                        //add visibleField to the list of SELECTed fields //if it is not yet present there
//not needed                        if (!querySchema.findTableField( visibleField->table()->name()+"."+visibleField->name() )) {
                            if (!querySchema.table( visibleField->table()->name() )) {
/* not true
                                //table should be added after FROM
                                if (!s_from_additional.isEmpty())
                                    s_from_additional += QString::fromLatin1(", ");
                                s_from_additional += escapeIdentifier(visibleField->table()->name(), options.identifierEscaping);
                                */
                            }
                            if (!s_additional_fields.isEmpty())
                                s_additional_fields += QString::fromLatin1(", ");
                            s_additional_fields += (internalUniqueTableAlias + "." //escapeIdentifier(visibleField->table()->name(), options.identifierEscaping) + "."
                                + escapeIdentifier(visibleField->name(), options.identifierEscaping));
//not needed                        }
                    }
                }
            }
        }
    }

    //add lookup fields
    if (!s_additional_fields.isEmpty())
        sql += (QString::fromLatin1(", ") + s_additional_fields);

    if (options.alsoRetrieveROWID) { //append rowid column
        QString s;
        if (!sql.isEmpty())
            s = QString::fromLatin1(", ");
        if (querySchema.masterTable())
            s += (escapeIdentifier(querySchema.masterTable()->name())+".");
        s += m_driver->beh->ROW_ID_FIELD_NAME;
        sql += s;
    }

    sql.prepend("SELECT ");
    TableSchema::List* tables = querySchema.tables();
    if (tables && !tables->isEmpty()) {
        sql += QString::fromLatin1(" FROM ");
        QString s_from;
        TableSchema *table;
        number = 0;
        for (TableSchema::ListIterator it(*tables); (table = it.current());
            ++it, number++)
        {
            if (!s_from.isEmpty())
                s_from += QString::fromLatin1(", ");
            s_from += escapeIdentifier(table->name(), options.identifierEscaping);
            QString aliasString = QString(querySchema.tableAlias(number));
            if (!aliasString.isEmpty())
                s_from += (QString::fromLatin1(" AS ") + aliasString);
        }
/*unused    if (!s_from_additional.isEmpty()) {//additional tables list needed for lookup fields
            if (!s_from.isEmpty())
                s_from += QString::fromLatin1(", ");
            s_from += s_from_additional;
        }*/
        sql += s_from;
    }
    QString s_where;
    s_where.reserve(4096);

    //JOINS
    if (!s_additional_joins.isEmpty()) {
        sql += QString::fromLatin1(" ") + s_additional_joins + QString::fromLatin1(" ");
    }

//@todo: we're using WHERE for joins now; use INNER/LEFT/RIGHT JOIN later

    //WHERE
    Relationship *rel;
    bool wasWhere = false; //for later use
    for (Relationship::ListIterator it(*querySchema.relationships()); (rel = it.current()); ++it) {
        if (s_where.isEmpty()) {
            wasWhere = true;
        }
        else
            s_where += QString::fromLatin1(" AND ");
        Field::Pair *pair;
        QString s_where_sub;
        for (QPtrListIterator<Field::Pair> p_it(*rel->fieldPairs()); (pair = p_it.current()); ++p_it) {
            if (!s_where_sub.isEmpty())
                s_where_sub += QString::fromLatin1(" AND ");
            s_where_sub += (
                escapeIdentifier(pair->first->table()->name(), options.identifierEscaping) +
                QString::fromLatin1(".") +
                escapeIdentifier(pair->first->name(), options.identifierEscaping) +
                QString::fromLatin1(" = ")  +
                escapeIdentifier(pair->second->table()->name(), options.identifierEscaping) +
                QString::fromLatin1(".") +
                escapeIdentifier(pair->second->name(), options.identifierEscaping));
        }
        if (rel->fieldPairs()->count()>1) {
            s_where_sub.prepend("(");
            s_where_sub += QString::fromLatin1(")");
        }
        s_where += s_where_sub;
    }
    //EXPLICITLY SPECIFIED WHERE EXPRESSION
    if (querySchema.whereExpression()) {
        QuerySchemaParameterValueListIterator paramValuesIt(*m_driver, params);
        QuerySchemaParameterValueListIterator *paramValuesItPtr = params.isEmpty() ? 0 : &paramValuesIt;
        if (wasWhere) {
//TODO: () are not always needed
            s_where = "(" + s_where + ") AND (" + querySchema.whereExpression()->toString(paramValuesItPtr) + ")";
        }
        else {
            s_where = querySchema.whereExpression()->toString(paramValuesItPtr);
        }
    }
    if (!s_where.isEmpty())
        sql += QString::fromLatin1(" WHERE ") + s_where;
    //(use wasWhere here)
    
    // ORDER BY
    QString orderByString( querySchema.orderByColumnList().toSQLString(!singleTable/*includeTableName*/) );
    if (!orderByString.isEmpty())
        sql += (" ORDER BY " + orderByString);
    
    //KexiDBDbg << sql << endl;
    return sql;
}

QString Connection::selectStatement( KexiDB::TableSchema& tableSchema,
    const SelectStatementOptions& options) const
{
    return selectStatement( *tableSchema.query(), options );
}

Field* Connection::findSystemFieldName(KexiDB::FieldList* fieldlist)
{
    Field *f = fieldlist->fields()->first();
    while (f) {
        if (m_driver->isSystemFieldName( f->name() ))
            return f;
        f = fieldlist->fields()->next();
    }
    return 0;
}

Q_ULLONG Connection::lastInsertedAutoIncValue(const QString& aiFieldName, const QString& tableName,
    Q_ULLONG* ROWID)
{
    Q_ULLONG row_id = drv_lastInsertRowID();
    if (ROWID)
        *ROWID = row_id;
    if (m_driver->beh->ROW_ID_FIELD_RETURNS_LAST_AUTOINCREMENTED_VALUE) {
        return row_id;
    }
    RowData rdata;
    if (row_id<=0 || true!=querySingleRecord(
        QString::fromLatin1("SELECT ") + tableName + QString::fromLatin1(".") + aiFieldName + QString::fromLatin1(" FROM ") + tableName
        + QString::fromLatin1(" WHERE ") + m_driver->beh->ROW_ID_FIELD_NAME + QString::fromLatin1("=") + QString::number(row_id), rdata))
    {
//      KexiDBDbg << "Connection::lastInsertedAutoIncValue(): row_id<=0 || true!=querySingleRecord()" << endl;
        return (Q_ULLONG)-1; //ULL;
    }
    return rdata[0].toULongLong();
}

Q_ULLONG Connection::lastInsertedAutoIncValue(const QString& aiFieldName,
    const KexiDB::TableSchema& table, Q_ULLONG* ROWID)
{
    return lastInsertedAutoIncValue(aiFieldName,table.name(), ROWID);
}

static FieldList* createFieldListForKexi__Fields(TableSchema *kexi__fieldsSchema)
{
    if (!kexi__fieldsSchema)
        return 0;
    return kexi__fieldsSchema->subList(
        "t_id",
        "f_type",
        "f_name",
        "f_length",
        "f_precision",
        "f_constraints",
        "f_options",
        "f_default",
        "f_order",
        "f_caption",
        "f_help"
    );
}

void buildValuesForKexi__Fields(QValueList<QVariant>& vals, Field* f)
{
    vals.clear();
    vals
    << QVariant(f->table()->id())
    << QVariant(f->type())
    << QVariant(f->name())
    << QVariant(f->isFPNumericType() ? f->scale() : f->length())
    << QVariant(f->isFPNumericType() ? f->precision() : 0)
    << QVariant(f->constraints())
    << QVariant(f->options())
        // KexiDB::variantToString() is needed here because the value can be of any QVariant type, 
        // depending on f->type()
    << (f->defaultValue().isNull() 
            ? QVariant() : QVariant(KexiDB::variantToString( f->defaultValue() ))) 
    << QVariant(f->order())
    << QVariant(f->caption())
    << QVariant(f->description());
}

bool Connection::storeMainFieldSchema(Field *field)
{
    if (!field || !field->table())
        return false;
    FieldList *fl = createFieldListForKexi__Fields(d->tables_byname["kexi__fields"]);
    if (!fl)
        return false;

    QValueList<QVariant> vals;
    buildValuesForKexi__Fields(vals, field);
    QValueList<QVariant>::ConstIterator valsIt = vals.constBegin();
    Field *f;
    bool first = true;
    QString sql = "UPDATE kexi__fields SET ";
    for (Field::ListIterator it( fl->fieldsIterator() ); (f = it.current()); ++it, ++valsIt) {
        sql.append( (first ? QString::null : QString(", ")) +
            f->name() + "=" + m_driver->valueToSQL( f, *valsIt ) );
        if (first)
            first = false;
    }
    delete fl;
    
    sql.append(QString(" WHERE t_id=") + QString::number( field->table()->id() )
        + " AND f_name=" + m_driver->valueToSQL( Field::Text, field->name() ) );
    return executeSQL( sql );
}

#define createTable_ERR \
    { KexiDBDbg << "Connection::createTable(): ERROR!" <<endl; \
      setError(this, i18n("Creating table failed.")); \
      rollbackAutoCommitTransaction(tg.transaction()); \
      return false; }
        //setError( errorNum(), i18n("Creating table failed.") + " " + errorMsg()); 


bool Connection::createTable( KexiDB::TableSchema* tableSchema, bool replaceExisting )
{
    if (!tableSchema || !checkIsDatabaseUsed())
        return false;

    //check if there are any fields
    if (tableSchema->fieldCount()<1) {
        clearError();
        setError(ERR_CANNOT_CREATE_EMPTY_OBJECT, i18n("Cannot create table without fields."));
        return false;
    }
    const bool internalTable = dynamic_cast<InternalTableSchema*>(tableSchema);

    const QString &tableName = tableSchema->name().lower();

    if (!internalTable) {
        if (m_driver->isSystemObjectName( tableName )) {
            clearError();
            setError(ERR_SYSTEM_NAME_RESERVED, i18n("System name \"%1\" cannot be used as table name.")
                .arg(tableSchema->name()));
            return false;
        }

        Field *sys_field = findSystemFieldName(tableSchema);
        if (sys_field) {
            clearError();
            setError(ERR_SYSTEM_NAME_RESERVED,
                i18n("System name \"%1\" cannot be used as one of fields in \"%2\" table.")
                .arg(sys_field->name()).arg(tableName));
            return false;
        }
    }

    bool previousSchemaStillKept = false;

    KexiDB::TableSchema *existingTable = 0;
    if (replaceExisting) {
        //get previous table (do not retrieve, though)
        existingTable = d->tables_byname[tableName];
        if (existingTable) {
            if (existingTable == tableSchema) {
                clearError();
                setError(ERR_OBJECT_EXISTS, 
                    i18n("Could not create the same table \"%1\" twice.").arg(tableSchema->name()) );
                return false;
            }
//TODO(js): update any structure (e.g. queries) that depend on this table!
            if (existingTable->id()>0)
                tableSchema->m_id = existingTable->id(); //copy id from existing table
            previousSchemaStillKept = true;
            if (!dropTable( existingTable, false /*alsoRemoveSchema*/ ))
                return false