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

queryschema.h

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.
*/

#ifndef KEXIDB_QUERY_H
#define KEXIDB_QUERY_H

#include <qvaluevector.h>
#include <qstring.h>
#include <qmap.h>
#include <qptrlist.h>

#include "fieldlist.h"
#include "schemadata.h"
#include "tableschema.h"
#include "relationship.h"

namespace KexiDB {

class Connection;
class QueryAsterisk;
class QuerySchemaPrivate;
class QuerySchemaParameter;
typedef QValueList<QuerySchemaParameter> QuerySchemaParameterList;


class KEXI_DB_EXPORT QueryColumnInfo
{
    public:
        typedef QPtrVector<QueryColumnInfo> Vector;
        typedef QPtrList<QueryColumnInfo> List;
        typedef QPtrListIterator<QueryColumnInfo> ListIterator;

        QueryColumnInfo(Field *f, const QCString& _alias, bool _visible, QueryColumnInfo *foreignColumn = 0);
        ~QueryColumnInfo();

        inline QCString aliasOrName() const { 
            return alias.isEmpty() ? field->name().latin1() : (const char*)alias; 
        }

        inline QString captionOrAliasOrName() const {
            return field->caption().isEmpty() ? QString(aliasOrName()) : field->caption(); }

        Field *field;
        QCString alias;

        inline int indexForVisibleLookupValue() const { return m_indexForVisibleLookupValue; }

        inline void setIndexForVisibleLookupValue(int index) { m_indexForVisibleLookupValue = index; }

        QueryColumnInfo *foreignColumn() const { return m_foreignColumn; }

        QString debugString() const;

        bool visible : 1;

    private:
        int m_indexForVisibleLookupValue;

        QueryColumnInfo *m_foreignColumn;
};


class KEXI_DB_EXPORT OrderByColumn
{
    public:
        typedef QValueListConstIterator<OrderByColumn> ListConstIterator;
        OrderByColumn();
        OrderByColumn(QueryColumnInfo& column, bool ascending = true, int pos = -1);
        
        OrderByColumn(Field& field, bool ascending = true);

        ~OrderByColumn();

        inline QueryColumnInfo* column() const { return m_column; }

        inline int position() const { return m_pos; }

        inline Field *field() const { return m_field; }

        inline bool ascending() const { return m_ascending; }

        bool operator== ( const OrderByColumn& col ) const 
            { return m_column==col.m_column && m_field==col.m_field 
                && m_ascending==col.m_ascending; }

        QString debugString() const;

        QString toSQLString(bool includeTableName = true) const;

    protected:
        QueryColumnInfo* m_column; 
        int m_pos; 


        Field* m_field; 

        bool m_ascending : 1;
};

typedef QValueList<OrderByColumn> OrderByColumnListBase;

class KEXI_DB_EXPORT OrderByColumnList : protected OrderByColumnListBase
{
    public:
        OrderByColumnList();

        ~OrderByColumnList();

        bool appendFields(QuerySchema& querySchema,
            const QString& field1, bool ascending1 = true, 
            const QString& field2 = QString::null, bool ascending2 = true, 
            const QString& field3 = QString::null, bool ascending3 = true, 
            const QString& field4 = QString::null, bool ascending4 = true, 
            const QString& field5 = QString::null, bool ascending5 = true);

        void appendColumn(QueryColumnInfo& columnInfo, bool ascending = true);
        
        void appendField(Field& field, bool ascending = true);

        bool appendField(QuerySchema& querySchema, const QString& fieldName, 
            bool ascending = true);

        bool appendColumn(QuerySchema& querySchema, bool ascending = true, int pos = -1);

        void appendColumn(const OrderByColumn& column);
        
        bool isEmpty() const { return OrderByColumnListBase::isEmpty(); }
        
        uint count() const { return OrderByColumnListBase::count(); }

        void clear() { OrderByColumnListBase::clear(); }

        const_iterator constBegin () const { return OrderByColumnListBase::constBegin(); }
        const_iterator constEnd () const { return OrderByColumnListBase::constEnd(); }

        QString debugString() const;
        
        QString toSQLString(bool includeTableNames = true) const;
};


class KEXI_DB_EXPORT QuerySchema : public FieldList, public SchemaData
{
    public:
        QuerySchema();

        QuerySchema(TableSchema* tableSchema);
        
        virtual ~QuerySchema();
        
        virtual FieldList& insertField(uint position, Field *field);

        /* Like above method, but you can also set column's visibility. 
         New column is not bound explicitly to any table.
        */
        FieldList& insertField(uint position, Field *field, bool visible);

        /* Like above method, but you can also explicitly bound the new column
         to specific position on tables list. 
         If \a visible is true (the default), the field will be visible. 
         If bindToTable==-1, no particular table should be bound.
         @see tableBoundToColumn(uint columnPosition) */
        FieldList& insertField(uint position, Field *field, 
            int bindToTable, bool visible = true);
        
        FieldList& addField(Field* field, bool visible = true);
        
        FieldList& addField(Field* field, int bindToTable, 
            bool visible = true);

        virtual void removeField(Field *field);

        FieldList& addExpression(BaseExpr* expr, bool visible = true);

        bool isColumnVisible(uint position) const;

        void setColumnVisible(uint position, bool v);

        FieldList& addAsterisk(QueryAsterisk *asterisk, bool visible = true);

        virtual void clear();

        virtual QString debugString();

        Connection* connection() const;
        
        TableSchema* masterTable() const;

        void setMasterTable(TableSchema *table);
        
        TableSchema::List* tables() const;

        void addTable(TableSchema *table, const QCString& alias = QCString());

        void removeTable(TableSchema *table);

        TableSchema* table(const QString& tableName) const;
        
        bool contains(TableSchema *table) const;

        Field* findTableField(const QString &tableOrTableAndFieldName) const;

        QCString columnAlias(uint position) const;
        
        bool hasColumnAlias(uint position) const;

        void setColumnAlias(uint position, const QCString& alias);

        int tableBoundToColumn(uint columnPosition) const;

        QCString tableAlias(uint position) const;
        
        int tablePositionForAlias(const QCString& name) const;

        int tablePosition(const QString& tableName) const;
        
        QValueList<int> tablePositions(const QString& tableName) const;

        bool hasTableAlias(uint position) const;

        int columnPositionForAlias(const QCString& name) const;

        void setTableAlias(uint position, const QCString& alias);

        Relationship::List* relationships() const;

        Relationship* addRelationship( Field *field1, Field *field2 );

        Field::List* asterisks() const;

        virtual Field* field(const QString& name, bool expanded = true);

        inline Field* field(uint id) { return FieldList::field(id); }

        QueryColumnInfo* columnInfo(const QString& identifier, bool expanded = true);

        enum FieldsExpandedOptions {
            Default,                   
            Unique,                    
            WithInternalFields,        
            WithInternalFieldsAndRowID 

        };

        QueryColumnInfo::Vector fieldsExpanded(FieldsExpandedOptions options = Default);

        QueryColumnInfo::Vector internalFields();

        QueryColumnInfo* expandedOrInternalField(uint index);

        enum ColumnsOrderOptions {
            UnexpandedList,                 
            UnexpandedListWithoutAsterisks, 
            ExpandedList                    
        };

        QMap<QueryColumnInfo*,int> columnsOrder(ColumnsOrderOptions options = ExpandedList);

        QValueVector<int> pkeyFieldsOrder();

        uint pkeyFieldsCount();

        QueryColumnInfo::List* autoIncrementFields();

        QString statement() const;

        void setStatement(const QString &s);

        static QString sqlColumnsList(QueryColumnInfo::List* infolist, Driver *driver);

        QString autoIncrementSQLFieldsList(Driver *driver);

        void setWhereExpression(BaseExpr *expr);

        BaseExpr *whereExpression() const;
    
        void addToWhereExpression(KexiDB::Field *field, const QVariant& value, int relation = '=');

        void setOrderByColumnList(const OrderByColumnList& list);

        OrderByColumnList& orderByColumnList() const;

        QuerySchemaParameterList parameters();

    protected:
        void init();

        void computeFieldsExpanded();

        QuerySchemaPrivate *d;
        
    friend class Connection;
    friend class QuerySchemaPrivate;
};


class KEXI_DB_EXPORT QueryAsterisk : protected Field
{
    public:
        QueryAsterisk( QuerySchema *query, TableSchema *table = 0 );
        
        virtual ~QueryAsterisk();

        QuerySchema *query() const { return static_cast<QuerySchema*>(m_parent); }

        virtual TableSchema* table() const { return m_table; }

        virtual void setTable(TableSchema *table);

        bool isSingleTableAsterisk() const { return m_table!=NULL; }
        
        bool isAllTableAsterisk() const { return m_table==NULL; }
        
        virtual QString debugString();

    protected:
        TableSchema* m_table;

    friend class QuerySchema;
};

} //namespace KexiDB

#endif

This file is part of the documentation for Kexi 2.0 alpha.

Documentation copyright © 2002-2007 the Kexi Team.
Generated on Tue Apr 1 20:48:48 2008 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003