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

queryschema.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 library 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 library 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 library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#include "kexidb/queryschema.h"
#include "kexidb/driver.h"
#include "kexidb/connection.h"
#include "kexidb/expression.h"
#include "kexidb/parser/sqlparser.h"
#include "utils.h"
#include "lookupfieldschema.h"

#include <assert.h>

#include <qvaluelist.h>
#include <qasciidict.h>
#include <qptrdict.h>
#include <qintdict.h>
#include <qbitarray.h>

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

using namespace KexiDB;

QueryColumnInfo::QueryColumnInfo(Field *f, const QCString& _alias, bool _visible, 
    QueryColumnInfo *foreignColumn)
 : field(f), alias(_alias), visible(_visible), m_indexForVisibleLookupValue(-1)
 , m_foreignColumn(foreignColumn)
{
}

QueryColumnInfo::~QueryColumnInfo()
{
}

QString QueryColumnInfo::debugString() const
{
    return field->name() + 
        ( alias.isEmpty() ? QString::null 
            : (QString::fromLatin1(" AS ") + QString(alias)) );
}

//=======================================
namespace KexiDB {
class QuerySchemaPrivate
{
    public:
        QuerySchemaPrivate(QuerySchema* q)
         : query(q)
         , masterTable(0)
         , fakeRowIDField(0)
         , fakeRowIDCol(0)
         , maxIndexWithAlias(-1)
         , visibility(64)
         , fieldsExpanded(0)
         , internalFields(0)
         , fieldsExpandedWithInternalAndRowID(0)
         , fieldsExpandedWithInternal(0)
         , autoincFields(0)
         , columnsOrder(0)
         , columnsOrderWithoutAsterisks(0)
         , columnsOrderExpanded(0)
         , pkeyFieldsOrder(0)
         , pkeyFieldsCount(0)
         , tablesBoundToColumns(64, -1)
         , tablePositionsForAliases(67, false)
         , columnPositionsForAliases(67, false)
         , whereExpr(0)
         , regenerateExprAliases(false)
        {
            columnAliases.setAutoDelete(true);
            tableAliases.setAutoDelete(true);
            asterisks.setAutoDelete(true);
            relations.setAutoDelete(true);
            tablePositionsForAliases.setAutoDelete(true);
            columnPositionsForAliases.setAutoDelete(true);
            visibility.fill(false);
        }
        ~QuerySchemaPrivate()
        {
            delete fieldsExpanded;
            delete internalFields;
            delete fieldsExpandedWithInternalAndRowID;
            delete fieldsExpandedWithInternal;
            delete autoincFields;
            delete columnsOrder;
            delete columnsOrderWithoutAsterisks;
            delete columnsOrderExpanded;
            delete pkeyFieldsOrder;
            delete whereExpr;
            delete fakeRowIDCol;
            delete fakeRowIDField;
        }

        void clear()
        {
            columnAliases.clear();
            tableAliases.clear();
            asterisks.clear();
            relations.clear();
            masterTable = 0;
            tables.clear();
            clearCachedData();
            delete pkeyFieldsOrder;
            pkeyFieldsOrder=0;
            visibility.fill(false);
            tablesBoundToColumns = QValueVector<int>(64,-1);
            tablePositionsForAliases.clear();
            columnPositionsForAliases.clear();
        }

        void clearCachedData()
        {
            orderByColumnList.clear();
            if (fieldsExpanded) {
                delete fieldsExpanded;
                fieldsExpanded = 0;
                delete internalFields;
                internalFields = 0;
                delete columnsOrder;
                columnsOrder = 0;
                delete columnsOrderWithoutAsterisks;
                columnsOrderWithoutAsterisks = 0;
                delete columnsOrderExpanded;
                columnsOrderExpanded = 0;
                delete autoincFields;
                autoincFields = 0;
                autoIncrementSQLFieldsList = QString::null;
                columnInfosByNameExpanded.clear();
                columnInfosByName.clear();
            }
        }

        void setColumnAliasInternal(uint position, const QCString& alias)
        {
            columnAliases.replace(position, new QCString(alias));
            columnPositionsForAliases.replace(alias, new int(position));
            maxIndexWithAlias = QMAX( maxIndexWithAlias, (int)position );
        }

        void setColumnAlias(uint position, const QCString& alias)
        {
            QCString *oldAlias = columnAliases.take(position);
            if (oldAlias) {
                tablePositionsForAliases.remove(*oldAlias);
                delete oldAlias;
            }
            if (alias.isEmpty()) {
                maxIndexWithAlias = -1;
            }
            else {
                setColumnAliasInternal(position, alias);
            }
        }

        bool hasColumnAliases()
        {
            tryRegenerateExprAliases();
            return !columnAliases.isEmpty();
        }

        QCString* columnAlias(uint position)
        {
            tryRegenerateExprAliases();
            return columnAliases[position];
        }

        QuerySchema *query;

        TableSchema *masterTable;
        
        TableSchema::List tables;

        Field *fakeRowIDField; 
        QueryColumnInfo *fakeRowIDCol; 

    protected:
        void tryRegenerateExprAliases()
        {
            if (!regenerateExprAliases)
                return;
            //regenerate missing aliases for experessions
            Field *f;
            uint p=0;
            uint colNum=0; //used to generate a name
            QCString columnAlias;
            for (Field::ListIterator it(query->fieldsIterator()); (f = it.current()); ++it, p++) {
                if (f->isExpression() && !columnAliases[p]) {
                    //missing
                    for (;;) { //find 1st unused
                        colNum++;
                        columnAlias = (i18n("short for 'expression' word (only latin letters, please)", "expr") 
                            + QString::number(colNum)).latin1();
                        if (!tablePositionsForAliases[columnAlias])
                            break;
                    }
                    setColumnAliasInternal(p, columnAlias);
                }
            }
            regenerateExprAliases = false;
        }

        QIntDict<QCString> columnAliases;

    public:
        QIntDict<QCString> tableAliases;
        
        int maxIndexWithAlias;

        int maxIndexWithTableAlias;
        
        QBitArray visibility;

        Field::List asterisks;

//      Field::Vector *fieldsExpanded;
        QueryColumnInfo::Vector *fieldsExpanded;

        QueryColumnInfo::Vector *internalFields;

        QueryColumnInfo::Vector *fieldsExpandedWithInternalAndRowID;

        QueryColumnInfo::Vector *fieldsExpandedWithInternal;

        OrderByColumnList orderByColumnList;

        QueryColumnInfo::List *autoincFields;
        
        QString autoIncrementSQLFieldsList;
        QGuardedPtr<Driver> lastUsedDriverForAutoIncrementSQLFieldsList;

        QMap<QueryColumnInfo*,int> *columnsOrder;

        QMap<QueryColumnInfo*,int> *columnsOrderWithoutAsterisks;

        QMap<QueryColumnInfo*,int> *columnsOrderExpanded;

//      QValueList<bool> detailedVisibility;

        QValueVector<int> *pkeyFieldsOrder;

        uint pkeyFieldsCount;

        QString statement;

        Relationship::List relations;

        QValueVector<int> tablesBoundToColumns;
        
        QAsciiDict<int> tablePositionsForAliases;

        QAsciiDict<int> columnPositionsForAliases;

        BaseExpr *whereExpr;

        QDict<QueryColumnInfo> columnInfosByNameExpanded;

        QDict<QueryColumnInfo> columnInfosByName; 

        bool regenerateExprAliases : 1;
};
}

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

OrderByColumn::OrderByColumn()
 : m_column(0)
 , m_pos(-1)
 , m_field(0)
 , m_ascending(true)
{
}

OrderByColumn::OrderByColumn(QueryColumnInfo& column, bool ascending, int pos)
 : m_column(&column)
 , m_pos(pos)
 , m_field(0)
 , m_ascending(ascending)
{
}

OrderByColumn::OrderByColumn(Field& field, bool ascending)
 : m_column(0)
 , m_pos(-1)
 , m_field(&field)
 , m_ascending(ascending)
{
}

OrderByColumn::~OrderByColumn()
{
}

QString OrderByColumn::debugString() const
{
    QString orderString( m_ascending ? "ascending" : "descending" );
    if (m_column) {
        if (m_pos>-1)
            return QString("COLUMN_AT_POSITION_%1(%2, %3)")
                .arg(m_pos+1).arg(m_column->debugString()).arg(orderString);
        else
            return QString("COLUMN(%1, %2)").arg(m_column->debugString()).arg(orderString);
    }
    return m_field ? QString("FIELD(%1, %2)").arg(m_field->debugString()).arg(orderString)
     : QString("NONE");
}

QString OrderByColumn::toSQLString(bool includeTableName) const
{
    QString orderString( m_ascending ? "" : " DESC" );
    if (m_column) {
        if (m_pos>-1)
            return QString::number(m_pos+1) + orderString;
        else
            return ((includeTableName && m_column->alias.isEmpty()) 
                ? m_column->field->table()->name()+"." : QString::null)
                + QString(m_column->aliasOrName()) + orderString;
    }
    else {
        return 
            (includeTableName ? m_field->table()->name()+"." : QString::null)
            + (m_field ? m_field->name() : "??"/*error*/)  + orderString;
    }
}

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

OrderByColumnList::OrderByColumnList()
 : OrderByColumnListBase()
{
}

bool OrderByColumnList::appendFields(QuerySchema& querySchema,
    const QString& field1, bool ascending1, 
    const QString& field2, bool ascending2, 
    const QString& field3, bool ascending3, 
    const QString& field4, bool ascending4, 
    const QString& field5, bool ascending5)
{
    uint numAdded = 0;
#define ADD_COL(fieldName, ascending) \
    if (ok && !fieldName.isEmpty()) { \
        if (!appendField( querySchema, fieldName, ascending )) \
            ok = false; \
        else \
            numAdded++; \
    }
    bool ok = true;
    ADD_COL(field1, ascending1);
    ADD_COL(field2, ascending2);
    ADD_COL(field3, ascending3);
    ADD_COL(field4, ascending4);
    ADD_COL(field5, ascending5);
#undef ADD_COL
    if (ok)
        return true;
    for (uint i=0; i<numAdded; i++)
        pop_back();
    return false;
}

OrderByColumnList::~OrderByColumnList()
{
}

void OrderByColumnList::appendColumn(QueryColumnInfo& columnInfo, bool ascending)
{
    appendColumn( OrderByColumn(columnInfo, ascending) );
}

bool OrderByColumnList::appendColumn(QuerySchema& querySchema, bool ascending, int pos)
{
    QueryColumnInfo::Vector fieldsExpanded( querySchema.fieldsExpanded() );
    QueryColumnInfo* ci = (pos >= (int)fieldsExpanded.size()) ? 0 : fieldsExpanded[pos];
    if (!ci)
        return false;
    appendColumn( OrderByColumn(*ci, ascending, pos) );
    return true;
}

void OrderByColumnList::appendField(Field& field, bool ascending)
{
    appendColumn( OrderByColumn(field, ascending) );
}

bool OrderByColumnList::appendField(QuerySchema& querySchema, 
    const QString& fieldName, bool ascending)
{
    QueryColumnInfo *columnInfo = querySchema.columnInfo( fieldName );
    if (columnInfo) {
        appendColumn( OrderByColumn(*columnInfo, ascending) );
        return true;
    }
    Field *field = querySchema.findTableField(fieldName);
    if (field) {
        appendColumn( OrderByColumn(*field, ascending) );
        return true;
    }
    KexiDBWarn << "OrderByColumnList::addColumn(QuerySchema& querySchema, "
        "const QString& column, bool ascending): no such field \"" << fieldName << "\"" << endl;
    return false;
}
        
void OrderByColumnList::appendColumn(const OrderByColumn& column)
{
    append( column );
}

QString OrderByColumnList::debugString() const
{
    if (isEmpty())
        return "NONE";
    QString dbg;
    for (OrderByColumn::ListConstIterator it=constBegin(); it!=constEnd(); ++it) {
        if (!dbg.isEmpty())
            dbg += "\n";
        dbg += (*it).debugString();
    }
    return dbg;
}

QString OrderByColumnList::toSQLString(bool includeTableNames) const
{
    QString string;
    for (OrderByColumn::ListConstIterator it=constBegin(); it!=constEnd(); ++it) {
        if (!string.isEmpty())
            string += ", ";
        string += (*it).toSQLString(includeTableNames);
    }
    return string;
}

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

QuerySchema::QuerySchema()
    : FieldList(false)//fields are not owned by QuerySchema object
    , SchemaData(KexiDB::QueryObjectType)
    , d( new QuerySchemaPrivate(this) )
{
    init();
}

QuerySchema::QuerySchema(TableSchema* tableSchema)
    : FieldList(false)
    , SchemaData(KexiDB::QueryObjectType)
    , d( new QuerySchemaPrivate(this) )
{
    d->masterTable = tableSchema;
//  assert(d->masterTable);
    init();
    if (!d->masterTable) {
        KexiDBWarn << "QuerySchema(TableSchema*): !d->masterTable" << endl;
        m_name = QString::null;
        return;
    }
    addTable(d->masterTable);
    //defaults:
    //inherit name from a table
    m_name = d->masterTable->name();
    //inherit caption from a table
    m_caption = d->masterTable->caption();
    
//replaced by explicit field list: //add all fields of the table as asterisk:
//replaced by explicit field list:  addField( new QueryAsterisk(this) );

    // add explicit field list to avoid problems (e.g. with fields added outside of Kexi):
    for (Field::ListIterator it( d->masterTable->fieldsIterator() ); it.current(); ++it) {
        addField( it.current() );
    }
}

QuerySchema::~QuerySchema()
{
    delete d;
}

void QuerySchema::init()
{
    m_type = KexiDB::QueryObjectType;
//m_fields_by_name.setAutoDelete( true ); //because we're using QueryColumnInfoEntry objects
}

void QuerySchema::clear()
{
    FieldList::clear();
    SchemaData::clear();
    d->clear();
}

FieldList& QuerySchema::insertField(uint position, Field *field, bool visible)
{
    return insertField(position, field, -1/*don't bind*/, visible);
}

/*virtual*/
FieldList& QuerySchema::insertField(uint position, Field *field)
{
    return insertField( position, field, -1/*don't bind*/, true );
}

FieldList& QuerySchema::insertField(uint position, Field *field, 
    int bindToTable, bool visible)
{
    if (!field) {
        KexiDBWarn << "QuerySchema::insertField(): !field" << endl;
        return *this;
    }

    if (position>m_fields.count()) {
        KexiDBWarn << "QuerySchema::insertField(): position (" << position << ") out of range" << endl;
        return *this;
    }
    if (!field->isQueryAsterisk() && !field->isExpression() && !field->table()) {
        KexiDBWarn << "QuerySchema::insertField(): WARNING: field '"<<field->name()
            <<"' must contain table information!" <<endl;
        return *this;
    }
    if (fieldCount()>=d->visibility.size()) {
        d->visibility.resize(d->visibility.size()*2);
        d->tablesBoundToColumns.resize(d->tablesBoundToColumns.size()*2);
    }
    d->clearCachedData();
    FieldList::insertField(position, field);
    if (field->isQueryAsterisk()) {
        d->asterisks.append(field);
        //if this is single-table asterisk,
        //add a table to list if doesn't exist there:
        if (field->table() && (d->tables.findRef(field->table())==-1))
            d->tables.append(field->table());
    }
    else if (field->table()) {
        //add a table to list if doesn't exist there:
        if (d->tables.findRef(field->table())==-1)
            d->tables.append(field->table());
    }
//  //visible by default
//  setFieldVisible(field, true);
//  d->visibility.setBit(fieldCount()-1, visible);
    //update visibility
    //--move bits to make a place for a new one
    for (uint i=fieldCount()-1; i>position; i--)
        d->visibility.setBit(i, d->visibility.testBit(i-1));
    d->visibility.setBit(position, visible);

    //bind to table
    if (bindToTable < -1 && bindToTable>(int)d->tables.count()) {
        KexiDBWarn << "QuerySchema::insertField(): bindToTable (" << bindToTable 
            << ") out of range" << endl;
        bindToTable = -1;
    }
    //--move items to make a place for a new one
    for (uint i=fieldCount()-1; i>position; i--)
        d->tablesBoundToColumns[i] = d->tablesBoundToColumns[i-1];
    d->tablesBoundToColumns[ position ] = bindToTable;
    
    KexiDBDbg << "QuerySchema::insertField(): bound to table (" << bindToTable << "): " <<endl;
    if (bindToTable==-1)
        KexiDBDbg << " <NOT SPECIFIED>" << endl; 
    else
        KexiDBDbg << " name=" << d->tables.at(bindToTable)->name() 
            << " alias=" << tableAlias(bindToTable) <<  endl;
    QString s;
    for (uint i=0; i<fieldCount();i++)
        s+= (QString::number(d->tablesBoundToColumns[i]) + " ");
    KexiDBDbg << "tablesBoundToColumns == [" << s << "]" <<endl;

    if (field->isExpression())
        d->regenerateExprAliases = true;

    return *this;
}

int QuerySchema::tableBoundToColumn(uint columnPosition) const
{
    if (columnPosition > d->tablesBoundToColumns.count()) {
        KexiDBWarn << "QuerySchema::tableBoundToColumn(): columnPosition (" << columnPosition
            << ") out of range" << endl;
        return -1;
    }
    return d->tablesBoundToColumns[columnPosition];
}

KexiDB::FieldList& QuerySchema::addField(KexiDB::Field* field, bool visible)
{
    return insertField(m_fields.count(), field, visible);
}

KexiDB::FieldList& QuerySchema::addField(KexiDB::Field* field, int bindToTable, 
    bool visible)
{
    return insertField(m_fields.count(), field, bindToTable, visible);
}

void QuerySchema::removeField(KexiDB::Field *field)
{
    if (!field)
        return;
    d->clearCachedData();
    if (field->isQueryAsterisk()) {
        d->asterisks.remove(field); //this will destroy this asterisk
    }
//TODO: should we also remove table for this field or asterisk?
    FieldList::removeField(field);
}

FieldList& QuerySchema::addExpression(BaseExpr* expr, bool visible)
{
    return addField( new Field(this, expr), visible );
}

bool QuerySchema::isColumnVisible(uint position) const
{
    return (position < fieldCount()) ? d->visibility.testBit(position) : false;
}

void QuerySchema::setColumnVisible(uint position, bool v)
{
    if (position < fieldCount())
        d->visibility.setBit(position, v);
}

FieldList& QuerySchema::addAsterisk(QueryAsterisk *asterisk, bool visible)
{
    if (!asterisk)
        return *this;
    //make unique name
    asterisk->m_name = (asterisk->table() ? asterisk->table()->name() + ".*" : "*") 
        + QString::number(asterisks()->count());
    return addField(asterisk, visible);
}

Connection* QuerySchema::connection() const
{
    TableSchema *mt = masterTable();
    return mt ? mt->connection() : 0;
}

QString QuerySchema::debugString()
{
    QString dbg;
    dbg.reserve(1024);
    //fields
    TableSchema *mt = masterTable();
    dbg = QString("QUERY ") + schemaDataDebugString() + "\n"
        + "-masterTable=" + (mt ? mt->name() :"<NULL>")
        + "\n-COLUMNS:\n"
        + ((fieldCount()>0) ? FieldList::debugString() : "<NONE>") + "\n"
        + "-FIELDS EXPANDED ";

    QString dbg1;
    uint fieldsExpandedCount = 0;
    if (fieldCount()>0) {
        QueryColumnInfo::Vector fe( fieldsExpanded() );
        fieldsExpandedCount = fe.size();
        for ( uint i=0; i < fieldsExpandedCount; i++ ) {
            QueryColumnInfo *ci = fe[i];
            if (!dbg1.isEmpty())
                dbg1 += ",\n";
            dbg1 += ci->debugString();
        }
        dbg1 += "\n";
    }
    else {
        dbg1 = "<NONE>\n";
    }
    dbg1.prepend( QString("(%1):\n").arg(fieldsExpandedCount) );
    dbg += dbg1;

    //it's safer to delete fieldsExpanded for now 
    // (debugString() could be called before all fields are added)
//causes a crash    d->clearCachedData();

    //bindings
    QString dbg2;
    dbg2.reserve(512);
    for (uint i = 0; i<fieldCount(); i++) {
        int tablePos = tableBoundToColumn(i);
        if (tablePos>=0) {
            QCString tAlias = tableAlias(tablePos);
            if (!tAlias.isEmpty()) {
                dbg2 += (QString::fromLatin1(" field \"") + FieldList::field(i)->name() 
                    + "\" uses alias \"" + QString(tAlias) + "\" of table \""
                    + d->tables.at(tablePos)->name() + "\"\n");
            }
        }
    }
    if (!dbg2.isEmpty()) {
        dbg += "\n-BINDINGS:\n";
        dbg += dbg2;
    }
    
    //tables    
    TableSchema *table;
    QString table_names;
    table_names.reserve(512);
    for ( table = d->tables.first(); table; table = d->tables.next() ) {
        if (!table_names.isEmpty())
            table_names += ", ";
        table_names += (QString("'") + table->name() + "'");
    }
    if (d->tables.isEmpty())
        table_names = "<NONE>";
    dbg += (QString("-TABLES:\n") + table_names);
    QString aliases;
    if (!d->hasColumnAliases())
        aliases = "<NONE>\n";
    else {
        Field::ListIterator it( m_fields );
        for (int i=0; it.current(); ++it, i++) {
            QCString *alias = d->columnAlias(i);
            if (alias)
                aliases += (QString("field #%1: ").arg(i) 
                    + (it.current()->name().isEmpty() ? "<noname>" : it.current()->name())
                    + " -> " + (const char*)*alias + "\n");
        }
    }
    //aliases
    dbg += QString("\n-COLUMN ALIASES:\n" + aliases);
    if (d->tableAliases.isEmpty())
        aliases = "<NONE>";
    else {
        aliases = "";
        TableSchema::ListIterator t_it(d->tables);
        for (int i=0; t_it.current(); ++t_it, i++) {
            QCString *alias = d->tableAliases[i];
            if (alias)
                aliases += (QString("table #%1: ").arg(i) 
                    + (t_it.current()->name().isEmpty() ? "<noname>" : t_it.current()->name())
                    + " -> " + (const char*)*alias + "\n");
        }
    }
    dbg += QString("-TABLE ALIASES:\n" + aliases);
    QString where = d->whereExpr ? d->whereExpr->debugString() : QString::null;
    if (!where.isEmpty())
        dbg += (QString("\n-WHERE EXPRESSION:\n") + where);
    if (!orderByColumnList().isEmpty())
        dbg += (QString("\n-ORDER BY (%1):\n").arg(orderByColumnList().count()) 
            + orderByColumnList().debugString());
    return dbg;
}

TableSchema* QuerySchema::masterTable() const
{
    if (d->masterTable)
        return d->masterTable;
    if (d->tables.isEmpty())
        return 0;

    //try to find master table if there's only one table (with possible aliasses)
    int num = 0;
    QString tableNameLower;
    for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
        if (!tableNameLower.isEmpty() && it.current()->name().lower()!=tableNameLower) {
            //two or more different tables
            return 0;
        }
        tableNameLower = tableAlias(num);
    }
    return d->tables.first();
}

void QuerySchema::setMasterTable(TableSchema *table)
{ 
    if (table)
        d->masterTable=table; 
}

TableSchema::List* QuerySchema::tables() const
{
    return &d->tables;
}

void QuerySchema::addTable(TableSchema *table, const QCString& alias)
{
    KexiDBDbg << "QuerySchema::addTable() " << (void *)table 
        << " alias=" << alias << endl;
    if (!table)
        return;
    
    //only append table if:
    //-it has alias
    //-it has no alias but there is no such table on the list
    if (alias.isEmpty() && d->tables.findRef(table)!=-1) {
        const QString& tableNameLower = table->name().lower();
        const QString& aliasLower = QString(alias.lower());
        int num = 0;
        for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
            if (it.current()->name().lower()==tableNameLower) {
                const QString& tAlias = tableAlias(num);
                if (tAlias == aliasLower) {
                    KexiDBWarn << "QuerySchema::addTable(): table with \"" 
                        << tAlias << "\" alias already added!" << endl;
                    return;
                }
            }
        }
    }
    
    d->tables.append(table);
    
    if (!alias.isEmpty())
        setTableAlias(d->tables.count()-1, alias);
}

void QuerySchema::removeTable(TableSchema *table)
{
    if (!table)
        return;
    if (d->masterTable == table)
        d->masterTable = 0;
    d->tables.remove(table);
    //todo: remove fields!
}

TableSchema* QuerySchema::table(const QString& tableName) const
{
//TODO: maybe use tables_byname?
    for (TableSchema::ListIterator it(d->tables); it.current(); ++it) {
        if (it.current()->name().lower()==tableName.lower())
            return it.current();
    }
    return 0;
}

bool QuerySchema::contains(TableSchema *table) const
{
    return d->tables.findRef(table)!=-1;
}

Field* QuerySchema::findTableField(const QString &tableOrTableAndFieldName) const
{
    QString tableName, fieldName;
    if (!KexiDB::splitToTableAndFieldParts(tableOrTableAndFieldName, 
        tableName, fieldName, KexiDB::SetFieldNameIfNoTableName)) {
        return 0;
    }
    if (tableName.isEmpty()) {
        for (TableSchema::ListIterator it(d->tables); it.current(); ++it) {
            if (it.current()->field(fieldName))
                return it.current()->field(fieldName);
        }
        return 0;
    }
    TableSchema *tableSchema = table(tableName);
    if (!tableSchema)
        return 0;
    return tableSchema->field(fieldName);
}

QCString QuerySchema::columnAlias(uint position) const
{
    QCString *a = d->columnAlias(position);
    return a ? *a : QCString();
}

bool QuerySchema::hasColumnAlias(uint position) const
{
    return d->columnAlias(position)!=0;
}

void QuerySchema::setColumnAlias(uint position, const QCString& alias)
{
    if (position >= m_fields.count()) {
        KexiDBWarn << "QuerySchema::setColumnAlias(): position ("  << position 
            << ") out of range!" << endl;
        return;
    }
    QCString fixedAlias = alias.stripWhiteSpace();
    Field *f = FieldList::field(position);
    if (f->captionOrName().isEmpty() && fixedAlias.isEmpty()) {
        KexiDBWarn << "QuerySchema::setColumnAlias(): position ("  << position 
            << ") could not remove alias when no name is specified for expression column!" << endl;
        return;
    }
    d->setColumnAlias(position, fixedAlias);
}

QCString QuerySchema::tableAlias(uint position) const
{
    QCString *a = d->tableAliases[position];
    return a ? *a : QCString();
}

int QuerySchema::tablePositionForAlias(const QCString& name) const
{
    int *num = d->tablePositionsForAliases[name];
    if (!num)
        return -1;
    return *num;
}

int QuerySchema::tablePosition(const QString& tableName) const
{
    int num = 0;
    for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
        if (it.current()->name().lower()==tableName.lower())
            return num;
    }
    return -1;
}

QValueList<int> QuerySchema::tablePositions(const QString& tableName) const
{
    int num = 0;
    QValueList<int> result;
    const QString& tableNameLower = tableName.lower();
    for (TableSchema::ListIterator it(d->tables); it.current(); ++it, num++) {
        if (it.current()->name().lower()==tableNameLower) {
            result += num;
        }
    }
    return result;
}

bool QuerySchema::hasTableAlias(uint position) const
{
    return d->tableAliases[position]!=0;
}

int QuerySchema::columnPositionForAlias(const QCString& name) const
{
    int *num = d->columnPositionsForAliases[name];
    if (!num)
        return -1;
    return *num;
}

void QuerySchema::setTableAlias(uint position, const QCString& alias)
{
    if (position >= d->tables.count()) {
        KexiDBWarn << "QuerySchema::setTableAlias(): position ("  << position 
            << ") out of range!" << endl;
        return;
    }
    QCString fixedAlias = alias.stripWhiteSpace();
    if (fixedAlias.isEmpty()) {
        QCString *oldAlias = d->tableAliases.take(position);
        if (oldAlias) {
            d->tablePositionsForAliases.remove(*oldAlias);
            delete oldAlias;
        }
//          d->maxIndexWithTableAlias = -1;
    }
    else {
        d->tableAliases.replace(position, new QCString(fixedAlias));
        d->tablePositionsForAliases.replace(fixedAlias, new int(position));
//      d->maxIndexWithTableAlias = QMAX( d->maxIndexWithTableAlias, (int)index );
    }
}

Relationship::List* QuerySchema::relationships() const
{
    return &d->relations;
}

Field::List* QuerySchema::asterisks() const
{
    return &d->asterisks;
}
        
QString QuerySchema::statement() const
{
    return d->statement;
}

void QuerySchema::setStatement(const QString &s)
{
    d->statement = s;
}

Field* QuerySchema::field(const QString& identifier, bool expanded)
{
    QueryColumnInfo *ci = columnInfo(identifier, expanded);
    return ci ? ci->field : 0;
}

QueryColumnInfo* QuerySchema::columnInfo(const QString& identifier, bool expanded)
{
    computeFieldsExpanded();
    return expanded ? d->columnInfosByNameExpanded[identifier] : d->columnInfosByName[identifier];
}

QueryColumnInfo::Vector QuerySchema::fieldsExpanded(FieldsExpandedOptions options)
{
    computeFieldsExpanded();
    if (options == WithInternalFields || options == WithInternalFieldsAndRowID) {
        //a ref to a proper pointer (as we cache the vector for two cases)
        QueryColumnInfo::Vector*& tmpFieldsExpandedWithInternal = 
            (options == WithInternalFields) ? d->fieldsExpandedWithInternal : d->fieldsExpandedWithInternalAndRowID;
        //special case
        if (!tmpFieldsExpandedWithInternal) {
            //glue expanded and internal fields and cache it
            const uint size = d->fieldsExpanded->count()
                + (d->internalFields ? d->internalFields->count() : 0)
                + ((options == WithInternalFieldsAndRowID) ? 1 : 0) /*ROWID*/;
            tmpFieldsExpandedWithInternal = new QueryColumnInfo::Vector( size );
            const uint fieldsExpandedVectorSize = d->fieldsExpanded->size();
            for (uint i=0; i<fieldsExpandedVectorSize; i++)
                tmpFieldsExpandedWithInternal->insert(i, d->fieldsExpanded->at(i));
            const uint internalFieldsCount = d->internalFields ? d->internalFields->size() : 0;
            if (internalFieldsCount > 0) {
                for (uint i=0; i < internalFieldsCount; i++)
                    tmpFieldsExpandedWithInternal->insert(
                        fieldsExpandedVectorSize + i, d->internalFields->at(i));
            }
            if (options == WithInternalFieldsAndRowID) {
                if (!d->fakeRowIDField) {
                    d->fakeRowIDField = new Field("rowID", Field::BigInteger);
                    d->fakeRowIDCol = new QueryColumnInfo(d->fakeRowIDField, QCString(), true);
                }
                tmpFieldsExpandedWithInternal->insert( 
                    fieldsExpandedVectorSize + internalFieldsCount, d->fakeRowIDCol );
            }
        }
        return *tmpFieldsExpandedWithInternal;
    }

    if (options == Default)
        return *d->fieldsExpanded;

    //options == Unique:
    QDict<char> columnsAlreadyFound;
    QueryColumnInfo::Vector result( d->fieldsExpanded->count() ); //initial size is set
//  QMapConstIterator<QueryColumnInfo*, bool> columnsAlreadyFoundIt;
    //compute unique list
    uint uniqueListCount = 0;
    for (uint i=0; i<d->fieldsExpanded->count(); i++) {
        QueryColumnInfo *ci = (*d->fieldsExpanded)[i];
//      columnsAlreadyFoundIt = columnsAlreadyFound.find(ci);
//      uint foundColumnIndex = -1;
        if (!columnsAlreadyFound[ci->aliasOrName()]) {// columnsAlreadyFoundIt==columnsAlreadyFound.constEnd())
            columnsAlreadyFound.insert(ci->aliasOrName(), (char*)1);
            result.insert(uniqueListCount++, ci);
        }
    }
    result.resize(uniqueListCount); //update result size
    return result;
}

QueryColumnInfo::Vector QuerySchema::internalFields()
{
    computeFieldsExpanded();
    return d->internalFields ? *d->internalFields : QueryColumnInfo::Vector();
}

QueryColumnInfo* QuerySchema::expandedOrInternalField(uint index)
{
    QueryColumnInfo::Vector vector = fieldsExpanded(WithInternalFields);
    return (index < vector.size()) ? vector[index] : 0;
}

void QuerySchema::computeFieldsExpanded()
{
    if (d->fieldsExpanded)
        return;

    if (!d->columnsOrder) {
        d->columnsOrder = new QMap<QueryColumnInfo*,int>();
        d->columnsOrderWithoutAsterisks = new QMap<QueryColumnInfo*,int>();
    }
    else {
        d->columnsOrder->clear();
        d->columnsOrderWithoutAsterisks->clear();
    }

    //collect all fields in a list (not a vector yet, because we do not know its size)
    QueryColumnInfo::List list; //temporary
    QueryColumnInfo::List lookup_list; //temporary, for collecting additional fields related to lookup fields
    QMap<QueryColumnInfo*, bool> columnInfosOutsideAsterisks; //helper for filling d->columnInfosByName
    uint i = 0;
    uint fieldPosition = 0;
    Field *f;
    for (Field::ListIterator it = fieldsIterator(); (f = it.current()); ++it, fieldPosition++) {
        if (f->isQueryAsterisk()) {
            if (static_cast<QueryAsterisk*>(f)->isSingleTableAsterisk()) {
                Field::List *ast_fields = static_cast<QueryAsterisk*>(f)->table()->fields();
                for (Field *ast_f = ast_fields->first(); ast_f; ast_f=ast_fields->next()) {
//                  d->detailedVisibility += isFieldVisible(fieldPosition);
                    QueryColumnInfo *ci = new QueryColumnInfo(ast_f, QCString()/*no field for asterisk!*/,
                        isColumnVisible(fieldPosition));
                    list.append( ci );
                    KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) columns order: "
                        << ci->debugString() << " at position " << fieldPosition << endl;
                    d->columnsOrder->insert(ci, fieldPosition);
//                  list.append(ast_f);
                }
            }
            else {//all-tables asterisk: iterate through table list
                for (TableSchema *table = d->tables.first(); table; table = d->tables.next()) {
                    //add all fields from this table
                    Field::List *tab_fields = table->fields();
                    for (Field *tab_f = tab_fields->first(); tab_f; tab_f = tab_fields->next()) {
//                      d->detailedVisibility += isFieldVisible(fieldPosition);
//                      list.append(tab_f);
                        QueryColumnInfo *ci = new QueryColumnInfo(tab_f, QCString()/*no field for asterisk!*/,
                            isColumnVisible(fieldPosition));
                        list.append( ci );
                        KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) columns order: "
                            << ci->debugString() << " at position " << fieldPosition << endl;
                        d->columnsOrder->insert(ci, fieldPosition);
                    }
                }
            }
        }
        else {
            //a single field
//          d->detailedVisibility += isFieldVisible(fieldPosition);
            QueryColumnInfo *ci = new QueryColumnInfo(f, columnAlias(fieldPosition), isColumnVisible(fieldPosition));
            list.append( ci );
            columnInfosOutsideAsterisks.insert( ci, true );
            KexiDBDbg << "QuerySchema::computeFieldsExpanded(): caching (unexpanded) column's order: "
                << ci->debugString() << " at position " << fieldPosition << endl;
            d->columnsOrder->insert(ci, fieldPosition);
            d->columnsOrderWithoutAsterisks->insert(ci, fieldPosition);

            //handle lookup field schema
            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 = 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() )))
                    {
                        lookup_list.append( new QueryColumnInfo(visibleField, QCString(), true/*visible*/, ci/*foreign*/) );
/*
                        //add visibleField to the list of SELECTed fields if it is not yes present there
                        if (!findTableField( visibleField->table()->name()+"."+visibleField->name() )) {
                            if (!table( visibleField->table()->name() )) {
                            }
                            if (!sql.isEmpty())
                                sql += QString::fromLatin1(", ");
                            sql += (escapeIdentifier(visibleField->table()->name(), drvEscaping) + "."
                                + escapeIdentifier(visibleField->name(), drvEscaping));
                        }*/
                    }
                }
            }
        }
    }
    //prepare clean vector for expanded list, and a map for order information
    if (!d->fieldsExpanded) {
        d->fieldsExpanded = new QueryColumnInfo::Vector( list.count() );// Field::Vector( list.count() );
        d->fieldsExpanded->setAutoDelete(true);
        d->columnsOrderExpanded = new QMap<QueryColumnInfo*,int>();
    }
    else {//for future:
        d->fieldsExpanded->clear();
        d->fieldsExpanded->resize( list.count() );
        d->columnsOrderExpanded->clear();
    }

    /*fill (based on prepared 'list' and 'lookup_list'):
     -the vector
     -the map
     -"fields by name" dictionary
    */
    d->columnInfosByName.clear();
    d->columnInfosByNameExpanded.clear();
    i=0;
    QueryColumnInfo *ci;
    for (QueryColumnInfo::ListIterator it(list); (ci = it.current()); ++it, i++) 
    {
        d->fieldsExpanded->insert(i, ci);
        d->columnsOrderExpanded->insert(ci, i);
        //remember field by name/alias/table.name if there's no such string yet in d->columnInfosByNameExpanded
        if (!ci->alias.isEmpty()) {
            //store alias and table.alias
            if (!d->columnInfosByNameExpanded[ ci->alias ])
                d->columnInfosByNameExpanded.insert( ci->alias, ci );
            QString tableAndAlias( ci->alias );
            if (ci->field->table())
                tableAndAlias.prepend(ci->field->table()->name() + ".");
            if (!d->columnInfosByNameExpanded[ tableAndAlias ])
                d->columnInfosByNameExpanded.insert( tableAndAlias, ci );
            //the same for "unexpanded" list
            if (columnInfosOutsideAsterisks.contains(ci)) {
                if (!d->columnInfosByName[ ci->alias ])
                    d->columnInfosByName.insert( ci->alias, ci );
                if (!d->columnInfosByName[ tableAndAlias ])
                    d->columnInfosByName.insert( tableAndAlias, ci );
            }
        }
        else {
            //no alias: store name and table.name
            if (!d->columnInfosByNameExpanded[ ci->field->name() ])
                d->columnInfosByNameExpanded.insert( ci->field->name(), ci );
            QString tableAndName( ci->field->name() );
            if (ci->field->table())
                tableAndName.prepend(ci->field->table()->name() + ".");
            if (!d->columnInfosByNameExpanded[ tableAndName ])
                d->columnInfosByNameExpanded.insert( tableAndName, ci );
            //the same for "unexpanded" list
            if (columnInfosOutsideAsterisks.contains(ci)) {
                if (!d->columnInfosByName[ ci->field->name() ])
                    d->columnInfosByName.insert( ci->field->name(), ci );
                if (!d->columnInfosByName[ tableAndName ])
                    d->columnInfosByName.insert( tableAndName, ci );
            }
        }
    }

    //remove duplicates for lookup fields
    QDict<uint> lookup_dict; //used to fight duplicates and to update QueryColumnInfo::indexForVisibleLookupValue()
                             // (a mapping from table.name string to uint* lookupFieldIndex
    lookup_dict.setAutoDelete(true);
#define LOOKUP_COLUMN_KEY(foreignField, field) ( field->table()->name() + "." + field->name() \
            + "_" + foreignField->table()->name() + "." + foreignField->name() )
    i=0;
    for (QueryColumnInfo::ListIterator it(lookup_list); (ci = it.current());)
    {
        QString key( LOOKUP_COLUMN_KEY(ci->foreignColumn()->field, ci->field) );
        if ( /* not needed   columnInfo( tableAndFieldName ) || */
            lookup_dict[ key ]) {
            // this table.field is already fetched by this query
            ++it;
            lookup_list.removeRef( ci );
        }
        else {
            lookup_dict.replace( key, new uint( i ) );
            ++it;
            i++;
        }
    }

    //create internal expanded list with lookup fields
    if (d->internalFields) {
        d->internalFields->clear();
        d->internalFields->resize( lookup_list.count() );
    }
    delete d->fieldsExpandedWithInternal; //clear cache
    delete d->fieldsExpandedWithInternalAndRowID; //clear cache
    d->fieldsExpandedWithInternal = 0;
    d->fieldsExpandedWithInternalAndRowID = 0;
    i=0;
    if (!lookup_list.isEmpty() && !d->internalFields) {//create on demand
        d->internalFields = new QueryColumnInfo::Vector( lookup_list.count() );
        d->internalFields->setAutoDelete(true);
    }
    for (QueryColumnInfo::ListIterator it(lookup_list); it.current();i++, ++it)
    {
        //add it to the internal list
        d->internalFields->insert(i, it.current());
        d->columnsOrderExpanded->insert(it.current(), list.count()+i);
    }

    //update QueryColumnInfo::indexForVisibleLookupValue() cache for columns
    for (i=0; i < d->fieldsExpanded->size(); i++) {
        QueryColumnInfo* ci = d->fieldsExpanded->at(i);
        LookupFieldSchema *lookupFieldSchema 
            = ci->field->table() ? ci->field->table()->lookupFieldSchema( *ci->field ) : 0;
        if (lookupFieldSchema) {
            LookupFieldSchema::RowSource& rowSource = lookupFieldSchema->rowSource();
            TableSchema *lookupTable = connection()->tableSchema( rowSource.name() );
            Field *visibleField = 0;
            if (lookupTable && lookupFieldSchema->boundColumn()>=0 
                && (uint)lookupFieldSchema->boundColumn() < lookupTable->fieldCount()
                && (visibleField = lookupTable->field( lookupFieldSchema->visibleColumn())))
            {
                QString key( LOOKUP_COLUMN_KEY(ci->field, visibleField) );//visibleTableAndFieldName( visibleField->table()->name()+"."+visibleField->name() );
                uint *index = lookup_dict[ key ];
                if (index)
                    ci->setIndexForVisibleLookupValue( d->fieldsExpanded->size() + *index );
            }
        }
    }
}

QMap<QueryColumnInfo*,int> QuerySchema::columnsOrder(ColumnsOrderOptions options)
{
    if (!d->columnsOrder)
        computeFieldsExpanded();
    if (options == UnexpandedList)
        return *d->columnsOrder;
    else if (options == UnexpandedListWithoutAsterisks)
        return *d->columnsOrderWithoutAsterisks;
    return *d->columnsOrderExpanded;
}

QValueVector<int> QuerySchema::pkeyFieldsOrder()
{
    if (d->pkeyFieldsOrder)
        return *d->pkeyFieldsOrder;

    TableSchema *tbl = masterTable();
    if (!tbl || !tbl->primaryKey())
        return QValueVector<int>();

    //get order of PKEY fields (e.g. for rows updating or inserting )
    IndexSchema *pkey = tbl->primaryKey();
    d->pkeyFieldsOrder = new QValueVector<int>( pkey->fieldCount(), -1 );

    const uint fCount = fieldsExpanded().count();
    d->pkeyFieldsCount = 0;
    for (uint i = 0; i<fCount; i++) {
        QueryColumnInfo *fi = d->fieldsExpanded->at(i);
        const int fieldIndex = fi->field->table()==tbl ? pkey->indexOf(fi->field) : -1;
        if (fieldIndex!=-1/* field found in PK */ 
            && d->pkeyFieldsOrder->at(fieldIndex)==-1 /* first time */)
        {
            KexiDBDbg << "QuerySchema::pkeyFieldsOrder(): FIELD " << fi->field->name() 
                << " IS IN PKEY AT POSITION #" << fieldIndex << endl;
//          (*d->pkeyFieldsOrder)[j]=i;
            (*d->pkeyFieldsOrder)[fieldIndex]=i;
            d->pkeyFieldsCount++;
//          j++;
        }
    }
    KexiDBDbg << "QuerySchema::pkeyFieldsOrder(): " << d->pkeyFieldsCount
        << " OUT OF " << pkey->fieldCount() << " PKEY'S FIELDS FOUND IN QUERY " << name() << endl;
    return *d->pkeyFieldsOrder;
}

uint QuerySchema::pkeyFieldsCount()
{
    (void)pkeyFieldsOrder(); /* rebuild information */
    return d->pkeyFieldsCount;
}

Relationship* QuerySchema::addRelationship( Field *field1, Field *field2 )
{
//@todo: find existing global db relationships
    Relationship *r = new Relationship(this, field1, field2);
    if (r->isEmpty()) {
        delete r;
        return 0;
    }

    d->relations.append( r );
    return r;
}

QueryColumnInfo::List* QuerySchema::autoIncrementFields()
{
    if (!d->autoincFields) {
        d->autoincFields = new QueryColumnInfo::List();
    }
    TableSchema *mt = masterTable();
    if (!mt) {
        KexiDBWarn << "QuerySchema::autoIncrementFields(): no master table!" << endl;
        return d->autoincFields;
    }
    if (d->autoincFields->isEmpty()) {//no cache
        QueryColumnInfo::Vector fexp =