queryschema.h

/* This file is part of the KDE project
   Copyright (C) 2003-2007 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 <tqvaluevector.h>
#include <tqstring.h>
#include <tqmap.h>
#include <tqptrlist.h>
 
#include "fieldlist.h"
#include "schemadata.h"
#include "tableschema.h"
#include "relationship.h"
 
namespace KexiDB {
 
class Connection;
class QueryAsterisk;
class QuerySchemaPrivate;
class QuerySchemaParameter;
typedef TQValueList<QuerySchemaParameter> QuerySchemaParameterList;
 
 
class KEXI_DB_EXPORT QueryColumnInfo
{
    public:
        typedef TQPtrVector<QueryColumnInfo> Vector;
        typedef TQPtrList<QueryColumnInfo> List;
        typedef TQPtrListIterator<QueryColumnInfo> ListIterator;
 
        QueryColumnInfo(Field *f, const TQCString& _alias, bool _visible, QueryColumnInfo *foreignColumn = 0);
        ~QueryColumnInfo();
 
        inline TQCString aliasOrName() const { 
            return alias.isEmpty() ? field->name().latin1() : (const char*)alias; 
        }
 
        inline TQString captionOrAliasOrName() const {
            return field->caption().isEmpty() ? TQString(aliasOrName()) : field->caption(); }
 
        Field *field;
        TQCString alias;
 
        inline int indexForVisibleLookupValue() const { return m_indexForVisibleLookupValue; }
 
        inline void setIndexForVisibleLookupValue(int index) { m_indexForVisibleLookupValue = index; }
 
        QueryColumnInfo *foreignColumn() const { return m_foreignColumn; }
 
        TQString debugString() const;
 
        bool visible : 1;
 
    private:
        int m_indexForVisibleLookupValue;
 
        QueryColumnInfo *m_foreignColumn;
};
 
 
class KEXI_DB_EXPORT OrderByColumn
{
    public:
        typedef TQValueListConstIterator<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; }
 
        TQString debugString() const;
 
        TQString toSQLString(bool includeTableName = true, 
            Driver *drv = 0, int identifierEscaping = Driver::EscapeDriver|Driver::EscapeAsNecessary) const;
 
    protected:
        QueryColumnInfo* m_column; 
        int m_pos; 
        Field* m_field; 
 
        bool m_ascending : 1;
};
 
typedef TQValueList<OrderByColumn> OrderByColumnListBase;
 
class KEXI_DB_EXPORT OrderByColumnList : protected OrderByColumnListBase
{
    public:
        OrderByColumnList();
 
        ~OrderByColumnList();
 
        bool appendFields(QuerySchema& querySchema,
            const TQString& field1, bool ascending1 = true, 
            const TQString& field2 = TQString(), bool ascending2 = true, 
            const TQString& field3 = TQString(), bool ascending3 = true, 
            const TQString& field4 = TQString(), bool ascending4 = true, 
            const TQString& field5 = TQString(), bool ascending5 = true);
 
        void appendColumn(QueryColumnInfo& columnInfo, bool ascending = true);
        
        void appendField(Field& field, bool ascending = true);
 
        bool appendField(QuerySchema& querySchema, const TQString& 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(); }
 
        TQString debugString() const;
        
        TQString toSQLString(bool includeTableNames = true, 
            Driver *drv = 0, int identifierEscaping = Driver::EscapeDriver|Driver::EscapeAsNecessary) const;
};
 
 
class KEXI_DB_EXPORT QuerySchema : public FieldList, public SchemaData
{
    public:
        QuerySchema();
 
        QuerySchema(TableSchema& tableSchema);
 
        QuerySchema(const QuerySchema& querySchema);
 
        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 TQString debugString();
 
        Connection* connection() const;
        
        TableSchema* masterTable() const;
 
        void setMasterTable(TableSchema *table);
        
        TableSchema::List* tables() const;
 
        void addTable(TableSchema *table, const TQCString& alias = TQCString());
 
        void removeTable(TableSchema *table);
 
        TableSchema* table(const TQString& tableName) const;
        
        bool contains(TableSchema *table) const;
 
        Field* findTableField(const TQString &tableOrTableAndFieldName) const;
 
        TQCString columnAlias(uint position) const;
        
        bool hasColumnAlias(uint position) const;
 
        void setColumnAlias(uint position, const TQCString& alias);
 
        int tableBoundToColumn(uint columnPosition) const;
 
        TQCString tableAlias(uint position) const;
        
        int tablePositionForAlias(const TQCString& name) const;
 
        int tablePosition(const TQString& tableName) const;
        
        TQValueList<int> tablePositions(const TQString& tableName) const;
 
        bool hasTableAlias(uint position) const;
 
        int columnPositionForAlias(const TQCString& name) const;
 
        void setTableAlias(uint position, const TQCString& alias);
 
        Relationship::List* relationships() const;
 
        Relationship* addRelationship( Field *field1, Field *field2 );
 
        Field::List* asterisks() const;
 
        virtual Field* field(const TQString& name, bool expanded = true);
 
        inline Field* field(uint id) { return FieldList::field(id); }
 
        QueryColumnInfo* columnInfo(const TQString& 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                    
        };
 
        TQMap<QueryColumnInfo*,int> columnsOrder(ColumnsOrderOptions options = ExpandedList);
 
        TQValueVector<int> pkeyFieldsOrder();
 
        uint pkeyFieldsCount();
 
        QueryColumnInfo::List* autoIncrementFields();
 
        TQString statement() const;
 
        void setStatement(const TQString &s);
 
        static TQString sqlColumnsList(QueryColumnInfo::List* infolist, Driver *driver);
 
        TQString autoIncrementSQLFieldsList(Driver *driver);
 
        void setWhereExpression(BaseExpr *expr);
 
        BaseExpr *whereExpression() const;
    
        void addToWhereExpression(KexiDB::Field *field, const TQVariant& 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 : public 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);
 
        virtual bool isQueryAsterisk() const  { return true; }
 
        bool isSingleTableAsterisk() const { return m_table!=NULL; }
        
        bool isAllTableAsterisk() const { return m_table==NULL; }
        
        virtual TQString debugString() const;
 
    protected:
        virtual Field* copy() const;
 
        TableSchema* m_table;
 
    friend class QuerySchema;
};
 
} //namespace KexiDB
 
#endif