/*

* Copyright (c) 2007-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:  Class constructs SQL search clauses for MdS.*

*/

// INCLUDE FILES

#include "mdsfindsqlclause.h"

#include "mdsfindsqlclausedef.h"

#include "mdsclausebuffer.h"

#include "mdcserializationbuffer.h"

#include "mdsquerycriteriadeserialization.h"

#include "mdsobjectdef.h"

#include "mderange.h"

#include "mdsschema.h"

#include "mdsnamespacedef.h"

#include "mdspropertydef.h"

#include "mdcquery.h"

#include "mdeinternalerror.h"

const TInt KQueryBufInitialSize = 512;

// ---------------------------------------------------------------------------

// NewL

// ---------------------------------------------------------------------------

//

CMdSFindSqlClause* CMdSFindSqlClause::NewL(CMdsSchema& aSchema)

    {

    CMdSFindSqlClause* self = NewLC(aSchema);

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// NewLC

// ---------------------------------------------------------------------------

//

CMdSFindSqlClause* CMdSFindSqlClause::NewLC(CMdsSchema& aSchema)

    {

    CMdSFindSqlClause* self = new ( ELeave ) CMdSFindSqlClause(aSchema);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// ~CMdSSqlClause

// ---------------------------------------------------------------------------

//

CMdSFindSqlClause::~CMdSFindSqlClause()

    {

    delete iQueryBuf;

    iResultRow.Close();

    iVariables.Close();

    // doesn't own property definitions

	iPropertyFilters.Close();

	iFreeText.ResetAndDestroy();

	iFreeText.Close();

	if( iSourceObjectDefs )

		{

		iSourceObjectDefs->Close();

		delete iSourceObjectDefs;

		}

    }

// ---------------------------------------------------------------------------

// CMdSSqlClause

// ---------------------------------------------------------------------------

//

CMdSFindSqlClause::CMdSFindSqlClause(CMdsSchema& aSchema) : 

    iVariables(), iQueryBuf( NULL ), iSchema( aSchema ), 

    iSearchCriteria( NULL ), iSerializedBuffer( NULL ), 

    iUserLevel( EUserLevelNone ), iNamespaceDef( NULL ), iObjectDef( NULL ), 

    iSourceObjectDef ( NULL ), iSourceObjectDefs( NULL ), 

    iAppendToResultRow( ETrue ), iIncludeFreetexts( ETrue ), 

    iIncludeNotPresent( EFalse ), iNoObjectLocking( ETrue ), iPlaceholdersOnly( EFalse )

    {

    }

// ---------------------------------------------------------------------------

// ConstructL

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::ConstructL()

    {

    // Construct empty buffer for sql query

    iQueryBuf = CMdsClauseBuffer::NewL( KQueryBufInitialSize );

    iQueryBuf->AppendL( KEmpty );

    }

// ---------------------------------------------------------------------------

// AsText           Returns sql clause

// ---------------------------------------------------------------------------

//

const TDesC& CMdSFindSqlClause::AsTextL() const

    {

    return iQueryBuf->ConstBufferL();

    }

// ---------------------------------------------------------------------------

// Variables        Query variables

// ---------------------------------------------------------------------------

//

RRowData& CMdSFindSqlClause::Variables()

    {

    return iVariables;

    }

// ---------------------------------------------------------------------------

// Variables        Query result row

// ---------------------------------------------------------------------------

//

RRowData& CMdSFindSqlClause::ResultRow()

    {

    return iResultRow;

    }

// ---------------------------------------------------------------------------

// Limit        Query row limit

// ---------------------------------------------------------------------------

//

TUint32 CMdSFindSqlClause::Limit()

	{

	return iSearchCriteria->iLimit;

	}

TBool CMdSFindSqlClause::IncludesFreetexts()

	{

	return iIncludeFreetexts;

	}

TQueryType CMdSFindSqlClause::QueryType()

	{

	return (TQueryType)iSearchCriteria->iQueryType;

	}

TQueryResultMode CMdSFindSqlClause::ResultMode()

	{

	return (TQueryResultMode)iSearchCriteria->iQueryResultType;

	}

RPointerArray<HBufC>& CMdSFindSqlClause::QueryFreeText()

	{

	return iFreeText;

	}

TBool CMdSFindSqlClause::NoObjectLocking()

	{

	return iNoObjectLocking;

	}

// ---------------------------------------------------------------------------

// ObjectDef        Query object definition

// ---------------------------------------------------------------------------

//

CMdsObjectDef* CMdSFindSqlClause::ObjectDef()

	{

	return iObjectDef;

	}

RPointerArray<CMdsPropertyDef>& CMdSFindSqlClause::PropertyFilters()

	{

	return iPropertyFilters;

	}

// ---------------------------------------------------------------------------

// NamespaceDef        Query namespace definition

// ---------------------------------------------------------------------------

//

CMdsNamespaceDef* CMdSFindSqlClause::NamespaceDef()

	{

	return iNamespaceDef;

	}

// ---------------------------------------------------------------------------

// CreateL          Creates whole sql clause

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::CreateL( 

	CMdCSerializationBuffer& aSerializedCriteria, 

	TUserLevel aUserLevel )

    {

    iUserLevel = aUserLevel;

    iSerializedBuffer = &aSerializedCriteria;

    iSearchCriteria = CONST_CAST( TMdCSearchCriteria*, 

    		&TMdCSearchCriteria::GetFromBufferL( aSerializedCriteria ) );

	// can freetexts drop from results

	if( ( iSearchCriteria->iOptimizationFlags & EContainsFreetextCondition ) == 0 )

		{

		iIncludeFreetexts = EFalse;

		}

	if( iSearchCriteria->iOptimizationFlags & EContainsNotPresentCondition )

		{

		iIncludeNotPresent = ETrue;

		}

	if( iSearchCriteria->iOptimizationFlags & EContainsObjectLocking )

		{

		iNoObjectLocking = EFalse;

		}

	if( iSearchCriteria->iOptimizationFlags & EContainsPlaceholdersOnly )

        {

        iPlaceholdersOnly = ETrue;

        }

	// get namespace def from new schema definition

	iNamespaceDef = const_cast<CMdsNamespaceDef*>(iSchema.GetNamespaceByIdL( 

			iSearchCriteria->iNamespaceDefId ));

	if ( iNamespaceDef )

		{

		iNamespaceIdDes.Num( iNamespaceDef->GetId() );

		}

	else

		{

		User::Leave( KErrMdEUnknownNamespaceDef );

		}

	iObjectDef = NULL;

	if( iSearchCriteria->iObjectDefId != KNoDefId )

		{

		// get object def from new schema definition

		iObjectDef = CONST_CAST( CMdsObjectDef*, 

				iNamespaceDef->GetObjectByIdL( iSearchCriteria->iObjectDefId ) );

		if ( !iObjectDef )

			{

			User::Leave( KErrMdEUnknownObjectDef );

			}

		}

	iSourceObjectDef = NULL;

	iSourceObjectDefs = NULL;

	if ( iSearchCriteria->iObjectDefIds.iPtr.iCount > 0 )

		{

		iSourceObjectDefs = new (ELeave) RArray<TDefId>( 

				iSearchCriteria->iObjectDefIds.iPtr.iCount );

		iSourceObjectDefs->ReserveL( iSearchCriteria->iObjectDefIds.iPtr.iCount );

		iSerializedBuffer->PositionL( iSearchCriteria->iObjectDefIds.iPtr.iOffset );

		for( TUint32 i = 0; i < iSearchCriteria->iObjectDefIds.iPtr.iCount; i++ )

			{

			TDefId objectDefId;

			iSerializedBuffer->ReceiveL( objectDefId );			

			}

		}

	else

		{

		iSourceObjectDef = iObjectDef;

		}

	if( !iSourceObjectDefs )

		{

		// Construct beginning of the select clause 

		// Format: SELECT [column list/count(*)] FROM table name

		AppendSelectStatementL();

		AppendWhereStatementL();

		// if query type is object query and freetext are included

		// "GROUP BY BO.ObjectId"

		if( iIncludeFreetexts )

			{

		    AppendGroupByL();

			}

		}

	else

		{

		const TInt sourceObjectDefsCount = iSourceObjectDefs->Count();

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

			{

			const TDefId sourceObjectDefId = (*iSourceObjectDefs)[i];

			iSourceObjectDef = CONST_CAST( CMdsObjectDef*, 

					iNamespaceDef->GetObjectByIdL( sourceObjectDefId ) );

			if( i > 0 )

				{

				iAppendToResultRow = EFalse;

				iQueryBuf->AppendL( KUnionAll );

				}

			// Construct beginning of the select clause 

			// Format: SELECT [column list/count(*)] FROM table name

			AppendSelectStatementL();

			AppendWhereStatementL();

			// if query type is object query and freetext are included

			// "GROUP BY BO.ObjectId"

			if( iIncludeFreetexts )

				{

			    AppendGroupByL();

				}

			}

		}

    // ORDER BY clause (if such exists)

    AppendOrderByL();

    // LIMIT and OFFSET clauses (if such exists)

    AppendLimitAndOffsetL();

    // SQL clause must end to semicolon

    iQueryBuf->AppendL( KSemicolon );

    }

// ---------------------------------------------------------------------------

// AppendPropertyFiltersL       Appends the property filters

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendPropertyFiltersL( TBool aDistinct )

	{

	if( iSearchCriteria->iPropertyFilters.iPtr.iCount > 0 )

		{

		iSerializedBuffer->PositionL( 

				iSearchCriteria->iPropertyFilters.iPtr.iOffset );

		for ( TUint32 i = 0; i < iSearchCriteria->iPropertyFilters.iPtr.iCount; ++i )

			{

			TDefId id;

			iSerializedBuffer->ReceiveL( id );

			if ( !aDistinct )

				{

				iQueryBuf->AppendL( KComma );

				}

			AppendColumnByPropertyDefIdL( id, KNoDefId, ETrue );

			}

		iQueryBuf->AppendL( KSpace );

		}

	}

// ---------------------------------------------------------------------------

// AppendSelectStatementL       Appends the SELECT statements

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectStatementL()

    {

    switch( iSearchCriteria->iQueryType )

    	{

    	case EQueryTypeObject:

    		AppendSelectForObjectL();

    		AppendFromForObjectL();

	    	break;

	    case EQueryTypeRelation:

	    	AppendSelectForRelationL();

	    	AppendFromForRelationL();

	    	break;

        case EQueryTypeEvent:

	    	AppendSelectForEventL();

  	 		AppendFromForEventL();

	    	break;

	    default:

#ifdef _DEBUG

            User::Panic( _L("MdSFCASS") , KErrMdEUnknownQueryType );

#endif

	    	User::Leave( KErrMdEUnknownQueryType );

    	}

    }

// ---------------------------------------------------------------------------

// AppendSelectCountStatementL        SELECT statements for count query

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectCountStatementL()

    {

    // if result rows needs to be grouped return just "1"

    if( iIncludeFreetexts )

		{

		// "SELECT 1 "

		iQueryBuf->AppendL( KSelect1 );

		}

	else

		{

		// "SELECT count(*) "

    	iQueryBuf->AppendL( KSelectCount );

		}

	// expected result count

    if( iAppendToResultRow )

    	{

    	iResultRow.AppendL( TColumn( EColumnUint32 ) );

    	}

    }

// ---------------------------------------------------------------------------

// AppendSelectDistinctStatementL   SELECT statements for distinct value query

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectDistinctStatementL()

	{

	// "SELECT DISTINCT "

	iQueryBuf->AppendL( KSelectDistinct );

	const TUint32 position = iSerializedBuffer->Position();

	// "column name" (from property filter)

	AppendPropertyFiltersL( ETrue );

	iSerializedBuffer->PositionL( position );

	}

// ---------------------------------------------------------------------------

// AppendSelectObjectIdStatementL        SELECT statements for object id query

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectObjectIdStatementL()

	{

	// "SELECT BO.ObjectId "

	iQueryBuf->AppendL( KSelectObjectIds );

	// expected result object ID

	if( iAppendToResultRow )

		{

		iResultRow.AppendL( TColumn( EColumnTItemId ) );

		}

	}

// ---------------------------------------------------------------------------

// AppendSelectEventAllStatementL        SELECT statements for event query

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectAllFromEventStatementL()

	{

	// "SELECT * "

	iQueryBuf->AppendL( KSelectAllFrom );

	if( iAppendToResultRow )

		{

		// expected result Events 

	    iResultRow.AppendL( TColumn( EColumnTItemId ) );

	    iResultRow.AppendL( TColumn( EColumnTItemId ) );

	    iResultRow.AppendL( TColumn( EColumnTDefId ) );

	    iResultRow.AppendL( TColumn( EColumnTime ) );

	    iResultRow.AppendL( TColumn( EColumnDes16 ) );

	    iResultRow.AppendL( TColumn( EColumnDes16 ) );

		}

	}

// ---------------------------------------------------------------------------

// AppendSelectRelationAllStatementL        SELECT statements for Relaltion query

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectAllFromRelationStatementL()

	{

	// "SELECT * "

	iQueryBuf->AppendL( KSelectAllFrom );

	if( iAppendToResultRow )

		{

		// expected result Relation

	    iResultRow.AppendL( TColumn( EColumnTItemId ) );

	    iResultRow.AppendL( TColumn( EColumnUint32 ) );

	    iResultRow.AppendL( TColumn( EColumnTDefId ) );

	    iResultRow.AppendL( TColumn( EColumnTItemId ) );

	    iResultRow.AppendL( TColumn( EColumnTItemId ) );

	    iResultRow.AppendL( TColumn( EColumnInt32 ) );

	    iResultRow.AppendL( TColumn( EColumnInt64 ) );

	    iResultRow.AppendL( TColumn( EColumnInt64 ) );

	    iResultRow.AppendL( TColumn( EColumnTime ) );

		}

	}

// ---------------------------------------------------------------------------

// AppendSelectEventItemStatementL        SELECT statements for event id query

// ---------------------------------------------------------------------------

//

void CMdSFindSqlClause::AppendSelectEventItemStatementL()

    {

	// "SELECT Event + NamespaceId.EventId "

	iQueryBuf->AppendL( KSelectEventIds );

	iQueryBuf->AppendL( iNamespaceIdDes );

	iQueryBuf->AppendL( KDotEventId );

	if( iAppendToResultRow )

		{

		// expected result event

	    iResultRow.AppendL( TColumn( EColumnTItemId ) );

		}

    }

// ---------------------------------------------------------------------------

// AppendSelectRealtionItemStatementL        SELECT statements for Realtion id query

// ---------------------------------------------------------------------------

//AppendSelectRelationItemStatementL

void CMdSFindSqlClause::AppendSelectRealtionItemStatementL()

    {

	 //"SELECT Relation.EventId "

	iQueryBuf->AppendL( KSelectRelationIds );

    iQueryBuf->AppendL( iNamespaceIdDes );

    iQueryBuf->AppendL( KDotRelationId );

	if( iAppendToResultRow )

		{

		//expected result relation

		iResultRow.AppendL( TColumn( EColumnTItemId ) );

		}

    }

// ---------------------------------------------------------------------------

// AppendSelectObjectItemStatementL    SELECT statements for object item query