/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Manages object search from database using SQL,*

*/

#include "mdssqlfindoperation.h"

#include "mdcresult.h"

#include "mdcitem.h"

#include "mdcserializationbuffer.h"

#include "mdsfindsequence.h"

#include "mdsobjectdef.h"

#include "mdsnamespacedef.h"

#include "mdspropertydef.h"

#include "mdsfindsqlclause.h"

#include "mdsserver.h"

#include "mdsdbconnectionpool.h"

#include "mdeinternalerror.h"

const TInt KMaxResultSize = 1024*256; // 256 KiB

CMdSSqlFindOperation* CMdSSqlFindOperation::NewL(

    CMdSFindSequence& aFind,

    TUint aSetSize

    )

    {

    CMdSSqlFindOperation* that = CMdSSqlFindOperation::NewLC(

        aFind, aSetSize );

    CleanupStack::Pop( that );

    return that;

    }

CMdSSqlFindOperation* CMdSSqlFindOperation::NewLC(    

    CMdSFindSequence& aFind,

    TUint aSetSize

    )

    {

    CMdSSqlFindOperation* that = new (ELeave) CMdSSqlFindOperation(        

        aFind, 

        aSetSize

        );

    CleanupStack::PushL( that );

    that->ConstructL();

    return that;

    }

CMdSSqlFindOperation::CMdSSqlFindOperation(    

    CMdSFindSequence& aFind,

    TUint aSetSize

    )

    : iResultMode( EQueryResultModeFirst ), iResultRow(NULL),

    iResultRows(), iResultCount( 0 ), iResults( NULL ), iFind ( aFind ),

    iState( EStateIdle ), iSetSize( aSetSize ), iLimit( 0 ), 

    iLimitCounter( 0 ), iMemoryLimit( 0 ), 

    iHarvestingPrioritizationCount( 0 )

    {

    }

void CMdSSqlFindOperation::ConstructL()

    {    

	iFindClause = CMdSFindSqlClause::NewL( const_cast<CMdsSchema&>(iFind.Schema()) );	

    }

CMdSSqlFindOperation::~CMdSSqlFindOperation()

    {

	ConsumeRows();

    iResultRows.Close();

    iResultIds.Close();

    // doesn't own result row

    iResultRow = NULL;

    iQueryId.Close();

   	delete iResults;

   	delete iFindClause;

    }

TInt CMdSSqlFindOperation::ExecuteL()

    {

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

    iResultRow = &iFindClause->ResultRow();

    iQueryType = iFindClause->QueryType();

    iResultMode = iFindClause->ResultMode();

	if( EQueryResultModeFirst >= iResultMode || EQueryResultModeLast <= iResultMode )

		{

#ifdef _DEBUG

		User::Panic( _L("MdSFOExe") , KErrMdEUnknownQueryResultMode );

#endif

		User::Leave( KErrMdEUnknownQueryResultMode );

		}

   	iFind.SetResultMode( iQueryType == EQueryTypeObject && iResultMode == EQueryResultModeItem );

   	connection.ExecuteQueryL( iFindClause->AsTextL(), iQueryId, iFindClause->Variables() );

    iState = EStateRunning;

	iSetCounter = 0;

	iMemoryLimit = 0;

	iHarvestingPrioritizationCount = 0;

    return FetchResultsL();

    }

TInt CMdSSqlFindOperation::ContinueL()

    {

    // Continue query: fetch next row

    iSetCounter = 0;

    iState = EStateRunning;

    return FetchResultsL();

    }

TInt CMdSSqlFindOperation::FetchResultsL()

    {

	iMemoryLimit += EstimateBaseResultSize();

	if( !iResultRow )

		{

#ifdef _DEBUG

		User::Panic( _L("MdSFOFe1") , KErrCorrupt );

#endif

		User::Leave( KErrCorrupt );

		}

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

    while( ETrue )

        {

        RRowData* resultRow = new (ELeave) RRowData();        

        CleanupStack::PushL( resultRow );

        CleanupClosePushL( *resultRow );

        resultRow->AppendColumnTypesL( *iResultRow );

        // fetch next DB row

        if ( !connection.NextRowL( iQueryId, *resultRow ) )

            {

            CleanupStack::PopAndDestroy( 2, resultRow ); // close and delete resultRow separately

            resultRow = NULL;

           	TRAPD( err, AddToContainerL() );

           	if( KErrNone != err )

           		{

           		iResults = NULL;

           		ConsumeRows();

           		}

           	connection.Terminate( iQueryId );

            iState = EStateDead;

            return KErrNone;

            }

        iMemoryLimit += EstimateResultRowSizeL( *resultRow );

		// Check if maximum memory limit is reached or 

		// set/limit counter is more than maximum set/limit size. 

		if( KMaxResultSize <= iMemoryLimit )

			{

			// Store all previus items to result buffer.

           	TRAPD( err, AddToContainerL() );

           	if( KErrNone != err )

           		{

           		iResults = NULL;

           		ConsumeRows();

           		}

			// add estimated size to next result set

	        iMemoryLimit = EstimateResultRowSizeL( *resultRow );

			if( EQueryResultModeItem == iResultMode || EQueryResultModeDistinctValues == iResultMode )

				{

				// add result row to result rows pointer array

	           	iResultRows.AppendL( resultRow );

				iSetCounter++;

				// pop result row from cleanup stack twice

				CleanupStack::Pop( 2, resultRow );

				}

			else

				{

				if( EQueryResultModeId == iResultMode )

					{					

					TItemId itemId = 0;

					resultRow->Column( 0 ).Get( itemId );

					iResultIds.AppendL( itemId );

					iSetCounter++;

					}

				else

					{

					TUint32 count;

					resultRow->Column( 0 ).Get( count );

					iResultCount += count;

					}

				// pop and destroy result row from cleanup stack twice

				CleanupStack::PopAndDestroy( 2, resultRow );

				}

			resultRow = NULL;

           	++iLimitCounter;

            iState = EStateIdle;

            connection.EnableTransaction( EFalse, iQueryId );

            return KFindSetReady;

			}

		else

			{

			if( EQueryResultModeItem == iResultMode || EQueryResultModeDistinctValues == iResultMode )

				{

				// add result row to result rows pointer array

	           	iResultRows.AppendL( resultRow );

				iSetCounter++;

				// pop result row from cleanup stack twice

				CleanupStack::Pop( 2, resultRow );

				}

			else 

				{

				if( EQueryResultModeId == iResultMode )

					{					

					TItemId itemId = 0;

					resultRow->Column( 0 ).Get( itemId );

					iResultIds.AppendL( itemId ); 

					iSetCounter++;

					}

				else

					{

					TUint32 count;

					resultRow->Column( 0 ).Get( count );

					iResultCount += count;

					}

				// pop and destroy result row from cleanup stack twice

				CleanupStack::PopAndDestroy( 2, resultRow );

				}

			resultRow = NULL;

			++iLimitCounter;

			}

        // check for different exit conditions

        if ( iState == EStateRunning )

            {

            if ( iLimitCounter >= iLimit )

                {

	           	TRAPD( err, AddToContainerL() );

	           	if( KErrNone != err )

	           		{

	           		iResults = NULL;

	           		ConsumeRows();

	           		}

	           	connection.Terminate( iQueryId );

                iState = EStateDead;

                return KErrNone;

                }

            else if( iSetCounter >= iSetSize )

                {

	           	TRAPD( err, AddToContainerL() );

	           	if( KErrNone != err )

	           		{

	           		iResults = NULL;

	           		ConsumeRows();

	           		}

                iState = EStateIdle;

                connection.EnableTransaction( EFalse, iQueryId );

                return KFindSetReady;

                }

            }

        else if ( iState == EStateStop )

            {

            // stop instructed

            connection.Terminate( iQueryId );

            iState = EStateDead;

            return KErrCancel;

            }

        else 

            {

#ifdef _DEBUG

	    	User::Panic( _L("MdSFOFe2") , KErrCorrupt );

#endif

	    	User::Leave( KErrCorrupt );

            }

        }

    }

TInt CMdSSqlFindOperation::EstimateBaseResultSize()

	{

	switch( iResultMode )

		{

		case EQueryResultModeItem:

			return sizeof(TMdCItems);

		case EQueryResultModeId:

			return sizeof(TMdCItemIds);

		case EQueryResultModeCount:

			return sizeof(TMdCItemCounts);

		case EQueryResultModeDistinctValues:

			return sizeof(TMdCItemIds);

		// should never happen

		default:

#ifdef _DEBUG

			User::Panic( _L( "MdSFOEBS" ), KErrMdEUnknownQueryResultMode );

#endif

			return 0;

		}

	}

TInt CMdSSqlFindOperation::EstimateResultRowSizeL( RRowData& aRow )

	{

	if( iResultMode == EQueryResultModeId )

		{

		return CMdCSerializationBuffer::KRequiredSizeForTItemId;

		}

	else if( iResultMode == EQueryResultModeCount )

		{

		return 0;

		}

	else if( iResultMode == EQueryResultModeDistinctValues )

		{

		if( iFindClause->PropertyFilters().Count() != 1 )

			{

			User::Leave( KErrCorrupt );

			}

		const RPointerArray<CMdsPropertyDef>& propertyFilters = iFindClause->PropertyFilters();

		TInt rowSize = 0;

		if( propertyFilters[0]->GetType() == EPropertyText )

	    	{

	    	if ( !aRow.Column( 0 ).IsNull() )

	    		{

				// Required size for text property

				TPtrC16 value = TPtr16((TUint16*)0, 0);

				aRow.Column( 0 ).Get( value );

				rowSize += CMdCSerializationBuffer::RequiredSize( value );

	    		}	    		

	    	}

	    else

	    	{

#ifdef _DEBUG

	    	User::Panic( _L("MdSFOEs1") , KErrMdEUnknownPropertyType );

#endif

	    	User::Leave( KErrMdEUnknownPropertyType );

	    	}

	    return rowSize;

		}

	switch( iQueryType )

		{

		case EQueryTypeObject:

			{

			TInt rowSize = sizeof(TMdCObject);

			const TInt KUriColumn = 7;

			TPtrC16 uri = TPtr16((TUint16*)0, 0);

			// Required size for object URI

			if (!aRow.Column( KUriColumn ).IsNull())

				{

				aRow.Column( KUriColumn ).Get( uri );

				rowSize += CMdCSerializationBuffer::RequiredSize( uri );

				}

			if( iFindClause->NoObjectLocking() && iFindClause->ObjectDef() && iFindClause->ObjectDef()->GetId() != KBaseObjectDefId )

				{

				// check if object is placeholder and add it to count of harvester 

				// prioritization URIs

				const TInt KFlagsColumn = 2;

				TUint32 flags = 0;

				aRow.Column( KFlagsColumn ).Get( flags );

				if( flags & EMdEObjectFlagPlaceholder )

					{

					if( iFind.Server().ReserveSpaceHarvestingPrioritizationUri( uri ) )

						{

						iHarvestingPrioritizationCount++;

						}

					}

				}

			// Required size for properties

			CMdsObjectDef* objectDef = iFindClause->ObjectDef();

			if( !objectDef )

				{

#ifdef _DEBUG

				User::Panic( _L("MdSFOEs2") , KErrMdEUnknownObjectDef );

#endif

				User::Leave( KErrMdEUnknownObjectDef );

				}

			const RPointerArray<CMdsPropertyDef>& propertyFilters = iFindClause->PropertyFilters();

			// no property filterss

			if( propertyFilters.Count() <= 0 )

				{

				const TInt count = objectDef->GetAllPropertiesCount();

				// space for every property, even if it's "null"

				rowSize += count * sizeof(TMdCProperty);

				for( TInt i = 0; i < count; i++ )

					{

					const CMdsObjectDef::TMdsColumnOrder& propertyColumn = 

						objectDef->GetPropertyColumnL( i );

					TColumn& column = aRow.Column( propertyColumn.iColumnId );

					if( column.IsNull() )

						{

						continue;

						}

					if( propertyColumn.iPropertyDef.GetType() == EPropertyText )

				    	{

						// Required size for text in text property

						TPtrC16 value = TPtr16((TUint16*)0, 0);

						column.Get( value );

						rowSize += CMdCSerializationBuffer::RequiredSize( value );

				    	}

					}

				}

			// property filters

			else

				{

				const TInt count = propertyFilters.Count();

				// space for every property, even if it's "null"

				rowSize += count * sizeof(TMdCProperty);

				for( TInt i = 0; i < count; i++ )

					{

					CMdsPropertyDef* propDef = propertyFilters[i];

					if( !propDef )

						{

#ifdef _DEBUG

						User::Panic( _L("MdSFOEs3") , KErrMdEUnknownPropertyDef );

#endif						

						User::Leave( KErrMdEUnknownPropertyDef );

						}

					TColumn& column = aRow.Column( KBaseObjectBasicValueColumnOffset + i );

					if( column.IsNull() )

						{

						continue;

						}

					if( propDef->GetType() == EPropertyText )

				    	{

						// Required size for text in text property

						TPtrC16 value = TPtr16((TUint16*)0, 0);

						column.Get( value );

						rowSize += CMdCSerializationBuffer::RequiredSize( value );

				    	}

					}

				}

			if( FindCriteria().IncludesFreetexts() )

				{

				// In result row the second lastest column is free text count

				const TInt freeTextCountColumn = aRow.Size() - 2;

				// Get free text count

				TUint32 freeTextCount = 0;

				aRow.Column( freeTextCountColumn ).Get( freeTextCount );

				if( freeTextCount > 0 )

					{

					// In result row last column is total free text length

					const TInt totalFreeTextsLengthColumn = aRow.Size() - 1;

					// Get total free text length.

					TUint32 totalFreeTextsLength = 0;

					aRow.Column( totalFreeTextsLengthColumn ).Get( totalFreeTextsLength );

					// Required size for free texts.

					// For every free text length (TUint16) 

					rowSize += freeTextCount * ( CMdCSerializationBuffer::KRequiredSizeForEmptyText );

					// and total free text length * TUint16

					rowSize += totalFreeTextsLength * sizeof( TUint16 );

					}

				}

			return rowSize;

			}

		case EQueryTypeRelation:

			return sizeof(TMdCRelation);