xref: /aoo41x/main/dbaccess/source/ui/querydesign/QueryDesignView.cxx (revision 96de5490)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_dbaccess.hxx"
#ifndef DBAUI_QUERYDESIGNVIEW_HXX
#include "QueryDesignView.hxx"
#endif
#ifndef DBAUI_QUERYTABLEVIEW_HXX
#include "QueryTableView.hxx"
#endif
#ifndef DBAUI_QUERY_TABLEWINDOW_HXX
#include "QTableWindow.hxx"
#endif
#ifndef _SV_TOOLBOX_HXX
#include <vcl/toolbox.hxx>
#endif
#ifndef DBAUI_QUERYCONTROLLER_HXX
#include "querycontroller.hxx"
#endif
#ifndef _SV_SPLIT_HXX
#include <vcl/split.hxx>
#endif
#ifndef _UNDO_HXX
#include <svl/undo.hxx>
#endif
#ifndef TOOLS_DIAGNOSE_EX_H
#include <tools/diagnose_ex.h>
#endif
#ifndef DBAUI_QYDLGTAB_HXX
#include "adtabdlg.hxx"
#endif
#ifndef _SV_SVAPP_HXX
#include <vcl/svapp.hxx>
#endif
#ifndef _SV_COMBOBOX_HXX
#include <vcl/combobox.hxx>
#endif
#ifndef _SV_MSGBOX_HXX
#include <vcl/msgbox.hxx>
#endif
#ifndef DBACCESS_UI_BROWSER_ID_HXX
#include "browserids.hxx"
#endif
#ifndef DBAUI_QUERYDESIGN_OSELECTIONBROWSEBOX_HXX
#include "SelectionBrowseBox.hxx"
#endif
#ifndef _DBU_QRY_HRC_
#include "dbu_qry.hrc"
#endif
#ifndef _UTL_CONFIGMGR_HXX_
#include <unotools/configmgr.hxx>
#endif
#ifndef _COMPHELPER_TYPES_HXX_
#include <comphelper/types.hxx>
#endif
#ifndef _CONNECTIVITY_DBTOOLS_HXX_
#include <connectivity/dbtools.hxx>
#endif
#ifndef _DBHELPER_DBEXCEPTION_HXX_
#include <connectivity/dbexception.hxx>
#endif
#ifndef _COM_SUN_STAR_I18N_XLOCALEDATA_HPP_
#include <com/sun/star/i18n/XLocaleData.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_
#include <com/sun/star/sdbc/DataType.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_
#include <com/sun/star/container/XNameAccess.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBC_COLUMNVALUE_HPP_
#include <com/sun/star/sdbc/ColumnValue.hpp>
#endif
#ifndef _CONNECTIVITY_PCOLUMN_HXX_
#include <connectivity/PColumn.hxx>
#endif
#ifndef DBAUI_QUERYTABLECONNECTION_HXX
#include "QTableConnection.hxx"
#endif
#ifndef DBAUI_CONNECTIONLINE_HXX
#include "ConnectionLine.hxx"
#endif
#ifndef DBAUI_CONNECTIONLINEDATA_HXX
#include "ConnectionLineData.hxx"
#endif
#ifndef DBAUI_QTABLECONNECTIONDATA_HXX
#include "QTableConnectionData.hxx"
#endif
#ifndef DBACCESS_SHARED_DBUSTRINGS_HRC
#include "dbustrings.hrc"
#endif
#ifndef _COMPHELPER_EXTRACT_HXX_
#include <comphelper/extract.hxx>
#endif
#ifndef DBAUI_TOOLS_HXX
#include "UITools.hxx"
#endif
#ifndef DBAUI_QUERYCONTAINERWINDOW_HXX
#include "querycontainerwindow.hxx"
#endif
#ifndef DBAUI_QUERYTABLEVIEW_HXX
#include "QueryTableView.hxx"
#endif
#ifndef _DBAUI_SQLMESSAGE_HXX_
#include "sqlmessage.hxx"
#endif
#ifndef INCLUDED_SVTOOLS_SYSLOCALE_HXX
#include <unotools/syslocale.hxx>
#endif

using namespace ::dbaui;
using namespace ::utl;
using namespace ::connectivity;
using namespace ::dbtools;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::i18n;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::container;

#define SQL_ISRULEOR2(pParseNode, e1,e2) 	((pParseNode)->isRule() && (\
											(pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::e1) || \
											(pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::e2)))

// here we define our functions used in the anonymous namespace to get our header file smaller
// please look at the book LargeScale C++ to know why
namespace
{
	static const ::rtl::OUString C_AND = ::rtl::OUString::createFromAscii(" AND ");
	static const ::rtl::OUString C_OR  = ::rtl::OUString::createFromAscii(" OR ");

	// forward declarations
	sal_Bool InsertJoin(	const OQueryDesignView* _pView,
							const ::connectivity::OSQLParseNode *pNode);

	SqlParseError InstallFields(OQueryDesignView* _pView,
								const ::connectivity::OSQLParseNode* pNode,
								OJoinTableView::OTableWindowMap* pTabList );

	SqlParseError GetGroupCriteria(	OQueryDesignView* _pView,
									OSelectionBrowseBox* _pSelectionBrw,
									const ::connectivity::OSQLParseNode* pSelectRoot );

	SqlParseError GetHavingCriteria(OQueryDesignView* _pView,
									OSelectionBrowseBox* _pSelectionBrw,
									const ::connectivity::OSQLParseNode* pSelectRoot,
									sal_uInt16& rLevel );

	SqlParseError GetOrderCriteria(	OQueryDesignView* _pView,
									OSelectionBrowseBox* _pSelectionBrw,
									const ::connectivity::OSQLParseNode* pParseRoot );

	SqlParseError AddFunctionCondition(OQueryDesignView* _pView,
									OSelectionBrowseBox* _pSelectionBrw,
									const ::connectivity::OSQLParseNode * pCondition,
									const sal_uInt16 nLevel,
									sal_Bool bHaving,
                                    bool _bAddOrOnOneLine);

	//------------------------------------------------------------------------------
	::rtl::OUString quoteTableAlias(sal_Bool _bQuote, const ::rtl::OUString& _sAliasName, const ::rtl::OUString& _sQuote)
	{
		::rtl::OUString sRet;
		if ( _bQuote && _sAliasName.getLength() )
		{
			sRet = ::dbtools::quoteName(_sQuote,_sAliasName);
			const static ::rtl::OUString sTableSeparater('.');
			sRet += sTableSeparater;
		}
		return sRet;
	}
    //------------------------------------------------------------------------------
    ::rtl::OUString getTableRange(const OQueryDesignView* _pView,const ::connectivity::OSQLParseNode* _pTableRef)
    {
        Reference< XConnection> xConnection = static_cast<OQueryController&>(_pView->getController()).getConnection();
        ::rtl::OUString sTableRange;
        if ( _pTableRef )
        {
            sTableRange = ::connectivity::OSQLParseNode::getTableRange(_pTableRef);
            if ( !sTableRange.getLength() )
                _pTableRef->parseNodeToStr(sTableRange,xConnection,NULL,sal_False,sal_False);
        }
        return sTableRange;
    }
    //------------------------------------------------------------------------------
    void insertConnection(const OQueryDesignView* _pView,const EJoinType& _eJoinType,OTableFieldDescRef _aDragLeft,OTableFieldDescRef _aDragRight,bool _bNatural = false)
    {
        OQueryTableView* pTableView = static_cast<OQueryTableView*>(_pView->getTableView());
		OQueryTableConnection* pConn = static_cast<OQueryTableConnection*>( pTableView->GetTabConn(static_cast<OTableWindow*>(_aDragLeft->GetTabWindow()),static_cast<OTableWindow*>(_aDragRight->GetTabWindow()),true));

		if ( !pConn )
		{
			OQueryTableConnectionData* pInfoData = new OQueryTableConnectionData();
            TTableConnectionData::value_type aInfoData(pInfoData);
			pInfoData->InitFromDrag(_aDragLeft, _aDragRight);
			pInfoData->SetJoinType(_eJoinType);

            if ( _bNatural )
            {
                aInfoData->ResetConnLines();
                pInfoData->setNatural(_bNatural);
                try
                {
                    Reference<XNameAccess> xReferencedTableColumns(aInfoData->getReferencedTable()->getColumns());
                    Sequence< ::rtl::OUString> aSeq = aInfoData->getReferencingTable()->getColumns()->getElementNames();
                    const ::rtl::OUString* pIter = aSeq.getConstArray();
                    const ::rtl::OUString* pEnd	  = pIter + aSeq.getLength();
                    for(;pIter != pEnd;++pIter)
                    {
                        if ( xReferencedTableColumns->hasByName(*pIter) )
                            aInfoData->AppendConnLine(*pIter,*pIter);
                    }
                }
                catch( const Exception& )
                {
                    DBG_UNHANDLED_EXCEPTION();
                }
            }

			OQueryTableConnection aInfo(pTableView, aInfoData);
			// da ein OQueryTableConnection-Objekt nie den Besitz der uebergebenen Daten uebernimmt, sondern sich nur den Zeiger merkt,
			// ist dieser Zeiger auf eine lokale Variable hier unkritisch, denn aInfoData und aInfo haben die selbe Lebensdauer
			pTableView->NotifyTabConnection( aInfo );
		}
		else
		{
			::rtl::OUString aSourceFieldName(_aDragLeft->GetField());
			::rtl::OUString aDestFieldName(_aDragRight->GetField());
			// the connection could point on the other side
			if(pConn->GetSourceWin() == _aDragRight->GetTabWindow())
			{
				::rtl::OUString aTmp(aSourceFieldName);
				aSourceFieldName = aDestFieldName;
				aDestFieldName = aTmp;
			}
			pConn->GetData()->AppendConnLine( aSourceFieldName,aDestFieldName);
			pConn->UpdateLineList();
			// Modified-Flag
			//	SetModified();
			// und neu zeichnen
			pConn->RecalcLines();
				// fuer das unten folgende Invalidate muss ich dieser neuen Connection erst mal die Moeglichkeit geben,
				// ihr BoundingRect zu ermitteln
			pConn->InvalidateConnection();
		}
    }
	//------------------------------------------------------------------------------
	::rtl::OUString ParseCondition(	OQueryController& rController
									,const ::connectivity::OSQLParseNode* pCondition
									,const ::rtl::OUString _sDecimal
									,const ::com::sun::star::lang::Locale& _rLocale
									,sal_uInt32 _nStartIndex)
	{
		::rtl::OUString	aCondition;
		Reference< XConnection> xConnection = rController.getConnection();
		if ( xConnection.is() )
		{
			sal_uInt32 nCount = pCondition->count();
			for(sal_uInt32 i = _nStartIndex ; i < nCount ; ++i)
				pCondition->getChild(i)->parseNodeToPredicateStr(aCondition,
								xConnection,
								rController.getNumberFormatter(),
								_rLocale,
								static_cast<sal_Char>(_sDecimal.toChar()),
								&rController.getParser().getContext());
		}
		return aCondition;
	}
	//------------------------------------------------------------------------------
	SqlParseError FillOuterJoins(OQueryDesignView* _pView,
								const ::connectivity::OSQLParseNode* pTableRefList)
	{
		SqlParseError eErrorCode = eOk;
		sal_uInt32 nCount = pTableRefList->count();
		sal_Bool bError = sal_False;
		for (sal_uInt32 i=0; !bError && i < nCount; ++i)
		{
			const ::connectivity::OSQLParseNode* pParseNode = pTableRefList->getChild(i);
			const ::connectivity::OSQLParseNode* pJoinNode = NULL;

			if ( SQL_ISRULE( pParseNode, qualified_join ) || SQL_ISRULE( pParseNode, joined_table ) || SQL_ISRULE( pParseNode, cross_union ) )
				pJoinNode = pParseNode;
			else if(	SQL_ISRULE(pParseNode,table_ref)
					&&	pParseNode->count() == 4 ) // '{' SQL_TOKEN_OJ joined_table '}'
				pJoinNode = pParseNode->getChild(2);

			if ( pJoinNode )
			{
				if ( !InsertJoin(_pView,pJoinNode) )
					bError = sal_True;
			}
		}
		// check if error occured
		if ( bError )
			eErrorCode = eIllegalJoin;

		return eErrorCode;
	}
	// -----------------------------------------------------------------------------

	/** FillDragInfo fills the field description out of the table
	*/
	//------------------------------------------------------------------------------
	SqlParseError FillDragInfo(	const OQueryDesignView* _pView,
							const ::connectivity::OSQLParseNode* pColumnRef,
							OTableFieldDescRef& _rDragInfo)
	{
		SqlParseError eErrorCode = eOk;

		sal_Bool bErg = sal_False;

		::rtl::OUString aTableRange,aColumnName;
		sal_uInt16 nCntAccount;
		::connectivity::OSQLParseTreeIterator& rParseIter = static_cast<OQueryController&>(_pView->getController()).getParseIterator();
		rParseIter.getColumnRange( pColumnRef, aColumnName, aTableRange );

		if ( aTableRange.getLength() )
		{
			OQueryTableWindow*	pSTW = static_cast<OQueryTableView*>(_pView->getTableView())->FindTable( aTableRange );
			bErg = (pSTW && pSTW->ExistsField( aColumnName, _rDragInfo ) );
		}
		if ( !bErg )
        {
			bErg = static_cast<OQueryTableView*>(_pView->getTableView())->FindTableFromField(aColumnName, _rDragInfo, nCntAccount);
            if ( !bErg )
                bErg = _pView->HasFieldByAliasName(aColumnName, _rDragInfo);
        }
		if ( !bErg )
		{
			eErrorCode = eColumnNotFound;
			String sError(ModuleRes(STR_QRY_COLUMN_NOT_FOUND));
			sError.SearchAndReplaceAscii("$name$",aColumnName);
			_pView->getController().appendError( sError );

			try
			{
				Reference<XDatabaseMetaData> xMeta = _pView->getController().getConnection()->getMetaData();
                if ( xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers() )
                    _pView->getController().appendError( String( ModuleRes( STR_QRY_CHECK_CASESENSITIVE ) ) );
			}
			catch(Exception&)
			{
			}
		}

		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	::rtl::OUString BuildJoinCriteria(	const Reference< XConnection>& _xConnection,
										OConnectionLineDataVec* pLineDataList,
										OQueryTableConnectionData* pData)
	{
		::rtl::OUStringBuffer aCondition;
		if ( _xConnection.is() )
        {
		    OConnectionLineDataVec::iterator aIter = pLineDataList->begin();
            OConnectionLineDataVec::iterator aEnd = pLineDataList->end();
		    try
		    {
			    const Reference< XDatabaseMetaData >  xMetaData = _xConnection->getMetaData();
			    const ::rtl::OUString aQuote = xMetaData->getIdentifierQuoteString();
                const ::rtl::OUString sEqual(RTL_CONSTASCII_USTRINGPARAM(" = "));

			    for(;aIter != aEnd;++aIter)
			    {
				    OConnectionLineDataRef pLineData = *aIter;
				    if(aCondition.getLength())
					    aCondition.append(C_AND);
				    aCondition.append(quoteTableAlias(sal_True,pData->GetAliasName(JTCS_FROM),aQuote));
				    aCondition.append(::dbtools::quoteName(aQuote, pLineData->GetFieldName(JTCS_FROM) ));
				    aCondition.append(sEqual);
				    aCondition.append(quoteTableAlias(sal_True,pData->GetAliasName(JTCS_TO),aQuote));
				    aCondition.append(::dbtools::quoteName(aQuote, pLineData->GetFieldName(JTCS_TO) ));
			    }
		    }
		    catch(SQLException&)
		    {
			    OSL_ASSERT(!"Failure while building Join criteria!");
		    }
        }

		return aCondition.makeStringAndClear();
	}
	//------------------------------------------------------------------------------
	/** JoinCycle looks for a join cycle and append it to the string
		@param	_xConnection	the connection
		@param	_pEntryConn		the table connection which holds the data
		@param	_pEntryTabTo	the corresponding table window
		@param	_rJoin			the String which will contain the resulting string
	*/
	void JoinCycle(	const Reference< XConnection>& _xConnection,
					OQueryTableConnection* _pEntryConn,
					const OQueryTableWindow* _pEntryTabTo,
					::rtl::OUString& _rJoin )
	{
		OSL_ENSURE(_pEntryConn,"TableConnection can not be null!");

		OQueryTableConnectionData* pData = static_cast< OQueryTableConnectionData*>(_pEntryConn->GetData().get());
		if ( pData->GetJoinType() != INNER_JOIN && _pEntryTabTo->ExistsAVisitedConn() )
		{
			sal_Bool bBrace = sal_False;
			if(_rJoin.getLength() && _rJoin.lastIndexOf(')') == (_rJoin.getLength()-1))
			{
				bBrace = sal_True;
				_rJoin = _rJoin.replaceAt(_rJoin.getLength()-1,1,::rtl::OUString(' '));
			}
			(_rJoin += C_AND) += BuildJoinCriteria(_xConnection,pData->GetConnLineDataList(),pData);
			if(bBrace)
				_rJoin += ::rtl::OUString(')');
			_pEntryConn->SetVisited(sal_True);
		}
	}
	//------------------------------------------------------------------------------
	::rtl::OUString BuildTable(	const Reference< XConnection>& _xConnection,
								const OQueryTableWindow* pEntryTab,
                                bool _bForce = false
								)
	{
		::rtl::OUString aDBName(pEntryTab->GetComposedName());

		//	Reference< XConnection> xConnection = static_cast<OQueryController&>(_pView->getController()).getConnection();
		if( _xConnection.is() )
		{
			try
			{
				Reference< XDatabaseMetaData >  xMetaData = _xConnection->getMetaData();

                ::rtl::OUString sCatalog, sSchema, sTable;
                ::dbtools::qualifiedNameComponents( xMetaData, aDBName, sCatalog, sSchema, sTable, ::dbtools::eInDataManipulation );
				::rtl::OUString aTableListStr = ::dbtools::composeTableNameForSelect( _xConnection, sCatalog, sSchema, sTable );

				::rtl::OUString aQuote = xMetaData->getIdentifierQuoteString();
				if ( _bForce || isAppendTableAliasEnabled( _xConnection ) || pEntryTab->GetAliasName() != aDBName )
				{
                    aTableListStr += ::rtl::OUString::createFromAscii(" ");
                    if ( generateAsBeforeTableAlias( _xConnection ) )
                        aTableListStr += ::rtl::OUString::createFromAscii("AS ");
					aTableListStr += ::dbtools::quoteName( aQuote, pEntryTab->GetAliasName() );
				}
				aDBName = aTableListStr;
			}
			catch(const SQLException&)
			{
                DBG_UNHANDLED_EXCEPTION();
			}
		}
		return aDBName;
	}
	//------------------------------------------------------------------------------
	::rtl::OUString BuildJoin(	const Reference< XConnection>& _xConnection,
								const ::rtl::OUString& rLh,
								const ::rtl::OUString& rRh,
								OQueryTableConnectionData* pData)
	{

		String aErg(rLh);
        if ( pData->isNatural() && pData->GetJoinType() != CROSS_JOIN )
            aErg.AppendAscii(" NATURAL ");
		switch(pData->GetJoinType())
		{
			case LEFT_JOIN:
				aErg.AppendAscii(" LEFT OUTER ");
				break;
			case RIGHT_JOIN:
				aErg.AppendAscii(" RIGHT OUTER ");
				break;
            case CROSS_JOIN:
                OSL_ENSURE(!pData->isNatural(),"OQueryDesignView::BuildJoin: This should not happen!");
				aErg.AppendAscii(" CROSS ");
				break;
			case INNER_JOIN:
                OSL_ENSURE(pData->isNatural(),"OQueryDesignView::BuildJoin: This should not happen!");
				aErg.AppendAscii(" INNER ");
				break;
			default:
				aErg.AppendAscii(" FULL OUTER ");
				break;
		}
		aErg.AppendAscii("JOIN ");
		aErg += String(rRh);
        if ( CROSS_JOIN != pData->GetJoinType() && !pData->isNatural() )
        {
		    aErg.AppendAscii(" ON ");
		    aErg += String(BuildJoinCriteria(_xConnection,pData->GetConnLineDataList(),pData));
        }

		return aErg;
	}
	//------------------------------------------------------------------------------
	::rtl::OUString BuildJoin(	const Reference< XConnection>& _xConnection,
								OQueryTableWindow* pLh,
								OQueryTableWindow* pRh,
								OQueryTableConnectionData* pData
								)
	{
        bool bForce = pData->GetJoinType() == CROSS_JOIN || pData->isNatural();
		return BuildJoin(_xConnection,BuildTable(_xConnection,pLh,bForce),BuildTable(_xConnection,pRh,bForce),pData);
	}
	//------------------------------------------------------------------------------
	::rtl::OUString BuildJoin(	const Reference< XConnection>& _xConnection,
								const ::rtl::OUString &rLh,
								OQueryTableWindow* pRh,
								OQueryTableConnectionData* pData
								)
	{
		return BuildJoin(_xConnection,rLh,BuildTable(_xConnection,pRh),pData);
	}
	//------------------------------------------------------------------------------
	::rtl::OUString BuildJoin(	const Reference< XConnection>& _xConnection,
								OQueryTableWindow* pLh,
								const ::rtl::OUString &rRh,
								OQueryTableConnectionData* pData
								)
	{
		return BuildJoin(_xConnection,BuildTable(_xConnection,pLh),rRh,pData);
	}
	//------------------------------------------------------------------------------
	void GetNextJoin(	const Reference< XConnection>& _xConnection,
						OQueryTableConnection* pEntryConn,
						OQueryTableWindow* pEntryTabTo,
						::rtl::OUString &aJoin)
	{
		OQueryTableConnectionData* pEntryConnData = static_cast<OQueryTableConnectionData*>(pEntryConn->GetData().get());
        if ( pEntryConnData->GetJoinType() == INNER_JOIN && !pEntryConnData->isNatural() )
			return;

		//	Reference< XConnection> xConnection = static_cast<OQueryController&>(_pView->getController()).getConnection();

		if(!aJoin.getLength())
		{
			OQueryTableWindow* pEntryTabFrom = static_cast<OQueryTableWindow*>(pEntryConn->GetSourceWin());
			aJoin = BuildJoin(_xConnection,pEntryTabFrom,pEntryTabTo,pEntryConnData);
		}
		else if(pEntryTabTo == pEntryConn->GetDestWin())
		{
			aJoin = BuildJoin(_xConnection,aJoin,pEntryTabTo,pEntryConnData);
		}
		else if(pEntryTabTo == pEntryConn->GetSourceWin())
		{
			aJoin = BuildJoin(_xConnection,pEntryTabTo,aJoin,pEntryConnData);
		}

		pEntryConn->SetVisited(sal_True);

		// first search for the "to" window
		const ::std::vector<OTableConnection*>* pConnections = pEntryConn->GetParent()->getTableConnections();
		::std::vector<OTableConnection*>::const_iterator aIter = pConnections->begin();
        ::std::vector<OTableConnection*>::const_iterator aEnd = pConnections->end();
		for(;aIter != aEnd;++aIter)
		{
			OQueryTableConnection* pNext = static_cast<OQueryTableConnection*>(*aIter);
			if(!pNext->IsVisited() && (pNext->GetSourceWin() == pEntryTabTo || pNext->GetDestWin() == pEntryTabTo))
			{
				OQueryTableWindow* pEntryTab = pNext->GetSourceWin() == pEntryTabTo ? static_cast<OQueryTableWindow*>(pNext->GetDestWin()) : static_cast<OQueryTableWindow*>(pNext->GetSourceWin());
				// exists there a connection to a OQueryTableWindow that holds a connection that has been already visited
				JoinCycle(_xConnection,pNext,pEntryTab,aJoin);
				if(!pNext->IsVisited())
					GetNextJoin(_xConnection,pNext,pEntryTab,aJoin);
			}
		}

		// when nothing found found look for the "from" window
		if(aIter == aEnd)
		{
			OQueryTableWindow* pEntryTabFrom = static_cast<OQueryTableWindow*>(pEntryConn->GetSourceWin());
			aIter = pConnections->begin();
			for(;aIter != aEnd;++aIter)
			{
				OQueryTableConnection* pNext = static_cast<OQueryTableConnection*>(*aIter);
				if(!pNext->IsVisited() && (pNext->GetSourceWin() == pEntryTabFrom || pNext->GetDestWin() == pEntryTabFrom))
				{
					OQueryTableWindow* pEntryTab = pNext->GetSourceWin() == pEntryTabFrom ? static_cast<OQueryTableWindow*>(pNext->GetDestWin()) : static_cast<OQueryTableWindow*>(pNext->GetSourceWin());
					// exists there a connection to a OQueryTableWindow that holds a connection that has been already visited
					JoinCycle(_xConnection,pNext,pEntryTab,aJoin);
					if(!pNext->IsVisited())
						GetNextJoin(_xConnection,pNext,pEntryTab,aJoin);
				}
			}
		}
	}
	//------------------------------------------------------------------------------
	SqlParseError InsertJoinConnection(	const OQueryDesignView* _pView,
									const ::connectivity::OSQLParseNode *pNode,
									const EJoinType& _eJoinType,
                                    const ::connectivity::OSQLParseNode *pLeftTable,
                                    const ::connectivity::OSQLParseNode *pRightTable)
	{
		SqlParseError eErrorCode = eOk;
		if (pNode->count() == 3 &&	// Ausdruck is geklammert
			SQL_ISPUNCTUATION(pNode->getChild(0),"(") &&
			SQL_ISPUNCTUATION(pNode->getChild(2),")"))
		{
			eErrorCode = InsertJoinConnection(_pView,pNode->getChild(1), _eJoinType,pLeftTable,pRightTable);
		}
		else if (SQL_ISRULEOR2(pNode,search_condition,boolean_term)	&&			// AND/OR-Verknuepfung:
				 pNode->count() == 3)
		{
			// nur AND Verkn�pfung zulassen
			if (!SQL_ISTOKEN(pNode->getChild(1),AND))
				eErrorCode = eIllegalJoinCondition;
			else if ( eOk == (eErrorCode = InsertJoinConnection(_pView,pNode->getChild(0), _eJoinType,pLeftTable,pRightTable)) )
					eErrorCode = InsertJoinConnection(_pView,pNode->getChild(2), _eJoinType,pLeftTable,pRightTable);
		}
		else if (SQL_ISRULE(pNode,comparison_predicate))
		{
			// only the comparison of columns is allowed
			DBG_ASSERT(pNode->count() == 3,"OQueryDesignView::InsertJoinConnection: Fehler im Parse Tree");
			if (!(SQL_ISRULE(pNode->getChild(0),column_ref) &&
				  SQL_ISRULE(pNode->getChild(2),column_ref) &&
				   pNode->getChild(1)->getNodeType() == SQL_NODE_EQUAL))
			{
				String sError(ModuleRes(STR_QRY_JOIN_COLUMN_COMPARE));
				_pView->getController().appendError( sError );
				return eIllegalJoin;
			}

			OTableFieldDescRef aDragLeft  = new OTableFieldDesc();
			OTableFieldDescRef aDragRight = new OTableFieldDesc();
			if ( eOk != ( eErrorCode = FillDragInfo(_pView,pNode->getChild(0),aDragLeft)) ||
				eOk != ( eErrorCode = FillDragInfo(_pView,pNode->getChild(2),aDragRight)))
				return eErrorCode;

            if ( pLeftTable )
            {
                OQueryTableWindow*	pLeftWindow = static_cast<OQueryTableView*>(_pView->getTableView())->FindTable( getTableRange(_pView,pLeftTable->getByRule(OSQLParseNode::table_ref) ));
                // OQueryTableWindow*	pRightWindow = static_cast<OQueryTableView*>(_pView->getTableView())->FindTable( getTableRange(_pView,pRightTable->getByRule(OSQLParseNode::table_ref) ));
                if ( pLeftWindow == aDragLeft->GetTabWindow() )
                    insertConnection(_pView,_eJoinType,aDragLeft,aDragRight);
                else
                    insertConnection(_pView,_eJoinType,aDragRight,aDragLeft);
            }
            else
                insertConnection(_pView,_eJoinType,aDragLeft,aDragRight);
		}
		else
			eErrorCode = eIllegalJoin;
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	sal_Bool GetInnerJoinCriteria(	const OQueryDesignView* _pView,
									const ::connectivity::OSQLParseNode *pCondition)
	{
		return InsertJoinConnection(_pView,pCondition, INNER_JOIN,NULL,NULL) != eOk;
	}
	//------------------------------------------------------------------------------
	::rtl::OUString GenerateSelectList(	const OQueryDesignView* _pView,
										OTableFields&	_rFieldList,
										sal_Bool bAlias)
	{
        Reference< XConnection> xConnection = static_cast<OQueryController&>(_pView->getController()).getConnection();
		if ( !xConnection.is() )
			return ::rtl::OUString();

		::rtl::OUStringBuffer aTmpStr,aFieldListStr;

		sal_Bool bAsterix = sal_False;
		int nVis = 0;
		OTableFields::iterator aIter = _rFieldList.begin();
        OTableFields::iterator aEnd = _rFieldList.end();
		for(;aIter != aEnd;++aIter)
		{
			OTableFieldDescRef pEntryField = *aIter;
			if ( pEntryField->IsVisible() )
			{
				if ( pEntryField->GetField().toChar() == '*' )
					bAsterix = sal_True;
				++nVis;
			}
		}
		if(nVis == 1)
			bAsterix = sal_False;

		try
		{
			const Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
			const ::rtl::OUString aQuote = xMetaData->getIdentifierQuoteString();

			OJoinTableView::OTableWindowMap* pTabList = _pView->getTableView()->GetTabWinMap();

			const static ::rtl::OUString sFieldSeparator(RTL_CONSTASCII_USTRINGPARAM(", "));
            const static ::rtl::OUString s_sAs(RTL_CONSTASCII_USTRINGPARAM(" AS "));

			aIter = _rFieldList.begin();
		    for(;aIter != aEnd;++aIter)
			{
				OTableFieldDescRef pEntryField = *aIter;
				::rtl::OUString rFieldName = pEntryField->GetField();
				if ( rFieldName.getLength() && pEntryField->IsVisible() )
				{
					aTmpStr = ::rtl::OUString();
					const ::rtl::OUString rAlias = pEntryField->GetAlias();
					const ::rtl::OUString rFieldAlias = pEntryField->GetFieldAlias();

					aTmpStr.append(quoteTableAlias((bAlias || bAsterix),rAlias,aQuote));

					// if we have a none numeric field, the table alias could be in the name
					// otherwise we are not allowed to do this (e.g. 0.1 * PRICE )
					if  ( !pEntryField->isOtherFunction() )
					{
						// we have to look if we have alias.* here but before we have to check if the column doesn't already exist
						String sTemp = rFieldName;
						OTableFieldDescRef	aInfo = new OTableFieldDesc();
						OJoinTableView::OTableWindowMap::iterator tableIter = pTabList->begin();
                        OJoinTableView::OTableWindowMap::iterator tableEnd = pTabList->end();
						sal_Bool bFound = sal_False;
						for(;!bFound && tableIter != tableEnd ;++tableIter)
						{
							OQueryTableWindow* pTabWin = static_cast<OQueryTableWindow*>(tableIter->second);

                            bFound = pTabWin->ExistsField( rFieldName, aInfo );
							if ( bFound )
								rFieldName = aInfo->GetField();
						}
						if ( ( rFieldName.toChar() != '*' ) && ( rFieldName.indexOf( aQuote ) == -1 ) )
						{
							OSL_ENSURE(pEntryField->GetTable().getLength(),"No table field name!");
							aTmpStr.append(::dbtools::quoteName(aQuote, rFieldName));
						}
						else
							aTmpStr.append(rFieldName);
					}
					else
						aTmpStr.append(rFieldName);

					if  ( pEntryField->isAggreateFunction() )
					{
						DBG_ASSERT(pEntryField->GetFunction().getLength(),"Functionname darf hier nicht leer sein! ;-(");
						::rtl::OUStringBuffer aTmpStr2( pEntryField->GetFunction());
						aTmpStr2.appendAscii("(");
						aTmpStr2.append(aTmpStr.makeStringAndClear());
						aTmpStr2.appendAscii(")");
						aTmpStr = aTmpStr2;
					}

					if (rFieldAlias.getLength()							&&
						(rFieldName.toChar() != '*'						||
						pEntryField->isNumericOrAggreateFunction()		||
						pEntryField->isOtherFunction()))
					{
						aTmpStr.append(s_sAs);
						aTmpStr.append(::dbtools::quoteName(aQuote, rFieldAlias));
					}
					aFieldListStr.append(aTmpStr.makeStringAndClear());
					aFieldListStr.append(sFieldSeparator);
				}
			}
			if(aFieldListStr.getLength())
				aFieldListStr.setLength(aFieldListStr.getLength()-2);
		}
		catch(SQLException&)
		{
			OSL_ASSERT(!"Failure while building select list!");
		}
		return aFieldListStr.makeStringAndClear();
	}
	//------------------------------------------------------------------------------
	sal_Bool GenerateCriterias(	OQueryDesignView* _pView,
								::rtl::OUStringBuffer& rRetStr,
								::rtl::OUStringBuffer& rHavingStr,
								OTableFields& _rFieldList,
								sal_Bool bMulti )
	{
		// * darf keine Filter enthalten : habe ich die entsprechende Warnung schon angezeigt ?
		sal_Bool bCritsOnAsterikWarning = sal_False;		// ** TMFS **

		::rtl::OUString aFieldName,aCriteria,aWhereStr,aHavingStr,aWork/*,aOrderStr*/;
		// Zeilenweise werden die Ausdr"ucke mit AND verknuepft
		sal_uInt16 nMaxCriteria = 0;
		OTableFields::iterator aIter = _rFieldList.begin();
		OTableFields::iterator aEnd = _rFieldList.end();
		for(;aIter != aEnd;++aIter)
		{
			nMaxCriteria = ::std::max<sal_uInt16>(nMaxCriteria,(sal_uInt16)(*aIter)->GetCriteria().size());
		}
		Reference< XConnection> xConnection = static_cast<OQueryController&>(_pView->getController()).getConnection();
		if(!xConnection.is())
			return sal_False;
		try
		{
			const Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
			const ::rtl::OUString aQuote = xMetaData->getIdentifierQuoteString();
			const IParseContext& rContext = static_cast<OQueryController&>(_pView->getController()).getParser().getContext();

			for (sal_uInt16 i=0 ; i < nMaxCriteria ; i++)
			{
				aHavingStr = aWhereStr = ::rtl::OUString();

				for(aIter = _rFieldList.begin();aIter != aEnd;++aIter)
				{
					OTableFieldDescRef	pEntryField = *aIter;
					aFieldName = pEntryField->GetField();

					if (!aFieldName.getLength())
						continue;
					aCriteria = pEntryField->GetCriteria( i );
					if ( aCriteria.getLength() )
					{
						// * is not allowed to contain any filter, only when used in combination an aggregate function
						if ( aFieldName.toChar() == '*' && pEntryField->isNoneFunction() )
						{
							// only show the messagebox the first time
							if (!bCritsOnAsterikWarning)
								ErrorBox(_pView, ModuleRes( ERR_QRY_CRITERIA_ON_ASTERISK)).Execute();
							bCritsOnAsterikWarning = sal_True;
							continue;
						}
						aWork = ::rtl::OUString();


						aWork += quoteTableAlias(bMulti,pEntryField->GetAlias(),aQuote);

						if ( (pEntryField->GetFunctionType() & (FKT_OTHER|FKT_NUMERIC)) || (aFieldName.toChar() == '*') )
							aWork += aFieldName;
						else
							aWork += ::dbtools::quoteName(aQuote, aFieldName);

						if ( pEntryField->isAggreateFunction() || pEntryField->IsGroupBy() )
						{
							if (!aHavingStr.getLength())			// noch keine Kriterien
								aHavingStr += ::rtl::OUString('(');			// Klammern
							else
								aHavingStr += C_AND;

							if ( pEntryField->isAggreateFunction() )
							{
								OSL_ENSURE(pEntryField->GetFunction().getLength(),"No function name for aggregate given!");
								aHavingStr += pEntryField->GetFunction();
								aHavingStr += ::rtl::OUString('(');			// Klammern
								aHavingStr += aWork;
								aHavingStr += ::rtl::OUString(')');			// Klammern
							}
							else
								aHavingStr += aWork;

							::rtl::OUString aTmp = aCriteria;
							::rtl::OUString aErrorMsg;
							Reference<XPropertySet> xColumn;
                            ::std::auto_ptr< ::connectivity::OSQLParseNode> pParseNode(_pView->getPredicateTreeFromEntry(pEntryField,aTmp,aErrorMsg,xColumn));
							if (pParseNode.get())
							{
								if (bMulti && !(pEntryField->isOtherFunction() || (aFieldName.toChar() == '*')))
									pParseNode->replaceNodeValue(pEntryField->GetAlias(),aFieldName);
								::rtl::OUString sHavingStr = aHavingStr;

								sal_uInt32 nCount = pParseNode->count();
								for( sal_uInt32 node = 1 ; node < nCount ; ++node)
									pParseNode->getChild(node)->parseNodeToStr(	sHavingStr,
																xConnection,
																&rContext,
																sal_False,
																!pEntryField->isOtherFunction());
								aHavingStr = sHavingStr;
							}
							else
								aHavingStr += aCriteria;
						}
						else
						{
							if ( !aWhereStr.getLength() )			// noch keine Kriterien
								aWhereStr += ::rtl::OUString('(');			// Klammern
							else
								aWhereStr += C_AND;

							aWhereStr += ::rtl::OUString(' ');
							// aCriteria could have some german numbers so I have to be sure here
							::rtl::OUString aTmp = aCriteria;
							::rtl::OUString aErrorMsg;
							Reference<XPropertySet> xColumn;
							::std::auto_ptr< ::connectivity::OSQLParseNode> pParseNode( _pView->getPredicateTreeFromEntry(pEntryField,aTmp,aErrorMsg,xColumn));
							if (pParseNode.get())
							{
								if (bMulti && !(pEntryField->isOtherFunction() || (aFieldName.toChar() == '*')))
									pParseNode->replaceNodeValue(pEntryField->GetAlias(),aFieldName);
								::rtl::OUString aWhere = aWhereStr;
								pParseNode->parseNodeToStr(	aWhere,
															xConnection,
															&rContext,
															sal_False,
															!pEntryField->isOtherFunction() );
								aWhereStr = aWhere;
							}
							else
							{
								aWhereStr += aWork;
								aWhereStr += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("="));
								aWhereStr += aCriteria;
							}
						}
					}
					// nur einmal f�r jedes Feld
					else if ( !i && pEntryField->isCondition() )
					{
						if (!aWhereStr.getLength())			// noch keine Kriterien
							aWhereStr += ::rtl::OUString('(');			// Klammern
						else
							aWhereStr += C_AND;
						aWhereStr += pEntryField->GetField();
					}
				}
				if (aWhereStr.getLength())
				{
					aWhereStr += ::rtl::OUString(')');						// Klammern zu fuer 'AND' Zweig
					if (rRetStr.getLength())							// schon Feldbedingungen ?
						rRetStr.append(C_OR);
					else										// Klammern auf fuer 'OR' Zweig
						rRetStr.append(sal_Unicode('('));
					rRetStr.append(aWhereStr);
				}
				if (aHavingStr.getLength())
				{
					aHavingStr += ::rtl::OUString(')');						// Klammern zu fuer 'AND' Zweig
					if (rHavingStr.getLength())							// schon Feldbedingungen ?
						rHavingStr.append(C_OR);
					else										// Klammern auf fuer 'OR' Zweig
						rHavingStr.append(sal_Unicode('('));
					rHavingStr.append(aHavingStr);
				}
			}

			if (rRetStr.getLength())
				rRetStr.append(sal_Unicode(')'));								// Klammern zu fuer 'OR' Zweig
			if (rHavingStr.getLength())
				rHavingStr.append(sal_Unicode(')'));								// Klammern zu fuer 'OR' Zweig
		}
		catch(SQLException&)
		{
			OSL_ASSERT(!"Failure while building where clause!");
		}
		return sal_True;
	}
	//------------------------------------------------------------------------------
	SqlParseError GenerateOrder(	OQueryDesignView* _pView,
									OTableFields& _rFieldList,
									sal_Bool bMulti,
									::rtl::OUString& _rsRet)
	{
        const OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
		Reference< XConnection> xConnection = rController.getConnection();
		if ( !xConnection.is() )
			return eNoConnection;

		SqlParseError eErrorCode = eOk;

		::rtl::OUString aColumnName;
		::rtl::OUString aWorkStr;
		try
		{
            const bool bColumnAliasInOrderBy = rController.getSdbMetaData().supportsColumnAliasInOrderBy();
			Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
			::rtl::OUString aQuote = xMetaData->getIdentifierQuoteString();
			// * darf keine Filter enthalten : habe ich die entsprechende Warnung schon angezeigt ?
			sal_Bool bCritsOnAsterikWarning = sal_False;		// ** TMFS **
			OTableFields::iterator aIter = _rFieldList.begin();
			OTableFields::iterator aEnd = _rFieldList.end();
		    for(;aIter != aEnd;++aIter)
			{
				OTableFieldDescRef	pEntryField = *aIter;
				EOrderDir eOrder = pEntryField->GetOrderDir();

				// nur wenn eine Sortierung und ein Tabellenname vorhanden ist-> erzeugen
				// sonst werden die Expressions vom Order By im GenerateCriteria mit erzeugt
				if ( eOrder != ORDER_NONE )
				{
					aColumnName = pEntryField->GetField();
					if(aColumnName.toChar() == '*')
					{
						// die entsprechende MessageBox nur beim ersten mal anzeigen
						if (!bCritsOnAsterikWarning)
							ErrorBox(_pView, ModuleRes( ERR_QRY_ORDERBY_ON_ASTERISK)).Execute();
						bCritsOnAsterikWarning = sal_True;
						continue;
					}

					if ( bColumnAliasInOrderBy && pEntryField->GetFieldAlias().getLength() )
					{
						aWorkStr += ::dbtools::quoteName(aQuote, pEntryField->GetFieldAlias());
					}
					else if ( pEntryField->isNumericOrAggreateFunction() )
					{
						DBG_ASSERT(pEntryField->GetFunction().getLength(),"Functionname darf hier nicht leer sein! ;-(");
						aWorkStr += pEntryField->GetFunction();
						aWorkStr +=  ::rtl::OUString('(');
						aWorkStr += quoteTableAlias(bMulti,pEntryField->GetAlias(),aQuote);
						// only quote column name when we don't have a numeric
						if ( pEntryField->isNumeric() )
							aWorkStr += aColumnName;
						else
							aWorkStr += ::dbtools::quoteName(aQuote, aColumnName);

						aWorkStr +=  ::rtl::OUString(')');
					}
                    else if ( pEntryField->isOtherFunction() )
                    {
                        aWorkStr += aColumnName;
                    }
					else
					{
						aWorkStr += quoteTableAlias(bMulti,pEntryField->GetAlias(),aQuote);
						aWorkStr += ::dbtools::quoteName(aQuote, aColumnName);
					}
					aWorkStr += ::rtl::OUString(' ');
					aWorkStr += String::CreateFromAscii( ";ASC;DESC" ).GetToken( (sal_uInt16)eOrder );
					aWorkStr += ::rtl::OUString(',');
				}
			}

			{
				String sTemp(aWorkStr);
				sTemp.EraseTrailingChars( ',' );
				aWorkStr = sTemp;
			}

			if ( aWorkStr.getLength() )
			{
				const sal_Int32 nMaxOrder = xMetaData->getMaxColumnsInOrderBy();
				String sToken(aWorkStr);
				if ( nMaxOrder && nMaxOrder < sToken.GetTokenCount(',') )
					eErrorCode = eStatementTooLong;
				else
				{
					_rsRet = ::rtl::OUString::createFromAscii(" ORDER BY ");
					_rsRet += aWorkStr;
				}
			}
		}
		catch(SQLException&)
		{
			OSL_ASSERT(!"Failure while building group by!");
		}

		return eErrorCode;
	}

	//------------------------------------------------------------------------------
	void GenerateInnerJoinCriterias(const Reference< XConnection>& _xConnection,
									::rtl::OUString& _rJoinCrit,
									const ::std::vector<OTableConnection*>* _pConnList)
	{
		::std::vector<OTableConnection*>::const_iterator aIter = _pConnList->begin();
        ::std::vector<OTableConnection*>::const_iterator aEnd = _pConnList->end();
		for(;aIter != aEnd;++aIter)
		{
			const OQueryTableConnection* pEntryConn = static_cast<const OQueryTableConnection*>(*aIter);
			OQueryTableConnectionData* pEntryConnData = static_cast<OQueryTableConnectionData*>(pEntryConn->GetData().get());
            if ( pEntryConnData->GetJoinType() == INNER_JOIN && !pEntryConnData->isNatural() )
			{
				if(_rJoinCrit.getLength())
					_rJoinCrit += C_AND;
				_rJoinCrit += BuildJoinCriteria(_xConnection,pEntryConnData->GetConnLineDataList(),pEntryConnData);
			}
		}
	}
	//------------------------------------------------------------------------------
	void searchAndAppendName(const Reference< XConnection>& _xConnection,
							 const OQueryTableWindow* _pTableWindow,
							 ::std::map< ::rtl::OUString,sal_Bool,::comphelper::UStringMixLess>& _rTableNames,
							 ::rtl::OUString& _rsTableListStr
							 )
	{
		::rtl::OUString sTabName(BuildTable(_xConnection,_pTableWindow));

		if(_rTableNames.find(sTabName) == _rTableNames.end())
		{
			_rTableNames[sTabName] = sal_True;
			_rsTableListStr += sTabName;
			_rsTableListStr += ::rtl::OUString(',');
		}
	}
	//------------------------------------------------------------------------------
	::rtl::OUString GenerateFromClause(	const Reference< XConnection>& _xConnection,
										const OQueryTableView::OTableWindowMap*	pTabList,
										const ::std::vector<OTableConnection*>*	pConnList
										)
	{

		::rtl::OUString aTableListStr;
		// wird gebraucht um sicher zustelllen das eine Tabelle nicht doppelt vorkommt
		::std::map< ::rtl::OUString,sal_Bool,::comphelper::UStringMixLess> aTableNames;

		// generate outer join clause in from
		if(!pConnList->empty())
		{
			::std::vector<OTableConnection*>::const_iterator aIter = pConnList->begin();
            ::std::vector<OTableConnection*>::const_iterator aEnd = pConnList->end();
            ::std::map<OTableWindow*,sal_Int32> aConnectionCount;
			for(;aIter != aEnd;++aIter)
            {
				static_cast<OQueryTableConnection*>(*aIter)->SetVisited(sal_False);
                if ( aConnectionCount.find((*aIter)->GetSourceWin()) == aConnectionCount.end() )
                    aConnectionCount.insert(::std::map<OTableWindow*,sal_Int32>::value_type((*aIter)->GetSourceWin(),0));
                else
                    aConnectionCount[(*aIter)->GetSourceWin()]++;
                if ( aConnectionCount.find((*aIter)->GetDestWin()) == aConnectionCount.end() )
                    aConnectionCount.insert(::std::map<OTableWindow*,sal_Int32>::value_type((*aIter)->GetDestWin(),0));
                else
                    aConnectionCount[(*aIter)->GetDestWin()]++;
            }
            ::std::multimap<sal_Int32 , OTableWindow*> aMulti;
            ::std::map<OTableWindow*,sal_Int32>::iterator aCountIter = aConnectionCount.begin();
            ::std::map<OTableWindow*,sal_Int32>::iterator aCountEnd = aConnectionCount.end();
            for(;aCountIter != aCountEnd;++aCountIter)
            {
                aMulti.insert(::std::multimap<sal_Int32 , OTableWindow*>::value_type(aCountIter->second,aCountIter->first));
            }

            const sal_Bool bUseEscape = ::dbtools::getBooleanDataSourceSetting( _xConnection, PROPERTY_OUTERJOINESCAPE );
            ::std::multimap<sal_Int32 , OTableWindow*>::reverse_iterator aRIter = aMulti.rbegin();
            ::std::multimap<sal_Int32 , OTableWindow*>::reverse_iterator aREnd = aMulti.rend();
            for(;aRIter != aREnd;++aRIter)
            {
                ::std::vector<OTableConnection*>::const_iterator aConIter = aRIter->second->getTableView()->getTableConnections(aRIter->second);
                for(;aConIter != aEnd;++aConIter)
                {
                    OQueryTableConnection* pEntryConn = static_cast<OQueryTableConnection*>(*aConIter);
				    if(!pEntryConn->IsVisited() && pEntryConn->GetSourceWin() == aRIter->second )
				    {
					    ::rtl::OUString aJoin;
					    GetNextJoin(_xConnection,pEntryConn,static_cast<OQueryTableWindow*>(pEntryConn->GetDestWin()),aJoin);

					    if(aJoin.getLength())
					    {
						    // insert tables into table list to avoid double entries
						    OQueryTableWindow* pEntryTabFrom = static_cast<OQueryTableWindow*>(pEntryConn->GetSourceWin());
						    OQueryTableWindow* pEntryTabTo = static_cast<OQueryTableWindow*>(pEntryConn->GetDestWin());

						    ::rtl::OUString sTabName(BuildTable(_xConnection,pEntryTabFrom));
						    if(aTableNames.find(sTabName) == aTableNames.end())
							    aTableNames[sTabName] = sal_True;
						    sTabName = BuildTable(_xConnection,pEntryTabTo);
						    if(aTableNames.find(sTabName) == aTableNames.end())
							    aTableNames[sTabName] = sal_True;

                            ::rtl::OUString aStr;
                            switch(static_cast<OQueryTableConnectionData*>(pEntryConn->GetData().get())->GetJoinType())
		                    {
			                    case LEFT_JOIN:
			                    case RIGHT_JOIN:
                                case FULL_JOIN:
                                    {
						                // create outer join
						                if ( bUseEscape )
							                aStr += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("{ OJ "));
						                aStr += aJoin;
						                if ( bUseEscape )
							                aStr += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" }"));
                                    }
                                    break;
                                default:
                                    aStr += aJoin;
                                    break;
                            }
						    aStr += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(","));
						    aTableListStr += aStr;
					    }
				    }
			    }
            }

			// and now all inner joins
			aIter = pConnList->begin();
			for(;aIter != aEnd;++aIter)
			{
				OQueryTableConnection* pEntryConn = static_cast<OQueryTableConnection*>(*aIter);
				if(!pEntryConn->IsVisited())
				{
					searchAndAppendName(_xConnection,
										static_cast<OQueryTableWindow*>(pEntryConn->GetSourceWin()),
										aTableNames,
										aTableListStr);

					searchAndAppendName(_xConnection,
										static_cast<OQueryTableWindow*>(pEntryConn->GetDestWin()),
										aTableNames,
										aTableListStr);
				}
			}
		}
		// all tables that haven't a connection to anyone
		OQueryTableView::OTableWindowMap::const_iterator aTabIter = pTabList->begin();
        OQueryTableView::OTableWindowMap::const_iterator aTabEnd = pTabList->end();
		for(;aTabIter != aTabEnd;++aTabIter)
		{
			const OQueryTableWindow* pEntryTab = static_cast<const OQueryTableWindow*>(aTabIter->second);
			if(!pEntryTab->ExistsAConn())
			{
				aTableListStr += BuildTable(_xConnection,pEntryTab);
				aTableListStr += ::rtl::OUString(',');
			}
		}

		if(aTableListStr.getLength())
			aTableListStr = aTableListStr.replaceAt(aTableListStr.getLength()-1,1, ::rtl::OUString() );
		return aTableListStr;
	}
	//------------------------------------------------------------------------------
	::rtl::OUString GenerateGroupBy(const OQueryDesignView* _pView,OTableFields& _rFieldList, sal_Bool bMulti )
	{
        OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
		const Reference< XConnection> xConnection = rController.getConnection();
		if(!xConnection.is())
			return ::rtl::OUString();

        ::std::map< rtl::OUString,bool> aGroupByNames;

		::rtl::OUString aGroupByStr;
		try
		{
			const Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
			const ::rtl::OUString aQuote = xMetaData->getIdentifierQuoteString();

			OTableFields::iterator aIter = _rFieldList.begin();
			OTableFields::iterator aEnd = _rFieldList.end();
		    for(;aIter != aEnd;++aIter)
			{
				OTableFieldDescRef	pEntryField = *aIter;
				if ( pEntryField->IsGroupBy() )
				{
					DBG_ASSERT(pEntryField->GetField().getLength(),"Kein FieldName vorhanden!;-(");
					::rtl::OUString sGroupByPart = quoteTableAlias(bMulti,pEntryField->GetAlias(),aQuote);

					// only quote the field name when it isn't calculated
					if ( pEntryField->isNoneFunction() )
                    {
						sGroupByPart += ::dbtools::quoteName(aQuote, pEntryField->GetField());
                    }
					else
                    {
                        ::rtl::OUString aTmp = pEntryField->GetField();
						::rtl::OUString aErrorMsg;
						Reference<XPropertySet> xColumn;
                        ::std::auto_ptr< ::connectivity::OSQLParseNode> pParseNode(_pView->getPredicateTreeFromEntry(pEntryField,aTmp,aErrorMsg,xColumn));
						if (pParseNode.get())
						{
							::rtl::OUString sGroupBy;
							pParseNode->getChild(0)->parseNodeToStr(	sGroupBy,
														xConnection,
														&rController.getParser().getContext(),
														sal_False,
														!pEntryField->isOtherFunction());
							sGroupByPart += sGroupBy;
						}
						else
							sGroupByPart += pEntryField->GetField();
                    }
                    if ( aGroupByNames.find(sGroupByPart) == aGroupByNames.end() )
                    {
                        aGroupByNames.insert(::std::map< rtl::OUString,bool>::value_type(sGroupByPart,true));
                        aGroupByStr += sGroupByPart;
					    aGroupByStr += ::rtl::OUString(',');
                    }
				}
			}
			if ( aGroupByStr.getLength() )
			{
				aGroupByStr = aGroupByStr.replaceAt(aGroupByStr.getLength()-1,1, ::rtl::OUString(' ') );
				::rtl::OUString aGroupByStr2 = ::rtl::OUString::createFromAscii(" GROUP BY ");
				aGroupByStr2 += aGroupByStr;
				aGroupByStr = aGroupByStr2;
			}
		}
		catch(SQLException&)
		{
			OSL_ASSERT(!"Failure while building group by!");
		}
		return aGroupByStr;
	}
	// -----------------------------------------------------------------------------
	SqlParseError GetORCriteria(OQueryDesignView* _pView,
								OSelectionBrowseBox* _pSelectionBrw,
								const ::connectivity::OSQLParseNode * pCondition,
								sal_uInt16& nLevel ,
								sal_Bool bHaving = sal_False,
                                bool bAddOrOnOneLine = false);
	// -----------------------------------------------------------------------------
	SqlParseError GetSelectionCriteria(	OQueryDesignView* _pView,
										OSelectionBrowseBox* _pSelectionBrw,
										const ::connectivity::OSQLParseNode* pNode,
										sal_uInt16& rLevel )
	{
		if (!SQL_ISRULE(pNode, select_statement))
			return eNoSelectStatement;

		// nyi: mehr Pruefung auf korrekte Struktur!
		pNode = pNode ? pNode->getChild(3)->getChild(1) : NULL;
		// no where clause found
		if (!pNode || pNode->isLeaf())
			return eOk;

		// Naechster freier Satz ...
		SqlParseError eErrorCode = eOk;
		::connectivity::OSQLParseNode * pCondition = pNode->getChild(1);
		if ( pCondition ) // no where clause
		{
			// now we have to chech the other conditions
			// first make the logical easier
			::connectivity::OSQLParseNode::negateSearchCondition(pCondition);
			::connectivity::OSQLParseNode *pNodeTmp = pNode->getChild(1);

			::connectivity::OSQLParseNode::disjunctiveNormalForm(pNodeTmp);
			pNodeTmp = pNode->getChild(1);
			::connectivity::OSQLParseNode::absorptions(pNodeTmp);
			pNodeTmp = pNode->getChild(1);
            // compress sort the criteria @see http://www.openoffice.org/issues/show_bug.cgi?id=24079
            OSQLParseNode::compress(pNodeTmp);
            pNodeTmp = pNode->getChild(1);

			// first extract the inner joins conditions
			GetInnerJoinCriteria(_pView,pNodeTmp);
			// now simplify again, join are checked in ComparisonPredicate
			::connectivity::OSQLParseNode::absorptions(pNodeTmp);
			pNodeTmp = pNode->getChild(1);

			// it could happen that pCondition is not more valid
			eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pNodeTmp, rLevel);
		}
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError GetANDCriteria(	OQueryDesignView* _pView,
									OSelectionBrowseBox* _pSelectionBrw,
									const  ::connectivity::OSQLParseNode * pCondition,
									sal_uInt16& nLevel,
									sal_Bool bHaving,
                                    bool bAddOrOnOneLine);
	//------------------------------------------------------------------------------
	SqlParseError ComparisonPredicate(OQueryDesignView* _pView,
							OSelectionBrowseBox* _pSelectionBrw,
							const ::connectivity::OSQLParseNode * pCondition,
							const sal_uInt16 nLevel,
							sal_Bool bHaving,
                            bool bAddOrOnOneLine);
	//------------------------------------------------------------------------------
	SqlParseError GetORCriteria(OQueryDesignView* _pView,
								OSelectionBrowseBox* _pSelectionBrw,
								const ::connectivity::OSQLParseNode * pCondition,
								sal_uInt16& nLevel ,
								sal_Bool bHaving,
                                bool bAddOrOnOneLine)
	{
		SqlParseError eErrorCode = eOk;

		// Runde Klammern um den Ausdruck
		if (pCondition->count() == 3 &&
			SQL_ISPUNCTUATION(pCondition->getChild(0),"(") &&
			SQL_ISPUNCTUATION(pCondition->getChild(2),")"))
		{
			eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pCondition->getChild(1),nLevel,bHaving,bAddOrOnOneLine);
		}
		// oder Verknuepfung
		// a searchcondition can only look like this: search_condition SQL_TOKEN_OR boolean_term
		else if (SQL_ISRULE(pCondition,search_condition))
		{
			for (int i = 0; i < 3 && eErrorCode == eOk ; i+=2)
			{
                const  ::connectivity::OSQLParseNode* pChild = pCondition->getChild(i);
				if ( SQL_ISRULE(pChild,search_condition) )
					eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pChild,nLevel,bHaving,bAddOrOnOneLine);
				else
				{
                    eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pChild, nLevel,bHaving, i == 0 ? false : bAddOrOnOneLine);
					if ( !bAddOrOnOneLine)
						nLevel++;
				}
			}
		}
		else
			eErrorCode = GetANDCriteria( _pView,_pSelectionBrw,pCondition, nLevel, bHaving,bAddOrOnOneLine );

		return eErrorCode;
	}
    //--------------------------------------------------------------------------------------------------
    bool CheckOrCriteria(const ::connectivity::OSQLParseNode* _pCondition,::connectivity::OSQLParseNode* _pFirstColumnRef)
    {
        bool bRet = true;
        ::connectivity::OSQLParseNode* pFirstColumnRef = _pFirstColumnRef;
        for (int i = 0; i < 3 && bRet; i+=2)
		{
            const  ::connectivity::OSQLParseNode* pChild = _pCondition->getChild(i);
            if ( SQL_ISRULE(pChild,search_condition) )
                bRet = CheckOrCriteria(pChild,pFirstColumnRef);
            else
            {
                // this is a simple way to test columns are the same, may be we have to adjust this algo a little bit in future. :-)
                ::connectivity::OSQLParseNode* pSecondColumnRef = pChild->getByRule(::connectivity::OSQLParseNode::column_ref);
                if ( pFirstColumnRef && pSecondColumnRef )
                    bRet = *pFirstColumnRef == *pSecondColumnRef;
                else if ( !pFirstColumnRef )
                    pFirstColumnRef = pSecondColumnRef;
            }
        }
        return bRet;
    }
	//--------------------------------------------------------------------------------------------------
	SqlParseError GetANDCriteria(	OQueryDesignView* _pView,
									OSelectionBrowseBox* _pSelectionBrw,
									const  ::connectivity::OSQLParseNode * pCondition,
									sal_uInt16& nLevel,
									sal_Bool bHaving,
                                    bool bAddOrOnOneLine)
	{
		const ::com::sun::star::lang::Locale	aLocale = _pView->getLocale();
		const ::rtl::OUString sDecimal = _pView->getDecimalSeparator();

		// ich werde ein paar Mal einen gecasteten Pointer auf meinen ::com::sun::star::sdbcx::Container brauchen
		OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
		SqlParseError eErrorCode = eOk;

		// Runde Klammern
		if (SQL_ISRULE(pCondition,boolean_primary))
		{
            // check if we have to put the or criteria on one line.
			const  ::connectivity::OSQLParseNode* pSearchCondition = pCondition->getChild(1);
            bool bMustAddOrOnOneLine = CheckOrCriteria(pSearchCondition,NULL);
			if ( SQL_ISRULE( pSearchCondition, search_condition) ) // we have a or
			{
				_pSelectionBrw->DuplicateConditionLevel( nLevel);
				eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pSearchCondition->getChild(0), nLevel,bHaving,bMustAddOrOnOneLine );
				++nLevel;
				eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pSearchCondition->getChild(2), nLevel,bHaving,bMustAddOrOnOneLine );
			}
			else
				eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pSearchCondition, nLevel,bHaving,bMustAddOrOnOneLine );
		}
		// Das erste Element ist (wieder) eine AND-Verknuepfung
		else if ( SQL_ISRULE(pCondition,boolean_term) )
		{
            OSL_ENSURE(pCondition->count() == 3,"Illegal definifiton of boolean_term");
			eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pCondition->getChild(0), nLevel,bHaving,bAddOrOnOneLine );
			if ( eErrorCode == eOk )
				eErrorCode = GetANDCriteria(_pView,_pSelectionBrw,pCondition->getChild(2), nLevel,bHaving,bAddOrOnOneLine );
		}
		else if (SQL_ISRULE( pCondition, comparison_predicate))
		{
			eErrorCode = ComparisonPredicate(_pView,_pSelectionBrw,pCondition,nLevel,bHaving,bAddOrOnOneLine);
		}
		else if( SQL_ISRULE(pCondition,like_predicate) )
		{
            const  ::connectivity::OSQLParseNode* pValueExp = pCondition->getChild(0);
			if (SQL_ISRULE(pValueExp, column_ref ) )
			{
				::rtl::OUString aColumnName;
				::rtl::OUString	aCondition;
				Reference< XConnection> xConnection = rController.getConnection();
				if ( xConnection.is() )
				{
					Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
					// the international doesn't matter I have a string
					pCondition->parseNodeToPredicateStr(aCondition,
														xConnection,
														rController.getNumberFormatter(),
														aLocale,
														static_cast<sal_Char>(sDecimal.toChar()),
														&rController.getParser().getContext());

					pValueExp->parseNodeToPredicateStr(	aColumnName,
														xConnection,
														rController.getNumberFormatter(),
														aLocale,
														static_cast<sal_Char>(sDecimal.toChar()),
														&rController.getParser().getContext());

					// don't display the column name
					aCondition = aCondition.copy(aColumnName.getLength());
					aCondition = aCondition.trim();
				}

				OTableFieldDescRef aDragLeft = new OTableFieldDesc();
				if ( eOk == ( eErrorCode = FillDragInfo(_pView,pValueExp,aDragLeft) ))
                {
                    if ( bHaving )
					    aDragLeft->SetGroupBy(sal_True);
					_pSelectionBrw->AddCondition(aDragLeft, aCondition, nLevel,bAddOrOnOneLine);
                }
			}
            else if(SQL_ISRULEOR2(pValueExp,general_set_fct ,set_fct_spec)	        ||
							SQL_ISRULEOR2(pValueExp,position_exp,extract_exp)	||
							SQL_ISRULEOR2(pValueExp,fold,char_substring_fct)	||
							SQL_ISRULEOR2(pValueExp,length_exp,char_value_fct))
		    {
			    AddFunctionCondition(	_pView,
									    _pSelectionBrw,
									    pCondition,
									    nLevel,
									    bHaving,
                                        bAddOrOnOneLine);
		    }
			else
			{
				eErrorCode = eNoColumnInLike;
				String sError(ModuleRes(STR_QRY_LIKE_LEFT_NO_COLUMN));
				_pView->getController().appendError( sError );
			}
		}
		else if(	SQL_ISRULEOR2(pCondition,test_for_null,in_predicate)
				||	SQL_ISRULEOR2(pCondition,all_or_any_predicate,between_predicate))
		{
			if ( SQL_ISRULEOR2(pCondition->getChild(0), set_fct_spec , general_set_fct ) )
			{
				AddFunctionCondition(	_pView,
										_pSelectionBrw,
										pCondition,
										nLevel,
										bHaving,
                                        bAddOrOnOneLine);
			}
			else if ( SQL_ISRULE(pCondition->getChild(0), column_ref ) )
			{
				// parse condition
				::rtl::OUString sCondition = ParseCondition(rController,pCondition,sDecimal,aLocale,1);
				OTableFieldDescRef	aDragLeft = new OTableFieldDesc();
				if ( eOk == ( eErrorCode = FillDragInfo(_pView,pCondition->getChild(0),aDragLeft)) )
                {
                    if ( bHaving )
					    aDragLeft->SetGroupBy(sal_True);
					_pSelectionBrw->AddCondition(aDragLeft, sCondition, nLevel,bAddOrOnOneLine);
                }
			}
			else
			{
				// Funktions-Bedingung parsen
				::rtl::OUString	sCondition = ParseCondition(rController,pCondition,sDecimal,aLocale,1);
				Reference< XConnection> xConnection = rController.getConnection();
				Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
					// the international doesn't matter I have a string
				::rtl::OUString sName;
				pCondition->getChild(0)->parseNodeToPredicateStr(sName,
													xConnection,
													rController.getNumberFormatter(),
													aLocale,
													static_cast<sal_Char>(sDecimal.toChar()),
													&rController.getParser().getContext());

				OTableFieldDescRef aDragLeft = new OTableFieldDesc();
				aDragLeft->SetField(sName);
				aDragLeft->SetFunctionType(FKT_OTHER);

				if ( bHaving )
					aDragLeft->SetGroupBy(sal_True);
				_pSelectionBrw->AddCondition(aDragLeft, sCondition, nLevel,bAddOrOnOneLine);
			}
		}
		else if( SQL_ISRULEOR2(pCondition,existence_test,unique_test) )
		{
			// Funktions-Bedingung parsen
			::rtl::OUString	aCondition = ParseCondition(rController,pCondition,sDecimal,aLocale,0);

			OTableFieldDescRef aDragLeft = new OTableFieldDesc();
			aDragLeft->SetField(aCondition);
			aDragLeft->SetFunctionType(FKT_CONDITION);

			eErrorCode = _pSelectionBrw->InsertField(aDragLeft,BROWSER_INVALIDID,sal_False,sal_True).isValid() ? eOk : eTooManyColumns;
		}
		else //! TODO not supported yet
			eErrorCode = eStatementTooComplex;
		// Fehler einfach weiterreichen.
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError AddFunctionCondition(OQueryDesignView* _pView,
							OSelectionBrowseBox* _pSelectionBrw,
							const ::connectivity::OSQLParseNode * pCondition,
							const sal_uInt16 nLevel,
							sal_Bool bHaving,
                            bool bAddOrOnOneLine)
	{
		SqlParseError eErrorCode = eOk;
		OQueryController& rController = static_cast<OQueryController&>(_pView->getController());

        OSQLParseNode* pFunction = pCondition->getChild(0);

        OSL_ENSURE(SQL_ISRULEOR2(pFunction,general_set_fct ,set_fct_spec)	        ||
							SQL_ISRULEOR2(pFunction,position_exp,extract_exp)	||
							SQL_ISRULEOR2(pFunction,fold,char_substring_fct)	||
							SQL_ISRULEOR2(pFunction,length_exp,char_value_fct),"Illegal call!");
		::rtl::OUString	aCondition;
		OTableFieldDescRef aDragLeft = new OTableFieldDesc();

		::rtl::OUString aColumnName;
		Reference< XConnection> xConnection = rController.getConnection();
		if(xConnection.is())
		{
			Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
			pCondition->parseNodeToPredicateStr(aCondition,
												xConnection,
												rController.getNumberFormatter(),
												_pView->getLocale(),
												static_cast<sal_Char>(_pView->getDecimalSeparator().toChar()),
												&rController.getParser().getContext());

            pFunction->parseNodeToStr(	aColumnName,
										xConnection,
										&rController.getParser().getContext(),
										sal_True,
										sal_True); // quote is to true because we need quoted elements inside the function
            // i75557
			//pFunction->parseNodeToPredicateStr(aColumnName,
			//									xConnection,
			//									rController.getNumberFormatter(),
			//									_pView->getLocale(),
			//									static_cast<sal_Char>(_pView->getDecimalSeparator().toChar()),
			//									&rController.getParser().getContext());
			// don't display the column name
			aCondition = aCondition.copy(aColumnName.getLength());
			aCondition = aCondition.trim();
			if ( aCondition.indexOf('=',0) == 0 ) // ignore the equal sign
				aCondition = aCondition.copy(1);


			if ( SQL_ISRULE(pFunction, general_set_fct ) )
			{
				sal_Int32 nFunctionType = FKT_AGGREGATE;
				OSQLParseNode* pParamNode = pFunction->getChild(pFunction->count()-2);
				if ( pParamNode && pParamNode->getTokenValue().toChar() == '*' )
				{
					OJoinTableView::OTableWindowMap* pTabList = _pView->getTableView()->GetTabWinMap();
					OJoinTableView::OTableWindowMap::iterator aIter = pTabList->begin();
                    OJoinTableView::OTableWindowMap::iterator aTabEnd = pTabList->end();
					for(;aIter != aTabEnd;++aIter)
					{
						OQueryTableWindow* pTabWin = static_cast<OQueryTableWindow*>(aIter->second);
						if (pTabWin->ExistsField( ::rtl::OUString::createFromAscii("*"), aDragLeft ))
						{
							aDragLeft->SetAlias(String());
							aDragLeft->SetTable(String());
							break;
						}
					}
				}
				else if( eOk != ( eErrorCode = FillDragInfo(_pView,pParamNode,aDragLeft))
						&& SQL_ISRULE(pParamNode,num_value_exp) )
				{
					::rtl::OUString sParameterValue;
					pParamNode->parseNodeToStr(	sParameterValue,
												xConnection,
												&rController.getParser().getContext());
					nFunctionType |= FKT_NUMERIC;
					aDragLeft->SetField(sParameterValue);
					eErrorCode = eOk;
				}
				aDragLeft->SetFunctionType(nFunctionType);
				if ( bHaving )
					aDragLeft->SetGroupBy(sal_True);
				sal_Int32 nIndex = 0;
				aDragLeft->SetFunction(aColumnName.getToken(0,'(',nIndex));
			}
			else
			{
				// bei unbekannten Funktionen wird der gesamte Text in das Field gechrieben
				aDragLeft->SetField(aColumnName);
				if(bHaving)
					aDragLeft->SetGroupBy(sal_True);
				aDragLeft->SetFunctionType(FKT_OTHER|FKT_NUMERIC);
			}
			_pSelectionBrw->AddCondition(aDragLeft, aCondition, nLevel,bAddOrOnOneLine);
		}

		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError ComparisonPredicate(OQueryDesignView* _pView,
							OSelectionBrowseBox* _pSelectionBrw,
							const ::connectivity::OSQLParseNode * pCondition,
							const sal_uInt16 nLevel,
							sal_Bool bHaving
                            ,bool bAddOrOnOneLine)
	{
		SqlParseError eErrorCode = eOk;
		OQueryController& rController = static_cast<OQueryController&>(_pView->getController());

		DBG_ASSERT(SQL_ISRULE( pCondition, comparison_predicate),"ComparisonPredicate: pCondition ist kein ComparisonPredicate");
		if ( SQL_ISRULE(pCondition->getChild(0), column_ref )
			|| SQL_ISRULE(pCondition->getChild(pCondition->count()-1), column_ref) )
		{
			::rtl::OUString	aCondition;
			OTableFieldDescRef aDragLeft = new OTableFieldDesc();

			if ( SQL_ISRULE(pCondition->getChild(0), column_ref ) && SQL_ISRULE(pCondition->getChild(pCondition->count()-1), column_ref ) )
			{
				OTableFieldDescRef aDragRight = new OTableFieldDesc();
				if (eOk != ( eErrorCode = FillDragInfo(_pView,pCondition->getChild(0),aDragLeft)) ||
					eOk != ( eErrorCode = FillDragInfo(_pView,pCondition->getChild(2),aDragRight)))
					return eErrorCode;

                OQueryTableConnection* pConn = static_cast<OQueryTableConnection*>(
                                                    _pView->getTableView()->GetTabConn(static_cast<OQueryTableWindow*>(aDragLeft->GetTabWindow()),
																					   static_cast<OQueryTableWindow*>(aDragRight->GetTabWindow()),
                                                                                       true));
				if ( pConn )
				{
					OConnectionLineDataVec* pLineDataList = pConn->GetData()->GetConnLineDataList();
					OConnectionLineDataVec::iterator aIter = pLineDataList->begin();
                    OConnectionLineDataVec::iterator aEnd = pLineDataList->end();
					for(;aIter != aEnd;++aIter)
					{
						if((*aIter)->GetSourceFieldName() == aDragLeft->GetField() ||
						   (*aIter)->GetDestFieldName() == aDragLeft->GetField() )
							break;
					}
					if(aIter != aEnd)
						return eOk;
				}
			}

			sal_uInt32 nPos = 0;
			if(SQL_ISRULE(pCondition->getChild(0), column_ref ))
			{
				nPos = 0;
				sal_uInt32 i=1;

				// don't display the equal
				if (pCondition->getChild(i)->getNodeType() == SQL_NODE_EQUAL)
					i++;

				// Bedingung parsen
				aCondition = ParseCondition(rController
											,pCondition
											,_pView->getDecimalSeparator()
											,_pView->getLocale()
											,i);
			}
			else if( SQL_ISRULE(pCondition->getChild(pCondition->count()-1), column_ref ) )
			{
				nPos = pCondition->count()-1;

				sal_Int32 i = static_cast<sal_Int32>(pCondition->count() - 2);
				switch (pCondition->getChild(i)->getNodeType())
				{
					case SQL_NODE_EQUAL:
						// don't display the equal
						i--;
						break;
					case SQL_NODE_LESS:
						// take the opposite as we change the order
						i--;
						aCondition = aCondition + ::rtl::OUString::createFromAscii(">");
						break;
					case SQL_NODE_LESSEQ:
						// take the opposite as we change the order
						i--;
						aCondition = aCondition + ::rtl::OUString::createFromAscii(">=");
						break;
					case SQL_NODE_GREAT:
						// take the opposite as we change the order
						i--;
						aCondition = aCondition + ::rtl::OUString::createFromAscii("<");
						break;
					case SQL_NODE_GREATEQ:
						// take the opposite as we change the order
						i--;
						aCondition = aCondition + ::rtl::OUString::createFromAscii("<=");
						break;
                    default:
                        break;
				}

				// go backward
				Reference< XConnection> xConnection = rController.getConnection();
				if(xConnection.is())
				{
					Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
					for (; i >= 0; i--)
						pCondition->getChild(i)->parseNodeToPredicateStr(aCondition,
												xConnection,
												rController.getNumberFormatter(),
												_pView->getLocale(),
												static_cast<sal_Char>(_pView->getDecimalSeparator().toChar()),
												&rController.getParser().getContext());
				}
			}
			// else ???


			if( eOk == ( eErrorCode = FillDragInfo(_pView,pCondition->getChild(nPos),aDragLeft)))
			{
				if(bHaving)
					aDragLeft->SetGroupBy(sal_True);
				_pSelectionBrw->AddCondition(aDragLeft, aCondition, nLevel,bAddOrOnOneLine);
			}
		}
		else if( SQL_ISRULEOR2(pCondition->getChild(0), set_fct_spec , general_set_fct ) )
		{
			AddFunctionCondition(	_pView,
									_pSelectionBrw,
									pCondition,
									nLevel,
									bHaving,
                                    bAddOrOnOneLine);
		}
		else // kann sich nur um einen Expr. Ausdruck handeln
		{
			::rtl::OUString aName,aCondition;

			::connectivity::OSQLParseNode *pLhs = pCondition->getChild(0);
			::connectivity::OSQLParseNode *pRhs = pCondition->getChild(2);
			// Feldnamen
			Reference< XConnection> xConnection = rController.getConnection();
			if(xConnection.is())
			{
				pLhs->parseNodeToStr(aName,
									 xConnection,
									 &rController.getParser().getContext(),
									 sal_True);
				// Kriterium
				aCondition = pCondition->getChild(1)->getTokenValue();
				pRhs->parseNodeToPredicateStr(aCondition,
															xConnection,
															rController.getNumberFormatter(),
															_pView->getLocale(),
															static_cast<sal_Char>(_pView->getDecimalSeparator().toChar()),
															&rController.getParser().getContext());
			}

			OTableFieldDescRef aDragLeft = new OTableFieldDesc();
			aDragLeft->SetField(aName);
			aDragLeft->SetFunctionType(FKT_OTHER|FKT_NUMERIC);
			// und anh"angen
			_pSelectionBrw->AddCondition(aDragLeft, aCondition, nLevel,bAddOrOnOneLine);
		}
		return eErrorCode;
	}

    //------------------------------------------------------------------------------
    namespace
    {
        OQueryTableWindow* lcl_findColumnInTables( const ::rtl::OUString& _rColumName, const OJoinTableView::OTableWindowMap& _rTabList, OTableFieldDescRef& _rInfo )
        {
			OJoinTableView::OTableWindowMap::const_iterator aIter = _rTabList.begin();
            OJoinTableView::OTableWindowMap::const_iterator aEnd = _rTabList.end();
			for ( ; aIter != aEnd; ++aIter )
			{
				OQueryTableWindow* pTabWin = static_cast< OQueryTableWindow* >( aIter->second );
				if ( pTabWin && pTabWin->ExistsField( _rColumName, _rInfo ) )
					return pTabWin;
			}
            return NULL;
        }
    }

    //------------------------------------------------------------------------------
	void InsertColumnRef(const OQueryDesignView* _pView,
						const ::connectivity::OSQLParseNode * pColumnRef,
						::rtl::OUString& aColumnName,
						const ::rtl::OUString& aColumnAlias,
						::rtl::OUString& aTableRange,
						OTableFieldDescRef& _raInfo,
						OJoinTableView::OTableWindowMap* pTabList)
	{

		// Tabellennamen zusammen setzen
		::connectivity::OSQLParseTreeIterator& rParseIter = static_cast<OQueryController&>(_pView->getController()).getParseIterator();
		rParseIter.getColumnRange( pColumnRef, aColumnName, aTableRange );

		sal_Bool bFound(sal_False);
		DBG_ASSERT(aColumnName.getLength(),"Columnname darf nicht leer sein");
		if (!aTableRange.getLength())
		{
			// SELECT column, ...
            bFound = NULL != lcl_findColumnInTables( aColumnName, *pTabList, _raInfo );
			if ( bFound && ( aColumnName.toChar() != '*' ) )
				_raInfo->SetFieldAlias(aColumnAlias);
		}
		else
		{
			// SELECT range.column, ...
			OQueryTableWindow* pTabWin = static_cast<OQueryTableView*>(_pView->getTableView())->FindTable(aTableRange);

			if (pTabWin && pTabWin->ExistsField(aColumnName, _raInfo))
			{
				if(aColumnName.toChar() != '*')
					_raInfo->SetFieldAlias(aColumnAlias);
				bFound = sal_True;
			}
		}
		if (!bFound)
		{
			_raInfo->SetTable(::rtl::OUString());
			_raInfo->SetAlias(::rtl::OUString());
			_raInfo->SetField(aColumnName);
			_raInfo->SetFieldAlias(aColumnAlias);	// nyi : hier ein fortlaufendes Expr_1, Expr_2 ...
			_raInfo->SetFunctionType(FKT_OTHER);
		}
	}
	//-----------------------------------------------------------------------------
	sal_Bool checkJoinConditions(	const OQueryDesignView* _pView,
									const ::connectivity::OSQLParseNode* _pNode )
	{
		const ::connectivity::OSQLParseNode* pJoinNode = NULL;
		sal_Bool bRet = sal_True;
		if (SQL_ISRULE(_pNode,qualified_join))
			pJoinNode = _pNode;
        else if (SQL_ISRULE(_pNode,table_ref)
                &&  _pNode->count() == 3
                &&  SQL_ISPUNCTUATION(_pNode->getChild(0),"(")
                &&  SQL_ISPUNCTUATION(_pNode->getChild(2),")") ) // '(' joined_table ')'
			pJoinNode = _pNode->getChild(1);
		else if (! ( SQL_ISRULE(_pNode, table_ref) && _pNode->count() == 2) ) // table_node table_primary_as_range_column
			bRet = sal_False;

		if (pJoinNode && !InsertJoin(_pView,pJoinNode))
			bRet = sal_False;
		return bRet;
	}
	//-----------------------------------------------------------------------------
	sal_Bool InsertJoin(const OQueryDesignView* _pView,
						const ::connectivity::OSQLParseNode *pNode)
	{
		DBG_ASSERT( SQL_ISRULE( pNode, qualified_join ) || SQL_ISRULE( pNode, joined_table ) || SQL_ISRULE( pNode, cross_union ),
			"OQueryDesignView::InsertJoin: Fehler im Parse Tree");

        if (SQL_ISRULE(pNode,joined_table))
            return InsertJoin(_pView,pNode->getChild(1));

		// first check the left and right side
        const ::connectivity::OSQLParseNode* pRightTableRef = pNode->getChild(3); // table_ref
        if ( SQL_ISRULE(pNode, qualified_join) && SQL_ISTOKEN(pNode->getChild(1),NATURAL) )
            pRightTableRef = pNode->getChild(4); // table_ref

		if ( !checkJoinConditions(_pView,pNode->getChild(0)) || !checkJoinConditions(_pView,pRightTableRef))
			return sal_False;

		// named column join wird sp�ter vieleicht noch implementiert
		// SQL_ISRULE(pNode->getChild(4),named_columns_join)
        EJoinType eJoinType = INNER_JOIN;
        bool bNatural = false;
		if ( SQL_ISRULE(pNode, qualified_join) )
		{
			::connectivity::OSQLParseNode* pJoinType = pNode->getChild(1); // join_type
            if ( SQL_ISTOKEN(pJoinType,NATURAL) )
            {
                bNatural = true;
                pJoinType = pNode->getChild(2);
            }

			if (SQL_ISRULE(pJoinType,join_type) && (!pJoinType->count() || SQL_ISTOKEN(pJoinType->getChild(0),INNER)))
			{
				eJoinType = INNER_JOIN;
			}
			else
			{
				if (SQL_ISRULE(pJoinType,join_type))	   // eine Ebene tiefer
					pJoinType = pJoinType->getChild(0);

				if (SQL_ISTOKEN(pJoinType->getChild(0),LEFT))
					eJoinType = LEFT_JOIN;
				else if(SQL_ISTOKEN(pJoinType->getChild(0),RIGHT))
					eJoinType = RIGHT_JOIN;
				else
					eJoinType = FULL_JOIN;
			}
            if ( SQL_ISRULE(pNode->getChild(4),join_condition) )
            {
			    if ( InsertJoinConnection(_pView,pNode->getChild(4)->getChild(1), eJoinType,pNode->getChild(0),pRightTableRef) != eOk )
				    return sal_False;
            }
		}
        else if ( SQL_ISRULE(pNode, cross_union) )
        {
            eJoinType = CROSS_JOIN;
            pRightTableRef = pNode->getChild(pNode->count() - 1);
        }
        else
			return sal_False;

        if ( eJoinType == CROSS_JOIN || bNatural )
        {

            OQueryTableWindow*	pLeftWindow = static_cast<OQueryTableView*>(_pView->getTableView())->FindTable( getTableRange(_pView,pNode->getChild(0)) );
            OQueryTableWindow*	pRightWindow = static_cast<OQueryTableView*>(_pView->getTableView())->FindTable( getTableRange(_pView,pRightTableRef) );
            OSL_ENSURE(pLeftWindow && pRightWindow,"Table Windows could not be found!");
            if ( !pLeftWindow || !pRightWindow )
                return sal_False;

            OTableFieldDescRef aDragLeft  = new OTableFieldDesc();
            aDragLeft->SetTabWindow(pLeftWindow);
            aDragLeft->SetTable(pLeftWindow->GetTableName());
            aDragLeft->SetAlias(pLeftWindow->GetAliasName());

			OTableFieldDescRef aDragRight = new OTableFieldDesc();
            aDragRight->SetTabWindow(pRightWindow);
            aDragRight->SetTable(pRightWindow->GetTableName());
            aDragRight->SetAlias(pRightWindow->GetAliasName());

            insertConnection(_pView,eJoinType,aDragLeft,aDragRight,bNatural);
        }


		return sal_True;
	}
	//------------------------------------------------------------------------------
	void insertUnUsedFields(OQueryDesignView* _pView,OSelectionBrowseBox* _pSelectionBrw)
	{
		// now we have to insert the fields which aren't in the statement
		OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
		OTableFields& rUnUsedFields = rController.getUnUsedFields();
        OTableFields::iterator aEnd = rUnUsedFields.end();
		for(OTableFields::iterator aIter = rUnUsedFields.begin();aIter != aEnd;++aIter)
			if(_pSelectionBrw->InsertField(*aIter,BROWSER_INVALIDID,sal_False,sal_False).isValid())
				(*aIter) = NULL;
		OTableFields().swap( rUnUsedFields );
	}

	//------------------------------------------------------------------------------
	SqlParseError InitFromParseNodeImpl(OQueryDesignView* _pView,OSelectionBrowseBox* _pSelectionBrw)
	{
		SqlParseError eErrorCode = eOk;

		OQueryController& rController = static_cast<OQueryController&>(_pView->getController());

		_pSelectionBrw->PreFill();
		_pSelectionBrw->SetReadOnly(rController.isReadOnly());
		_pSelectionBrw->Fill();


		::connectivity::OSQLParseTreeIterator& aIterator = rController.getParseIterator();
		const ::connectivity::OSQLParseNode* pParseTree = aIterator.getParseTree();

        do
        {
            if ( !pParseTree )
            {
			    // now we have to insert the fields which aren't in the statement
			    insertUnUsedFields(_pView,_pSelectionBrw);
                break;
            }

            if ( !rController.isEsacpeProcessing() ) // not allowed in this mode
            {
			    eErrorCode = eNativeMode;
                break;
            }

			if ( !( SQL_ISRULE( pParseTree, select_statement ) ) )
            {
				eErrorCode = eNoSelectStatement;
                break;
            }

            const OSQLParseNode* pTableExp = pParseTree->getChild(3);
            if ( pTableExp->getChild(6)->count() > 0 || pTableExp->getChild(7)->count() > 0 || pTableExp->getChild(8)->count() > 0)
            {
				eErrorCode = eStatementTooComplex;
                break;
            }

			Reference< XConnection> xConnection = rController.getConnection();
			if ( !xConnection.is() )
            {
                DBG_ERROR( "InitFromParseNodeImpl: no connection? no connection!" );
                break;
            }

			const OSQLTables& aMap = aIterator.getTables();
			::comphelper::UStringMixLess aTmp(aMap.key_comp());
			::comphelper::UStringMixEqual aKeyComp( aTmp.isCaseSensitive() );

			Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
			try
			{
			    sal_Int32 nMax = xMetaData->getMaxTablesInSelect();
                if ( nMax && nMax < (sal_Int32)aMap.size() )
                {
					eErrorCode = eTooManyTables;
                    break;
                }

				::rtl::OUString sComposedName;
				::rtl::OUString aQualifierName;
				::rtl::OUString sAlias;

				OQueryTableView* pTableView = static_cast<OQueryTableView*>(_pView->getTableView());
                pTableView->clearLayoutInformation();
				OSQLTables::const_iterator aIter = aMap.begin();
                OSQLTables::const_iterator aEnd = aMap.end();
				for(;aIter != aEnd;++aIter)
				{
					OSQLTable xTable = aIter->second;
                    Reference< XPropertySet > xTableProps( xTable, UNO_QUERY_THROW );

					sAlias = aIter->first;

                    // check whether this is a query
                    Reference< XPropertySetInfo > xPSI = xTableProps->getPropertySetInfo();
                    bool bIsQuery = xPSI.is() && xPSI->hasPropertyByName( PROPERTY_COMMAND );

                    if ( bIsQuery )
                        OSL_VERIFY( xTableProps->getPropertyValue( PROPERTY_NAME ) >>= sComposedName );
                    else
                    {
                        sComposedName = ::dbtools::composeTableName( xMetaData, xTableProps, ::dbtools::eInDataManipulation, false, false, false );

                        // if the alias is the complete (composed) table, then shorten it
                        if ( aKeyComp( sComposedName, aIter->first ) )
					    {
						    ::rtl::OUString sCatalog, sSchema, sTable;
						    ::dbtools::qualifiedNameComponents( xMetaData, sComposedName, sCatalog, sSchema, sTable, ::dbtools::eInDataManipulation );
						    sAlias = sTable;
					    }
                    }

                    // find the existent window for this alias
					OQueryTableWindow* pExistentWin	= pTableView->FindTable( sAlias );
					if ( !pExistentWin )
					{
						pTableView->AddTabWin( sComposedName, sAlias, sal_False );  // don't create data here
					}
					else
					{
						// there already exists a window for this alias ....
						if ( !aKeyComp( pExistentWin->GetData()->GetComposedName(), sComposedName ) )
							// ... but for another complete table name -> new window
							pTableView->AddTabWin(sComposedName, sAlias);
					}
				}

				// now delete the data for which we haven't any tablewindow
				OJoinTableView::OTableWindowMap aTableMap(*pTableView->GetTabWinMap());
				OJoinTableView::OTableWindowMap::iterator aIterTableMap = aTableMap.begin();
                OJoinTableView::OTableWindowMap::iterator aIterTableEnd = aTableMap.end();
				for(;aIterTableMap != aIterTableEnd;++aIterTableMap)
				{
					if(aMap.find(aIterTableMap->second->GetComposedName())	== aMap.end() &&
						aMap.find(aIterTableMap->first)						== aMap.end())
						pTableView->RemoveTabWin(aIterTableMap->second);
				}

				if ( eOk == (eErrorCode = FillOuterJoins(_pView,pTableExp->getChild(0)->getChild(1))) )
				{
					// check if we have a distinct statement
					if(SQL_ISTOKEN(pParseTree->getChild(1),DISTINCT))
					{
						rController.setDistinct(sal_True);
						rController.InvalidateFeature(SID_QUERY_DISTINCT_VALUES);
					}
					if ( (eErrorCode = InstallFields(_pView,pParseTree, pTableView->GetTabWinMap())) == eOk )
					{
						// GetSelectionCriteria must be called before GetHavingCriteria
						sal_uInt16 nLevel=0;

						if ( eOk == (eErrorCode = GetSelectionCriteria(_pView,_pSelectionBrw,pParseTree,nLevel)) )
						{
							if ( eOk == (eErrorCode = GetGroupCriteria(_pView,_pSelectionBrw,pParseTree)) )
							{
								if ( eOk == (eErrorCode = GetHavingCriteria(_pView,_pSelectionBrw,pParseTree,nLevel)) )
								{
									if ( eOk == (eErrorCode = GetOrderCriteria(_pView,_pSelectionBrw,pParseTree)) )
										insertUnUsedFields(_pView,_pSelectionBrw);
								}
							}
						}
					}
				}
			}
			catch(SQLException&)
			{
				OSL_ASSERT(!"getMaxTablesInSelect!");
			}
		}
        while ( false );

		// Durch das Neuerzeugen wurden wieder Undo-Actions in den Manager gestellt
		rController.ClearUndoManager();
		_pSelectionBrw->Invalidate();
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	/** fillSelectSubList
		@return
			<TRUE/> when columns could be inserted otherwise <FALSE/>
	*/
	//------------------------------------------------------------------------------
	SqlParseError fillSelectSubList(	OQueryDesignView* _pView,
								OJoinTableView::OTableWindowMap* _pTabList)
	{
		SqlParseError eErrorCode = eOk;
		sal_Bool bFirstField = sal_True;
		::rtl::OUString sAsterix(RTL_CONSTASCII_USTRINGPARAM("*"));
		OJoinTableView::OTableWindowMap::iterator aIter = _pTabList->begin();
        OJoinTableView::OTableWindowMap::iterator aEnd = _pTabList->end();
		for(;aIter != aEnd && eOk == eErrorCode ;++aIter)
		{
			OQueryTableWindow* pTabWin = static_cast<OQueryTableWindow*>(aIter->second);
            OTableFieldDescRef	aInfo = new OTableFieldDesc();
			if (pTabWin->ExistsField( sAsterix, aInfo ))
			{
				eErrorCode = _pView->InsertField(aInfo, sal_True, bFirstField);
				bFirstField = sal_False;
			}
		}
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError InstallFields(OQueryDesignView* _pView,
								const ::connectivity::OSQLParseNode* pNode,
								OJoinTableView::OTableWindowMap* pTabList )
	{
		if( pNode==0 || !SQL_ISRULE(pNode,select_statement))
			return eNoSelectStatement;

		::connectivity::OSQLParseNode* pParseTree = pNode->getChild(2); // selection
		sal_Bool bFirstField = sal_True;	// bei der Initialisierung mu� auf alle Faelle das erste Feld neu aktiviert werden

		SqlParseError eErrorCode = eOk;

		if ( pParseTree->isRule() && SQL_ISPUNCTUATION(pParseTree->getChild(0),"*") )
		{
			// SELECT * ...
			eErrorCode = fillSelectSubList(_pView,pTabList);
		}
		else if (SQL_ISRULE(pParseTree,scalar_exp_commalist) )
		{
			// SELECT column, ...
			OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
			Reference< XConnection> xConnection = rController.getConnection();

			::rtl::OUString aColumnName,aTableRange;
			for (sal_uInt32 i = 0; i < pParseTree->count() && eOk == eErrorCode ; ++i)
			{
				::connectivity::OSQLParseNode * pColumnRef = pParseTree->getChild(i);

                do {

                if ( SQL_ISRULE(pColumnRef,select_sublist) )
				{
					 eErrorCode = fillSelectSubList(_pView,pTabList);
                     break;
				}

                if ( SQL_ISRULE(pColumnRef,derived_column) )
				{
					::rtl::OUString aColumnAlias(rController.getParseIterator().getColumnAlias(pColumnRef)); // kann leer sein
					pColumnRef = pColumnRef->getChild(0);
					OTableFieldDescRef aInfo = new OTableFieldDesc();

					if (	pColumnRef->count() == 3 &&
							SQL_ISPUNCTUATION(pColumnRef->getChild(0),"(") &&
							SQL_ISPUNCTUATION(pColumnRef->getChild(2),")")
						)
						pColumnRef = pColumnRef->getChild(1);

					if (SQL_ISRULE(pColumnRef,column_ref))
					{
						InsertColumnRef(_pView,pColumnRef,aColumnName,aColumnAlias,aTableRange,aInfo,pTabList);
						eErrorCode = _pView->InsertField(aInfo, sal_True, bFirstField);
						bFirstField = sal_False;
					}
					else if(SQL_ISRULEOR2(pColumnRef,general_set_fct ,set_fct_spec)	||
							SQL_ISRULEOR2(pColumnRef,position_exp,extract_exp)		||
							SQL_ISRULEOR2(pColumnRef,fold,char_substring_fct)		||
							SQL_ISRULEOR2(pColumnRef,length_exp,char_value_fct))
					{
						::rtl::OUString aColumns;
                        pColumnRef->parseNodeToPredicateStr(aColumns,
												            xConnection,
												            rController.getNumberFormatter(),
												            _pView->getLocale(),
												            static_cast<sal_Char>(_pView->getDecimalSeparator().toChar()),
												            &rController.getParser().getContext());
						//pColumnRef->parseNodeToStr(	aColumns,
						//							xConnection,
						//							&rController.getParser().getContext(),
						//							sal_True,
						//							sal_True); // quote is to true because we need quoted elements inside the function

						sal_Int32 nFunctionType = FKT_NONE;
						::connectivity::OSQLParseNode* pParamRef = NULL;
						sal_Int32 nColumnRefPos = pColumnRef->count() - 2;
						if ( nColumnRefPos >= 0 && static_cast<sal_uInt32>(nColumnRefPos) < pColumnRef->count() )
							pParamRef = pColumnRef->getChild(nColumnRefPos);

						if (	SQL_ISRULE(pColumnRef,general_set_fct)
							&&	SQL_ISRULE(pParamRef,column_ref) )
						{
							// Parameter auf Columnref pr"ufen
							InsertColumnRef(_pView,pParamRef,aColumnName,aColumnAlias,aTableRange,aInfo,pTabList);
						}
						else if ( SQL_ISRULE(pColumnRef,general_set_fct) )
						{
							if ( pParamRef && pParamRef->getTokenValue().toChar() == '*' )
							{
								OJoinTableView::OTableWindowMap::iterator aIter = pTabList->begin();
                                OJoinTableView::OTableWindowMap::iterator aEnd  = pTabList->end();
								for(;aIter != aEnd;++aIter)
								{
									OQueryTableWindow* pTabWin = static_cast<OQueryTableWindow*>(aIter->second);
									if (pTabWin->ExistsField( ::rtl::OUString::createFromAscii("*"), aInfo ))
									{
										aInfo->SetAlias(String());
										aInfo->SetTable(String());
										break;
									}
								}
							}
							else
							{
								::rtl::OUString sFieldName = aColumns;
								if ( pParamRef )
								{	// we got an aggregate function but without column name inside
									// so we set the whole argument of the function as field name
									nFunctionType |= FKT_NUMERIC;
									sFieldName = ::rtl::OUString();
									pParamRef->parseNodeToStr(	sFieldName,
														xConnection,
														&rController.getParser().getContext(),
														sal_True,
														sal_True); // quote is to true because we need quoted elements inside the function
								}
								aInfo->SetDataType(DataType::DOUBLE);
								aInfo->SetFieldType(TAB_NORMAL_FIELD);
								aInfo->SetField(sFieldName);
							}
							aInfo->SetTabWindow(NULL);
							aInfo->SetFieldAlias(aColumnAlias);
						}
						else
						{
                            _pView->fillFunctionInfo(pColumnRef,aColumns,aInfo);
							aInfo->SetFieldAlias(aColumnAlias);
						}

						if ( SQL_ISRULE(pColumnRef,general_set_fct) )
						{
							aInfo->SetFunctionType(nFunctionType|FKT_AGGREGATE);
							String aCol(aColumns);
							aInfo->SetFunction(aCol.GetToken(0,'(').EraseTrailingChars(' '));
						}
						else
							aInfo->SetFunctionType(nFunctionType|FKT_OTHER);

						eErrorCode = _pView->InsertField(aInfo, sal_True, bFirstField);
						bFirstField = sal_False;
					}
					else //if(SQL_ISRULE(pColumnRef,num_value_exp)	|| SQL_ISRULE(pColumnRef,term))
					{
						::rtl::OUString aColumns;
						pColumnRef->parseNodeToStr(	aColumns,
													xConnection,
													&rController.getParser().getContext(),
													sal_True,
													sal_True); // quote is to true because we need quoted elements inside the function

                        aInfo->SetTabWindow( NULL );

                        // since we support queries in queries, the thingie might belong to an existing "table"
                        OQueryTableWindow* pExistingTable = lcl_findColumnInTables( aColumns, *pTabList, aInfo );
                        if ( pExistingTable )
                        {
                            aInfo->SetTabWindow( pExistingTable );
					        aInfo->SetTable( pExistingTable->GetTableName() );
					        aInfo->SetAlias( pExistingTable->GetAliasName() );
                        }

                        aInfo->SetDataType(DataType::DOUBLE);
						aInfo->SetFieldType(TAB_NORMAL_FIELD);
						aInfo->SetField(aColumns);
						aInfo->SetFieldAlias(aColumnAlias);
						aInfo->SetFunctionType(FKT_NUMERIC | FKT_OTHER);

						eErrorCode = _pView->InsertField(aInfo, sal_True, bFirstField);
						bFirstField = sal_False;
					}

                    break;
				}

                DBG_ERROR( "InstallFields: don't know how to interpret this parse node!" );

                } while ( false );
			}
		}
		else
			eErrorCode = eStatementTooComplex;

		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError GetOrderCriteria(	OQueryDesignView* _pView,
							OSelectionBrowseBox* _pSelectionBrw,
							const ::connectivity::OSQLParseNode* pParseRoot )
	{
		SqlParseError eErrorCode = eOk;
		if (!pParseRoot->getChild(3)->getChild(4)->isLeaf())
		{
			::connectivity::OSQLParseNode* pNode = pParseRoot->getChild(3)->getChild(4)->getChild(2);
			::connectivity::OSQLParseNode* pParamRef = NULL;

            OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
			EOrderDir eOrderDir;
			OTableFieldDescRef aDragLeft = new OTableFieldDesc();
			for( sal_uInt32 i=0 ; i<pNode->count() ; i++ )
			{
				eOrderDir = ORDER_ASC;
				::connectivity::OSQLParseNode*	pChild = pNode->getChild( i );

				if (SQL_ISTOKEN( pChild->getChild(1), DESC ) )
					eOrderDir = ORDER_DESC;

                ::connectivity::OSQLParseNode* pArgument = pChild->getChild(0);

				if(SQL_ISRULE(pArgument,column_ref))
				{
					if( eOk == FillDragInfo(_pView,pArgument,aDragLeft))
						_pSelectionBrw->AddOrder( aDragLeft, eOrderDir, i);
					else // it could be a alias name for a field
					{
						::rtl::OUString aTableRange,aColumnName;
						::connectivity::OSQLParseTreeIterator& rParseIter = rController.getParseIterator();
						rParseIter.getColumnRange( pArgument, aColumnName, aTableRange );

						OTableFields& aList = rController.getTableFieldDesc();
						OTableFields::iterator aIter = aList.begin();
                        OTableFields::iterator aEnd = aList.end();
						for(;aIter != aEnd;++aIter)
						{
							OTableFieldDescRef pEntry = *aIter;
							if(pEntry.isValid() && pEntry->GetFieldAlias() == aColumnName)
								pEntry->SetOrderDir( eOrderDir );
						}
					}
				}
				else if(SQL_ISRULE(pArgument, general_set_fct ) &&
						SQL_ISRULE(pParamRef = pArgument->getChild(pArgument->count()-2),column_ref) &&
						eOk == FillDragInfo(_pView,pParamRef,aDragLeft))
					_pSelectionBrw->AddOrder( aDragLeft, eOrderDir, i );
                else if( SQL_ISRULE(pArgument, set_fct_spec ) )
                {

		            Reference< XConnection> xConnection = rController.getConnection();
		            if(xConnection.is())
		            {
                        ::rtl::OUString sCondition;
			            pArgument->parseNodeToPredicateStr(sCondition,
												            xConnection,
												            rController.getNumberFormatter(),
												            _pView->getLocale(),
												            static_cast<sal_Char>(_pView->getDecimalSeparator().toChar()),
												            &rController.getParser().getContext());
                        _pView->fillFunctionInfo(pArgument,sCondition,aDragLeft);
                        aDragLeft->SetFunctionType(FKT_OTHER);
                        aDragLeft->SetOrderDir(eOrderDir);
                        aDragLeft->SetVisible(sal_False);
                        _pSelectionBrw->AddOrder( aDragLeft, eOrderDir, i );
                    }
                    else
                        eErrorCode = eColumnNotFound;
                }
				else
					eErrorCode = eColumnNotFound;
			}
		}
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError GetHavingCriteria(	OQueryDesignView* _pView,
							OSelectionBrowseBox* _pSelectionBrw,
							const ::connectivity::OSQLParseNode* pSelectRoot,
							sal_uInt16& rLevel )
	{
		SqlParseError eErrorCode = eOk;
		if (!pSelectRoot->getChild(3)->getChild(3)->isLeaf())
			eErrorCode = GetORCriteria(_pView,_pSelectionBrw,pSelectRoot->getChild(3)->getChild(3)->getChild(1),rLevel, sal_True);
		return eErrorCode;
	}
	//------------------------------------------------------------------------------
	SqlParseError GetGroupCriteria(	OQueryDesignView* _pView,
							OSelectionBrowseBox* _pSelectionBrw,
							const ::connectivity::OSQLParseNode* pSelectRoot )
	{
		SqlParseError eErrorCode = eOk;
		if (!pSelectRoot->getChild(3)->getChild(2)->isLeaf()) // opt_group_by_clause
		{
            OQueryController& rController = static_cast<OQueryController&>(_pView->getController());
			::connectivity::OSQLParseNode* pGroupBy = pSelectRoot->getChild(3)->getChild(2)->getChild(2);

			for( sal_uInt32 i=0 ; i < pGroupBy->count() && eOk == eErrorCode; ++i )
			{
                OTableFieldDescRef aDragInfo = new OTableFieldDesc();
                ::connectivity::OSQLParseNode* pParamRef = NULL;
				::connectivity::OSQLParseNode* pArgument = pGroupBy->getChild( i );
				if(SQL_ISRULE(pArgument,column_ref))
				{
					if ( eOk == (eErrorCode = FillDragInfo(_pView,pArgument,aDragInfo)) )
					{
						aDragInfo->SetGroupBy(sal_True);
						_pSelectionBrw->AddGroupBy(aDragInfo,i);
					}
				}
                else if(SQL_ISRULE(pArgument, general_set_fct ) &&
						SQL_ISRULE(pParamRef = pArgument->getChild(pArgument->count()-2),column_ref) &&
						eOk == FillDragInfo(_pView,pParamRef,aDragInfo))
                {
                    aDragInfo->SetGroupBy(sal_True);
					_pSelectionBrw->AddGroupBy( aDragInfo, i );
                }
                else if( SQL_ISRULE(pArgument, set_fct_spec ) )
                {
		            Reference< XConnection> xConnection = rController.getConnection();
		            if(xConnection.is())
		            {
                        ::rtl::OUString sGroupByExpression;
			            pArgument->parseNodeToStr(	sGroupByExpression,
													xConnection,
													&rController.getParser().getContext(),
													sal_True,
													sal_True); // quote is to true because we need quoted elements inside the function
                        _pView->fillFunctionInfo(pArgument,sGroupByExpression,aDragInfo);
                        aDragInfo->SetFunctionType(FKT_OTHER);
                        aDragInfo->SetGroupBy(sal_True);
                        aDragInfo->SetVisible(sal_False);
                        _pSelectionBrw->AddGroupBy( aDragInfo, i );
                    }
                    else
                        eErrorCode = eColumnNotFound;
                }
			}
		}
		return eErrorCode;
	}

    //------------------------------------------------------------------------------
	String getParseErrorMessage( SqlParseError _eErrorCode )
	{
		sal_uInt16 nResId;
		switch(_eErrorCode)
		{
			case eIllegalJoin:
				nResId = STR_QRY_ILLEGAL_JOIN;
				break;
			case eStatementTooLong:
				nResId = STR_QRY_TOO_LONG_STATEMENT;
				break;
			case eNoConnection:
				nResId = STR_QRY_SYNTAX;
				break;
			case eNoSelectStatement:
				nResId = STR_QRY_NOSELECT;
				break;
			case eColumnInLikeNotFound:
				nResId = STR_QRY_SYNTAX;
				break;
			case eNoColumnInLike:
				nResId = STR_QRY_SYNTAX;
				break;
			case eColumnNotFound:
				nResId = STR_QRY_SYNTAX;
				break;
			case eNativeMode:
				nResId = STR_QRY_NATIVE;
				break;
			case eTooManyTables:
				nResId = STR_QRY_TOO_MANY_TABLES;
				break;
			case eTooManyConditions:
				nResId = STR_QRY_TOOMANYCOND;
				break;
			case eTooManyColumns:
				nResId = STR_QRY_TOO_MANY_COLUMNS;
				break;
			case eStatementTooComplex:
				nResId = STR_QRY_TOOCOMPLEX;
				break;
			default:
				nResId = STR_QRY_SYNTAX;
				break;
		}
		;
        return String( ModuleRes( nResId ) );
	}

	//------------------------------------------------------------------------------
	//------------------------------------------------------------------------------
}
// end of anonymouse namespace
DBG_NAME(OQueryDesignView)

OQueryDesignView::OQueryDesignView(	OQueryContainerWindow* _pParent,
									OQueryController& _rController,
									const Reference< XMultiServiceFactory >& _rFactory)
	:OQueryView( _pParent, _rController, _rFactory )
	,m_aSplitter( this )
	,m_eChildFocus(NONE)
	,m_bInKeyEvent(sal_False)
	,m_bInSplitHandler( sal_False )
{
    DBG_CTOR(OQueryDesignView,NULL);

	try
	{
		SvtSysLocale aSysLocale;
		m_aLocale = aSysLocale.GetLocaleData().getLocale();
		m_sDecimalSep = aSysLocale.GetLocaleData().getNumDecimalSep();
	}
	catch(Exception&)
	{
	}

	m_pSelectionBox = new OSelectionBrowseBox(this);

	setNoneVisbleRow(static_cast<OQueryController&>(getController()).getVisibleRows());
	m_pSelectionBox->Show();
	// Splitter einrichten
	m_aSplitter.SetSplitHdl(LINK(this, OQueryDesignView,SplitHdl));
	m_aSplitter.Show();

}
// -----------------------------------------------------------------------------
OQueryDesignView::~OQueryDesignView()
{
	if ( m_pTableView )
		::dbaui::notifySystemWindow(this,m_pTableView,::comphelper::mem_fun(&TaskPaneList::RemoveWindow));
	::std::auto_ptr<Window> aTemp(m_pSelectionBox);
	m_pSelectionBox = NULL;

    DBG_DTOR(OQueryDesignView,NULL);
}
//------------------------------------------------------------------------------
IMPL_LINK( OQueryDesignView, SplitHdl, void*, /*p*/ )
{
	if (!getController().isReadOnly())
	{
		m_bInSplitHandler = sal_True;
		m_aSplitter.SetPosPixel( Point( m_aSplitter.GetPosPixel().X(),m_aSplitter.GetSplitPosPixel() ) );
		static_cast<OQueryController&>(getController()).setSplitPos(m_aSplitter.GetSplitPosPixel());
		static_cast<OQueryController&>(getController()).setModified( sal_True );
		Resize();
		m_bInSplitHandler = sal_True;
	}
	return 0L;
}
// -------------------------------------------------------------------------
void OQueryDesignView::Construct()
{
	m_pTableView = new OQueryTableView(m_pScrollWindow,this);
	::dbaui::notifySystemWindow(this,m_pTableView,::comphelper::mem_fun(&TaskPaneList::AddWindow));
	OQueryView::Construct();
}
// -----------------------------------------------------------------------------
void OQueryDesignView::initialize()
{
	if(static_cast<OQueryController&>(getController()).getSplitPos() != -1)
	{
		m_aSplitter.SetPosPixel( Point( m_aSplitter.GetPosPixel().X(),static_cast<OQueryController&>(getController()).getSplitPos() ) );
		m_aSplitter.SetSplitPosPixel(static_cast<OQueryController&>(getController()).getSplitPos());
	}
	m_pSelectionBox->initialize();
	reset();
}
// -------------------------------------------------------------------------
void OQueryDesignView::resizeDocumentView(Rectangle& _rPlayground)
{
	Point aPlaygroundPos( _rPlayground.TopLeft() );
	Size aPlaygroundSize( _rPlayground.GetSize() );

	// calc the split pos, and forward it to the controller
	sal_Int32 nSplitPos = static_cast<OQueryController&>(getController()).getSplitPos();
	if ( 0 != aPlaygroundSize.Height() )
	{
		if	(	( -1 == nSplitPos )
			||	( nSplitPos >= aPlaygroundSize.Height() )
			)
		{
			// let the selection browse box determine an optimal size
			Size aSelectionBoxSize = m_pSelectionBox->CalcOptimalSize( aPlaygroundSize );
			nSplitPos = aPlaygroundSize.Height() - aSelectionBoxSize.Height() - m_aSplitter.GetSizePixel().Height();
			// still an invalid size?
			if ( nSplitPos == -1 || nSplitPos >= aPlaygroundSize.Height() )
				nSplitPos = sal_Int32(aPlaygroundSize.Height()*0.6);

			static_cast<OQueryController&>(getController()).setSplitPos(nSplitPos);
		}

		if ( !m_bInSplitHandler )
		{	// the resize is triggered by something else than the split handler
			// our main focus is to try to preserve the size of the selectionbrowse box
			Size aSelBoxSize = m_pSelectionBox->GetSizePixel();
			if ( aSelBoxSize.Height() )
			{
				// keep the size of the sel box constant
				nSplitPos = aPlaygroundSize.Height() - m_aSplitter.GetSizePixel().Height() - aSelBoxSize.Height();

				// and if the box is smaller than the optimal size, try to do something about it
				Size aSelBoxOptSize = m_pSelectionBox->CalcOptimalSize( aPlaygroundSize );
				if ( aSelBoxOptSize.Height() > aSelBoxSize.Height() )
				{
					nSplitPos = aPlaygroundSize.Height() - m_aSplitter.GetSizePixel().Height() - aSelBoxOptSize.Height();
				}

				static_cast< OQueryController& >(getController()).setSplitPos( nSplitPos );
			}
		}
	}

	// normalize the split pos
	Point	aSplitPos		= Point( _rPlayground.Left(), nSplitPos );
	Size	aSplitSize		= Size( _rPlayground.GetSize().Width(), m_aSplitter.GetSizePixel().Height() );

	if( ( aSplitPos.Y() + aSplitSize.Height() ) > ( aPlaygroundSize.Height() ))
		aSplitPos.Y() = aPlaygroundSize.Height() - aSplitSize.Height();

	if( aSplitPos.Y() <= aPlaygroundPos.Y() )
		aSplitPos.Y() = aPlaygroundPos.Y() + sal_Int32(aPlaygroundSize.Height() * 0.2);

	// position the table
	Size aTableViewSize(aPlaygroundSize.Width(), aSplitPos.Y() - aPlaygroundPos.Y());
	m_pScrollWindow->SetPosSizePixel(aPlaygroundPos, aTableViewSize);

	// position the selection browse box
	Point aPos( aPlaygroundPos.X(), aSplitPos.Y() + aSplitSize.Height() );
	m_pSelectionBox->SetPosSizePixel( aPos, Size( aPlaygroundSize.Width(), aPlaygroundSize.Height() - aSplitSize.Height() - aTableViewSize.Height() ));

	// set the size of the splitter
	m_aSplitter.SetPosSizePixel( aSplitPos, aSplitSize );
	m_aSplitter.SetDragRectPixel( _rPlayground );

	// just for completeness: there is no space left, we occupied it all ...
	_rPlayground.SetPos( _rPlayground.BottomRight() );
	_rPlayground.SetSize( Size( 0, 0 ) );
}
// -----------------------------------------------------------------------------
void OQueryDesignView::setReadOnly(sal_Bool _bReadOnly)
{
	m_pSelectionBox->SetReadOnly(_bReadOnly);
}
// -----------------------------------------------------------------------------
void OQueryDesignView::clear()
{
	m_pSelectionBox->ClearAll(); // clear the whole selection
	m_pTableView->ClearAll();
}
// -----------------------------------------------------------------------------
void OQueryDesignView::setStatement(const ::rtl::OUString& /*_rsStatement*/)
{
}
// -----------------------------------------------------------------------------
void OQueryDesignView::copy()
{
	if( m_eChildFocus == SELECTION)
		m_pSelectionBox->copy();
}
// -----------------------------------------------------------------------------
sal_Bool OQueryDesignView::isCutAllowed()
{
	sal_Bool bAllowed = sal_False;
	if ( SELECTION == m_eChildFocus )
		bAllowed = m_pSelectionBox->isCutAllowed();
	return bAllowed;
}
// -----------------------------------------------------------------------------
sal_Bool OQueryDesignView::isPasteAllowed()
{
	sal_Bool bAllowed = sal_False;
	if ( SELECTION == m_eChildFocus )
		bAllowed = m_pSelectionBox->isPasteAllowed();
	return bAllowed;
}
// -----------------------------------------------------------------------------
sal_Bool OQueryDesignView::isCopyAllowed()
{
	sal_Bool bAllowed = sal_False;
	if ( SELECTION == m_eChildFocus )
		bAllowed = m_pSelectionBox->isCopyAllowed();
	return bAllowed;
}
// -----------------------------------------------------------------------------
void OQueryDesignView::stopTimer()
{
	m_pSelectionBox->stopTimer();
}
// -----------------------------------------------------------------------------
void OQueryDesignView::startTimer()
{
	m_pSelectionBox->startTimer();
}
// -----------------------------------------------------------------------------
void OQueryDesignView::cut()
{
	if( m_eChildFocus == SELECTION)
	{
		m_pSelectionBox->cut();
		static_cast<OQueryController&>(getController()).setModified(sal_True);
	}
}
// -----------------------------------------------------------------------------
void OQueryDesignView::paste()
{
	if( m_eChildFocus == SELECTION)
	{
		m_pSelectionBox->paste();
		static_cast<OQueryController&>(getController()).setModified(sal_True);
	}
}
// -----------------------------------------------------------------------------
void OQueryDesignView::TableDeleted(const ::rtl::OUString& rAliasName)
{
	// Nachricht, dass Tabelle aus dem Fenster gel"oscht wurde
	DeleteFields(rAliasName);
	static_cast<OQueryController&>(getController()).InvalidateFeature(ID_BROWSER_ADDTABLE);	// view nochmal bescheid sagen
}
//------------------------------------------------------------------------------
void OQueryDesignView::DeleteFields( const ::rtl::OUString& rAliasName )
{
	m_pSelectionBox->DeleteFields( rAliasName );
}
// -----------------------------------------------------------------------------
bool OQueryDesignView::HasFieldByAliasName(const ::rtl::OUString& rFieldName, OTableFieldDescRef& rInfo)  const
{
    return m_pSelectionBox->HasFieldByAliasName( rFieldName, rInfo);
}
// -----------------------------------------------------------------------------
SqlParseError OQueryDesignView::InsertField( const OTableFieldDescRef& rInfo, sal_Bool bVis, sal_Bool bActivate)
{
	return m_pSelectionBox->InsertField( rInfo, BROWSER_INVALIDID,bVis, bActivate ).isValid() ? eOk : eTooManyColumns;
}
// -----------------------------------------------------------------------------
sal_Int32 OQueryDesignView::getColWidth(sal_uInt16 _nColPos) const
{
    static sal_Int32 s_nDefaultWidth = GetTextWidth(String(RTL_CONSTASCII_USTRINGPARAM("0"))) * 15;
    sal_Int32 nWidth = static_cast<OQueryController&>(getController()).getColWidth(_nColPos);
    if ( !nWidth )
        nWidth = s_nDefaultWidth;
	return nWidth;
}
//------------------------------------------------------------------------------
void OQueryDesignView::fillValidFields(const ::rtl::OUString& sAliasName, ComboBox* pFieldList)
{
	DBG_ASSERT(pFieldList != NULL, "OQueryDesignView::FillValidFields : What the hell do you think I can do with a NULL-ptr ? This will crash !");
	pFieldList->Clear();

	sal_Bool bAllTables = sAliasName.getLength() == 0;

	OJoinTableView::OTableWindowMap* pTabWins = m_pTableView->GetTabWinMap();
	::rtl::OUString strCurrentPrefix;
	::std::vector< ::rtl::OUString> aFields;
	OJoinTableView::OTableWindowMap::iterator aIter = pTabWins->begin();
    OJoinTableView::OTableWindowMap::iterator aEnd  = pTabWins->end();
    for(;aIter != aEnd;++aIter)
	{
		OQueryTableWindow* pCurrentWin = static_cast<OQueryTableWindow*>(aIter->second);
		if (bAllTables || (pCurrentWin->GetAliasName() == sAliasName))
		{
			strCurrentPrefix = pCurrentWin->GetAliasName();
			strCurrentPrefix += ::rtl::OUString('.');

			pCurrentWin->EnumValidFields(aFields);

			::std::vector< ::rtl::OUString>::iterator aStrIter = aFields.begin();
            ::std::vector< ::rtl::OUString>::iterator aStrEnd = aFields.end();
			for(;aStrIter != aStrEnd;++aStrIter)
			{
				if (bAllTables || aStrIter->toChar() == '*')
					pFieldList->InsertEntry(::rtl::OUString(strCurrentPrefix) += *aStrIter);
				else
					pFieldList->InsertEntry(*aStrIter);
			}

			if (!bAllTables)
				// das heisst, dass ich in diesen Block kam, weil der Tabellenname genau der gesuchte war, also bin ich fertig
				// (dadurch verhindere ich auch das doppelte Einfuegen von Feldern, wenn eine Tabelle mehrmals als TabWin vorkommt)
				break;
		}
	}
}
// -----------------------------------------------------------------------------
long OQueryDesignView::PreNotify(NotifyEvent& rNEvt)
{
	switch (rNEvt.GetType())
	{
		case EVENT_GETFOCUS:
#if OSL_DEBUG_LEVEL > 0
			{
				Window* pFocus = Application::GetFocusWindow();
                (void)pFocus;
			}
#endif

			if ( m_pSelectionBox && m_pSelectionBox->HasChildPathFocus() )
				m_eChildFocus = SELECTION;
			else
				m_eChildFocus = TABLEVIEW;
			break;
	}

	return OQueryView::PreNotify(rNEvt);
}
//------------------------------------------------------------------------------


// -----------------------------------------------------------------------------
// check if the statement is correct when not returning false
sal_Bool OQueryDesignView::checkStatement()
{
	sal_Bool bRet = sal_True;
	if ( m_pSelectionBox )
		bRet = m_pSelectionBox->Save(); // a error occured so we return no
	return bRet;
}
//-------------------------------------------------------------------------------
::rtl::OUString OQueryDesignView::getStatement()
{
	OQueryController& rController = static_cast<OQueryController&>(getController());
	m_rController.clearError();
	// used for fields which aren't any longer in the statement
	OTableFields& rUnUsedFields = rController.getUnUsedFields();
	OTableFields().swap( rUnUsedFields );

	// create the select columns
	sal_uInt32 nFieldcount = 0;
	OTableFields& rFieldList = rController.getTableFieldDesc();
	OTableFields::iterator aIter = rFieldList.begin();
    OTableFields::iterator aEnd = rFieldList.end();
	for(;aIter != aEnd;++aIter)
	{
		OTableFieldDescRef pEntryField = *aIter;
		if ( pEntryField->GetField().getLength() && pEntryField->IsVisible() )
			++nFieldcount;
		else if (pEntryField->GetField().getLength()			&&
				!pEntryField->HasCriteria()					&&
				pEntryField->isNoneFunction()				&&
				pEntryField->GetOrderDir() == ORDER_NONE	&&
                !pEntryField->IsGroupBy()                   &&
				!pEntryField->GetFunction().getLength() )
			rUnUsedFields.push_back(pEntryField);
	}
	if ( !nFieldcount )	// keine Felder sichtbar also zur"uck
	{
		rUnUsedFields = rFieldList;
		return ::rtl::OUString();
	}

	OQueryTableView::OTableWindowMap* pTabList   = m_pTableView->GetTabWinMap();
	sal_uInt32 nTabcount		= pTabList->size();

	::rtl::OUString	aFieldListStr(GenerateSelectList(this,rFieldList,nTabcount>1));
	if( !aFieldListStr.getLength() )
		return ::rtl::OUString();
	// Ausnahmebehandlung, wenn keine Felder angegeben worden sind
	// Dann darf die Tabpage nicht gewechselt werden
	// Im TabBarSelectHdl wird der SQL-::rtl::OUString auf STATEMENT_NOFIELDS abgefragt
	// und eine Errormeldung erzeugt
	// ----------------- Tabellenliste aufbauen ----------------------

	const ::std::vector<OTableConnection*>*	pConnList = m_pTableView->getTableConnections();
	Reference< XConnection> xConnection = rController.getConnection();
	::rtl::OUString aTableListStr(GenerateFromClause(xConnection,pTabList,pConnList));
	DBG_ASSERT(aTableListStr.getLength(), "OQueryDesignView::getStatement() : unerwartet : habe Felder, aber keine Tabellen !");
	// wenn es Felder gibt, koennen die nur durch Einfuegen aus einer schon existenten Tabelle entstanden sein; wenn andererseits
	// eine Tabelle geloescht wird, verschwinden auch die zugehoerigen Felder -> ergo KANN es das nicht geben, dass Felder
	// existieren, aber keine Tabellen (und aFieldListStr hat schon eine Laenge, das stelle ich oben sicher)
	::rtl::OUStringBuffer aHavingStr,aCriteriaListStr;
	// ----------------- Kriterien aufbauen ----------------------
	if (!GenerateCriterias(this,aCriteriaListStr,aHavingStr,rFieldList, nTabcount > 1))
		return ::rtl::OUString();

	::rtl::OUString aJoinCrit;
	GenerateInnerJoinCriterias(xConnection,aJoinCrit,pConnList);
	if(aJoinCrit.getLength())
	{
		::rtl::OUString aTmp = ::rtl::OUString::createFromAscii("( ");
		aTmp += aJoinCrit;
		aTmp += ::rtl::OUString::createFromAscii(" )");
		if(aCriteriaListStr.getLength())
		{
			aTmp += C_AND;
			aTmp += aCriteriaListStr.makeStringAndClear();
		}
		aCriteriaListStr = aTmp;
	}
	// ----------------- Statement aufbauen ----------------------
	::rtl::OUStringBuffer aSqlCmd(::rtl::OUString::createFromAscii("SELECT "));
	if(static_cast<OQueryController&>(getController()).isDistinct())
		aSqlCmd.append(::rtl::OUString::createFromAscii(" DISTINCT "));
	aSqlCmd.append(aFieldListStr);
	aSqlCmd.append(::rtl::OUString::createFromAscii(" FROM "));
	aSqlCmd.append(aTableListStr);

	if (aCriteriaListStr.getLength())
	{
		aSqlCmd.append(::rtl::OUString::createFromAscii(" WHERE "));
		aSqlCmd.append(aCriteriaListStr.makeStringAndClear());
	}
	// ----------------- GroupBy aufbauen und Anh"angen ------------
	Reference<XDatabaseMetaData> xMeta;
	if ( xConnection.is() )
		xMeta = xConnection->getMetaData();
	sal_Bool bUseAlias = nTabcount > 1;
	if ( xMeta.is() )
		bUseAlias = bUseAlias || !xMeta->supportsGroupByUnrelated();

	aSqlCmd.append(GenerateGroupBy(this,rFieldList,bUseAlias));
	// ----------------- having Anh"angen ------------
	if(aHavingStr.getLength())
	{
		aSqlCmd.append(::rtl::OUString::createFromAscii(" HAVING "));
		aSqlCmd.append(aHavingStr.makeStringAndClear());
	}
	// ----------------- Sortierung aufbauen und Anh"angen ------------
	::rtl::OUString sOrder;
	SqlParseError eErrorCode = eOk;
	if ( (eErrorCode = GenerateOrder(this,rFieldList,nTabcount > 1,sOrder)) == eOk)
		aSqlCmd.append(sOrder);
	else
	{
		if ( !m_rController.hasError() )
            m_rController.appendError( getParseErrorMessage( eErrorCode ) );

        m_rController.displayError();
	}

    ::rtl::OUString sSQL = aSqlCmd.makeStringAndClear();
    if ( xConnection.is() )
    {
        ::connectivity::OSQLParser& rParser( rController.getParser() );
        ::rtl::OUString sErrorMessage;
        ::std::auto_ptr<OSQLParseNode> pParseNode( rParser.parseTree( sErrorMessage, sSQL, sal_True ) );
        if ( pParseNode.get() )
        {
            OSQLParseNode* pNode = pParseNode->getChild(3)->getChild(1);
            if ( pNode->count() > 1 )
            {
		        ::connectivity::OSQLParseNode * pCondition = pNode->getChild(1);
		        if ( pCondition ) // no where clause
                {
                    OSQLParseNode::compress(pCondition);
                    ::rtl::OUString sTemp;
                    pParseNode->parseNodeToStr(sTemp,xConnection);
                    sSQL = sTemp;
                }
            }
        }
    }
	return sSQL;
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
void OQueryDesignView::setSlotEnabled(sal_Int32 _nSlotId,sal_Bool _bEnable)
{
	sal_uInt16 nRow;
	switch (_nSlotId)
	{
		case SID_QUERY_VIEW_FUNCTIONS:
			nRow = BROW_FUNCTION_ROW;
			break;
		case SID_QUERY_VIEW_TABLES:
			nRow = BROW_TABLE_ROW;
			break;
		case SID_QUERY_VIEW_ALIASES:
			nRow = BROW_COLUMNALIAS_ROW;
			break;
		default:
			// ????????????
			nRow = 0;
			break;
	}
	m_pSelectionBox->SetRowVisible(nRow,_bEnable);
	m_pSelectionBox->Invalidate();
}
// -----------------------------------------------------------------------------
sal_Bool OQueryDesignView::isSlotEnabled(sal_Int32 _nSlotId)
{
	sal_uInt16 nRow;
	switch (_nSlotId)
	{
		case SID_QUERY_VIEW_FUNCTIONS:
			nRow = BROW_FUNCTION_ROW;
			break;
		case SID_QUERY_VIEW_TABLES:
			nRow = BROW_TABLE_ROW;
			break;
		case SID_QUERY_VIEW_ALIASES:
			nRow = BROW_COLUMNALIAS_ROW;
			break;
		default:
			// ?????????
			nRow = 0;
			break;
	}
	return m_pSelectionBox->IsRowVisible(nRow);
}
// -----------------------------------------------------------------------------
void OQueryDesignView::SaveUIConfig()
{
	OQueryController& rCtrl = static_cast<OQueryController&>(getController());
	rCtrl.SaveTabWinsPosSize( m_pTableView->GetTabWinMap(), m_pScrollWindow->GetHScrollBar()->GetThumbPos(), m_pScrollWindow->GetVScrollBar()->GetThumbPos() );
	//	rCtrl.SaveTabFieldsWidth( m_pSelectionBox );
	rCtrl.setVisibleRows( m_pSelectionBox->GetNoneVisibleRows() );
    if ( m_aSplitter.GetSplitPosPixel() != 0 )
	    rCtrl.setSplitPos( m_aSplitter.GetSplitPosPixel() );
}
// -----------------------------------------------------------------------------
OSQLParseNode* OQueryDesignView::getPredicateTreeFromEntry(OTableFieldDescRef pEntry,
														   const String& _sCriteria,
														   ::rtl::OUString& _rsErrorMessage,
														   Reference<XPropertySet>& _rxColumn) const
{
	OSL_ENSURE(pEntry.isValid(),"Entry is null!");
	if(!pEntry.isValid())
		return NULL;
	Reference< XConnection> xConnection = static_cast<OQueryController&>(getController()).getConnection();
	if(!xConnection.is())
		return NULL;

	::connectivity::OSQLParser& rParser( static_cast<OQueryController&>(getController()).getParser() );
	OQueryTableWindow* pWin = static_cast<OQueryTableWindow*>(pEntry->GetTabWindow());

	String sTest(_sCriteria);
	// special handling for functions
	if ( pEntry->GetFunctionType() & (FKT_OTHER | FKT_AGGREGATE | FKT_NUMERIC) )
	{
		// we have a function here so we have to distinguish the type of return value
		String sFunction;
		if ( pEntry->isNumericOrAggreateFunction() )
			sFunction = pEntry->GetFunction();

        if ( !sFunction.Len() )
			sFunction = pEntry->GetField();

		if(sFunction.GetTokenCount('(') > 1)
			sFunction = sFunction.GetToken(0,'('); // this should be the name of the function

		sal_Int32 nType = ::connectivity::OSQLParser::getFunctionReturnType(sFunction,&rParser.getContext());
		if ( nType == DataType::OTHER || (!sFunction.Len() && pEntry->isNumericOrAggreateFunction()) )
		{
			// first try the international version
			::rtl::OUString sSql;
			sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SELECT * "));
			sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" FROM x WHERE "));
			sSql += pEntry->GetField();
			sSql += _sCriteria;
            ::std::auto_ptr<OSQLParseNode> pParseNode( rParser.parseTree( _rsErrorMessage, sSql, sal_True ) );
			nType = DataType::DOUBLE;
			if ( pParseNode.get() )
			{
				OSQLParseNode* pColumnRef = pParseNode->getByRule(OSQLParseNode::column_ref);
				if ( pColumnRef )
				{
					OTableFieldDescRef aField = new OTableFieldDesc();
					if ( eOk == FillDragInfo(this,pColumnRef,aField) )
					{
						nType = aField->GetDataType();
					}
				}
			}
		}

		Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
		parse::OParseColumn* pColumn = new parse::OParseColumn(	pEntry->GetField(),
																::rtl::OUString(),
																::rtl::OUString(),
                                                                ::rtl::OUString(),
																ColumnValue::NULLABLE_UNKNOWN,
																0,
																0,
																nType,
																sal_False,
																sal_False,
																xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
		_rxColumn = pColumn;
		pColumn->setFunction(sal_True);
		pColumn->setRealName(pEntry->GetField());
	}
	else
	{
		if (pWin)
		{
			Reference<XNameAccess> xColumns = pWin->GetOriginalColumns();
			if (xColumns.is() && xColumns->hasByName(pEntry->GetField()))
				xColumns->getByName(pEntry->GetField()) >>= _rxColumn;
		}
	}

	OSQLParseNode* pParseNode = rParser.predicateTree(	_rsErrorMessage,
														sTest,
														static_cast<OQueryController&>(getController()).getNumberFormatter(),
														_rxColumn);
	return pParseNode;
}
// -----------------------------------------------------------------------------
void OQueryDesignView::GetFocus()
{
	OQueryView::GetFocus();
	if ( m_pSelectionBox && !m_pSelectionBox->HasChildPathFocus() )
	{
		// first we have to deactivate the current cell to refill when nescessary
		m_pSelectionBox->DeactivateCell();
		m_pSelectionBox->ActivateCell(m_pSelectionBox->GetCurRow(), m_pSelectionBox->GetCurColumnId());
		m_pSelectionBox->GrabFocus();
	}
}
// -----------------------------------------------------------------------------
void OQueryDesignView::reset()
{
	m_pTableView->ClearAll();
	m_pTableView->ReSync();
}
// -----------------------------------------------------------------------------
void OQueryDesignView::setNoneVisbleRow(sal_Int32 _nRows)
{
	m_pSelectionBox->SetNoneVisbleRow(_nRows);
}

// -----------------------------------------------------------------------------
void OQueryDesignView::initByFieldDescriptions( const Sequence< PropertyValue >& i_rFieldDescriptions )
{
	OQueryController& rController = static_cast< OQueryController& >( getController() );

	m_pSelectionBox->PreFill();
	m_pSelectionBox->SetReadOnly( rController.isReadOnly() );
	m_pSelectionBox->Fill();

    for (   const PropertyValue* field = i_rFieldDescriptions.getConstArray();
            field != i_rFieldDescriptions.getConstArray() + i_rFieldDescriptions.getLength();
            ++field
        )
    {
        ::vos::ORef< OTableFieldDesc > pField( new OTableFieldDesc() );
        pField->Load( *field, true );
        InsertField( pField, sal_True, sal_False );
    }

    rController.ClearUndoManager();
	m_pSelectionBox->Invalidate();
}

// -----------------------------------------------------------------------------
bool OQueryDesignView::initByParseIterator( ::dbtools::SQLExceptionInfo* _pErrorInfo )
{
	SqlParseError eErrorCode = eNativeMode;
	m_rController.clearError();

    try
    {
        eErrorCode = InitFromParseNodeImpl( this, m_pSelectionBox );

        if ( eErrorCode != eOk )
	    {
	        if ( !m_rController.hasError() )
                m_rController.appendError( getParseErrorMessage( eErrorCode ) );

            if ( _pErrorInfo )
            {
                *_pErrorInfo = m_rController.getError();
            }
            else
            {
                m_rController.displayError();
            }
	    }
    }
    catch ( const Exception& )
    {
        DBG_UNHANDLED_EXCEPTION();
    }
	return eErrorCode == eOk;
}
//------------------------------------------------------------------------------
void OQueryDesignView::fillFunctionInfo(  const ::connectivity::OSQLParseNode* pNode
                                        ,const ::rtl::OUString& sFunctionTerm
                                        ,OTableFieldDescRef& aInfo)
{
    // get the type out of the funtion name
    OQueryController& rController = static_cast<OQueryController&>(getController());
	sal_Int32 nDataType = DataType::DOUBLE;
	::rtl::OUString sFieldName = sFunctionTerm;
	OSQLParseNode* pFunctionName = pNode->getChild(0);
	if ( !SQL_ISPUNCTUATION(pFunctionName,"{") )
	{
		if ( SQL_ISRULEOR2(pNode,length_exp,char_value_fct) )
			pFunctionName = pFunctionName->getChild(0);

		::rtl::OUString sFunctionName = pFunctionName->getTokenValue();
		if ( !sFunctionName.getLength() )
			sFunctionName = ::rtl::OStringToOUString(OSQLParser::TokenIDToStr(pFunctionName->getTokenID()),RTL_TEXTENCODING_UTF8);

		nDataType = OSQLParser::getFunctionReturnType(
							sFunctionName
							,&rController.getParser().getContext());
	}
	aInfo->SetDataType(nDataType);
	aInfo->SetFieldType(TAB_NORMAL_FIELD);
	aInfo->SetField(sFieldName);
	aInfo->SetTabWindow(NULL);
}
// -----------------------------------------------------------------------------