/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Defines the class which implements SCR's service requests.

*

*/

/**

 @file

 @internalComponent

 @released

*/

#include "scrrequestimpl.h"

#include "scrdatabase.h"

#include "screntries.h"

#include "scrserver.h"

#include "scrcommon.h"

#include "scrsubsession.h"

#include "usiflog.h"

#include "usiferror.h"

#include <s32mem.h>

#include <bautils.h>

#include <scs/streamingarray.h>

#include <scs/ipcstream.h>

#include <scs/ipcstream.inl>

#include <scs/cleanuputils.h>

#include <e32hashtab.h>

#include <usif/sts/sts.h>

using namespace Usif;

_LIT(KComponentIdColumnName, "ComponentId"); 

_LIT(KCompFileIdColumnName, "CmpFileId"); 

_LIT(KComponentPropertiesTable, "ComponentProperties");

_LIT(KFilePropertiesTable, "FileProperties");

/** Maximum number of log records could be recorded by SCR. */

// It is estimated that a thousand log entries create 40K-100K log file.

const TInt KMaxScrLogEntries = 1000;

/** The file path of SCR log file. */

_LIT(KScrLogFileName, "!:\\private\\10285bc0\\scr.log");

/** The file path of SCR temporary log file. */

_LIT(KScrTempLogFileName, "!:\\private\\10285bc0\\scr_tmp.log");

const TUint KDbInterfaceMajorVersion = 1;

const TUint KDbInterfaceMinorVersion = 1;

#ifdef _DEBUG

const TUint KDbInterfaceBuildNumber = 1;

#endif

enum TScrPanicId

	{

	KScrIllegalCallSequence = 1,

	KScrIllegalParameter = 2

	};

static void PanicClient(const RMessagePtr2& aMessage, TScrPanicId aPanic)

	{

	_LIT(KPanicMessage, "ScrServer");

    aMessage.Panic(KPanicMessage, aPanic);

    }

HBufC* UpdateFilePathDriveLC(const TDesC& aFilePath, TChar aDrive)

	{

	HBufC *fileName = HBufC::NewLC(aFilePath.Length());

	TPtr ptrFileName(fileName->Des());

	ptrFileName.Copy(aFilePath);

	ptrFileName[0] = aDrive;

	return fileName; 

	}	

////////////////////////

// CScrRequestImpl

////////////////////////

CScrRequestImpl::CScrRequestImpl(RFs& aFs)

	: iFs(aFs)

	{

	}

CScrRequestImpl::~CScrRequestImpl()

	{

	delete iDbHandle;

	delete iComponentEntry;

	iProperties.ResetAndDestroy();

	delete iSingleProperty;

	iFileComponents.Close();

	iVerCompIdList.ResetAndDestroy();

	iDeletedMimeTypes.ResetAndDestroy();

	iLogEntries.ResetAndDestroy();

	iMatchingSupportedLanguageList.Close();

	}

CScrRequestImpl* CScrRequestImpl::CScrRequestImpl::NewL(RFs& aFs, RFile& aDatabaseFile, RFile& aJournalFile)

	{

	CScrRequestImpl *self = new(ELeave) CScrRequestImpl(aFs);

	CleanupStack::PushL(self);

	self->ConstructL(aDatabaseFile, aJournalFile);

	CleanupStack::Pop(self);

	return self;

	}

void CScrRequestImpl::ConstructL(RFile& aDatabaseFile, RFile& aJournalFile)

	{

	iDbHandle = CDatabase::NewL(aDatabaseFile, aJournalFile);

	InitializeDbVersionL();

	VerifyDbVersionCompatibilityL();

	// Make sure that private directory exists - required for temporary and log files

	_LIT(KPrivateDirPath, "!:\\private\\10285bc0\\");

	HBufC* privateDirPath = UpdateFilePathDriveLC(KPrivateDirPath, iFs.GetSystemDriveChar());

	TInt res = iFs.MkDirAll(*privateDirPath);

	__ASSERT_ALWAYS(res == KErrNone || res == KErrAlreadyExists, User::Leave(res));

	CleanupStack::PopAndDestroy(privateDirPath);

	}

HBufC* CScrRequestImpl::ReadDescLC(const RMessage2& aMessage, TInt aSlot)

	{

	TInt len = aMessage.GetDesLengthL(aSlot);

	HBufC* desc = HBufC::NewLC(len);

	TPtr ptrDesc(desc->Des());

	aMessage.ReadL(aSlot, ptrDesc);

	return desc;

	}

HBufC8* CScrRequestImpl::ReadDesc8LC(const RMessage2& aMessage, TInt aSlot)

	{

	TInt len = aMessage.GetDesLengthL(aSlot);

	HBufC8* desc = HBufC8::NewLC(len);

	TPtr8 ptrDesc(desc->Des());

	aMessage.ReadL(aSlot, ptrDesc);

	return desc;

	}

HBufC* CScrRequestImpl::FormatStatementLC(const TDesC& aStatement, TInt aFormattedLength,...) const

	{

	VA_LIST list;

	VA_START(list, aFormattedLength);

	HBufC* statementStr = HBufC::NewLC(aStatement.Length() + aFormattedLength + 1);

	TPtr statementStrPtr(statementStr->Des()); 

	statementStrPtr.FormatList(aStatement, list);

	VA_END(list);

	// SQLite requires the statement string to end with NULL char.

	statementStrPtr.Append('\0');

	return statementStr;

	}

void CScrRequestImpl::CreateTransactionL()

	{

	DEBUG_PRINTF(_L8("Create Transaction request received."));

	_LIT(KBeginTransaction, "BEGIN IMMEDIATE;");

	ExecuteStatementL(KBeginTransaction());	

	DEBUG_PRINTF(_L8("Transaction has begun!"));

	}

void CScrRequestImpl::RollbackTransactionL()

	{

	DEBUG_PRINTF(_L8("Rollback Transaction request received."));

	_LIT(KRollbackTransaction, "ROLLBACK;");

	ExecuteStatementL(KRollbackTransaction());

	DEBUG_PRINTF(_L8("Transaction has been rolled back successfuly!"));

	}

void CScrRequestImpl::CommitTransactionL()

	{

	DEBUG_PRINTF(_L8("Commit Transaction request received."));

	_LIT(KCommitTransaction, "COMMIT;");

	ExecuteStatementL(KCommitTransaction());

	DEBUG_PRINTF(_L8("Transaction has been committed successfully!"));

	}

HBufC* CScrRequestImpl::GenerateGlobalIdL(const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId) const

	{ 

	HBufC *globalIdBuf = HBufC::NewL(aUniqueSwTypeName.Length() + aGlobalId.Length() + 1); // 1 is extra memory to put NULL char

	TPtr globalIdDes(globalIdBuf->Des());

	globalIdDes.Copy(aUniqueSwTypeName);

	globalIdDes.Append('\0');

	globalIdDes.Append(aGlobalId);

	return globalIdBuf;

	}

TComponentId CScrRequestImpl::CommonAddComponentL(const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId)

	{

	DEBUG_PRINTF(_L8("Adding a base component."));

	// Get the current time

	TTime time;

	time.HomeTime();

	TDateTime datetime = time.DateTime();

	TBuf<16> installTime;

	// We cannot use TTime::FormatL, since it starts months and days with 01, which is not accepted by TTime::Set() which starts them from 0

	installTime.Format(_L("%04d%02d%02d:%02d%02d%02d"), datetime.Year(), datetime.Month(), datetime.Day(), datetime.Hour(), datetime.Minute(), datetime.Second());

	// SoftwareTypeId is the hash of unique software type name. For more information, see CScrRequestImpl::AddSoftwareTypeL.

	// In Components table, both SoftwareTypeId and unique SoftwareTypeName is stored so that the software type name of a component

	// can be returned even if the corresponding installer (software type) has been uninstalled. The unique sofware type name

	// might be used by the client to identify the installer required to uninstall the component.

	TUint32 swTypeId = HashCaseSensitiveL(aUniqueSwTypeName);

	if(aGlobalId.CompareF(KNullDesC()))

		{ // Global Id is supplied by client

		HBufC *globalId = GenerateGlobalIdL(aUniqueSwTypeName, aGlobalId);

		CleanupStack::PushL(globalId);

		TUint32 globalIdHash = HashCaseSensitiveL(*globalId);

		_LIT(KInsertComponent,"INSERT INTO Components(SoftwareTypeId,SoftwareTypeName,GlobalIdHash,GlobalId,InstallTime) VALUES(?,?,?,?,?);");

		TInt numberOfValues = 5;

		ExecuteStatementL(KInsertComponent(), numberOfValues, EValueInteger, swTypeId, EValueString, &aUniqueSwTypeName, EValueInteger, globalIdHash, EValueString, globalId, EValueString, &installTime);

		CleanupStack::PopAndDestroy(globalId);

		}

	else

		{// Global Id is NOT supplied by client

		_LIT(KInsertComponent,"INSERT INTO Components(SoftwareTypeId,SoftwareTypeName,InstallTime) VALUES(?,?,?);");

		TInt numberOfValues = 3;

		ExecuteStatementL(KInsertComponent(), numberOfValues, EValueInteger, swTypeId, EValueString, &aUniqueSwTypeName, EValueString, &installTime);

		}

	DEBUG_PRINTF(_L8("The new component has been added to Components table successfully."));

	return iDbHandle->LastInsertedIdL();

	}

void CScrRequestImpl::AddComponentLocalizablesL(TComponentId aCompId, TLanguage aLocale, const TDesC& aName, const TDesC& aVendor)

	{

	DEBUG_PRINTF4(_L("Adding the component(%d) localizables: name(%S) and vendor(%S)."), aCompId, &aName, &aVendor);

	if(!aName.CompareF(KNullDesC()))

		{// Component name cannot be empty

		DEBUG_PRINTF(_L8("Component name cannot be NULL string."));

		User::Leave(KErrArgument);

		}

	_LIT(KInsertComponentLocalizables, "INSERT INTO ComponentLocalizables(ComponentId,Locale,Name,Vendor) VALUES(?,?,?,?);");

	TInt numberOfValues = 4;

	ExecuteStatementL(KInsertComponentLocalizables(), numberOfValues, EValueInteger, aCompId, EValueInteger, aLocale, EValueString, &aName, EValueString, &aVendor);

	DEBUG_PRINTF(_L8("The component localizables have been added successfully."));

	}

void CScrRequestImpl::ComponentRollback(TAny* aParam)

	{

	TRollbackParams *param = static_cast<TRollbackParams*>(aParam);

	_LIT(KDeleteComponents, "DELETE FROM Components WHERE ComponentId=?;");

	TInt numberOfValues = 1;

	TRAP_IGNORE(param->iReqImplHandle.ExecuteStatementL(KDeleteComponents, numberOfValues, EValueInteger, param->iIdColumnVal););

	}

void CScrRequestImpl::ComponentLocalizablesRollback(TAny* aParam)

	{

	TRollbackParams *param = static_cast<TRollbackParams*>(aParam);

	_LIT(KDeleteComponentLocalizables, "DELETE FROM ComponentLocalizables WHERE ComponentId=?;");

	TInt numberOfValues = 1;

	TRAP_IGNORE(param->iReqImplHandle.ExecuteStatementL(KDeleteComponentLocalizables, numberOfValues, EValueInteger, param->iIdColumnVal););

	}

void CScrRequestImpl::AddComponentL(const RMessage2& aMessage)

	{

	DEBUG_PRINTF(_L8("Adding a new component."));

	// First check if the supplied operation type is valid

	TScrComponentOperationType compOpType;

	TPckg<TScrComponentOperationType> opTypePckg(compOpType);

	aMessage.ReadL(3, opTypePckg, 0);

	if(compOpType != EScrCompInstall && compOpType != EScrCompUpgrade && compOpType != EScrCompHidden)

		{

		DEBUG_PRINTF2(_L("Unexpected component operation type (%d) was provided!"), static_cast<TInt>(compOpType));

		User::Leave(KErrArgument);

		}

	RIpcReadStream componentInfoReader;

	CleanupClosePushL(componentInfoReader);

	componentInfoReader.Open(aMessage, 1);

	RPointerArray<CLocalizableComponentInfo> componentInfoArray;

	CleanupResetAndDestroyPushL(componentInfoArray);

	InternalizePointersArrayL(componentInfoArray, componentInfoReader);

	TInt arrayCount = componentInfoArray.Count();

	// This check is done at the client side - if we get this condition here, this means that a rogue client-server call bypassed the R-class

	__ASSERT_ALWAYS(arrayCount > 0, PanicClient(aMessage, KScrIllegalParameter));

	HBufC *uniqueSwTypeName = GetSoftwareTypeNameFromMsgLC(aMessage);

	HBufC *globalId = ReadDescLC(aMessage, 2);

	TComponentId newComponentId = CommonAddComponentL(*uniqueSwTypeName, *globalId);

	// Add the newly added component into the cleanupstack so that it can be deleted in case of leaving.

	TRollbackParams cleanupParam(newComponentId, *this);

	CleanupStack::PushL(TCleanupItem(CScrRequestImpl::ComponentRollback, &cleanupParam));

	// Add the component localizables cleanup into the cleanupstack so that they can be deleted in case of leaving.

	CleanupStack::PushL(TCleanupItem(CScrRequestImpl::ComponentLocalizablesRollback, &cleanupParam));

	// For a log record, the component name is chosen for the current locale. If it doesn't exist, 

	// then the non-localized component name is picked. If none of them exist, the first name in the names 

	// array is used as default.

	TInt componentNameIndexForLog (0);

	TInt indexForCurrentLocale = KErrNotFound;

	TInt indexForNonLocalized = KErrNotFound;

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

		{

		TLanguage locale(componentInfoArray[i]->Locale());

		const TDesC& name = componentInfoArray[i]->NameL();

		const TDesC& vendor = componentInfoArray[i]->VendorL();

		AddComponentLocalizablesL(newComponentId, locale, name, vendor);

		if(locale == User::Language())

			indexForCurrentLocale = i;

		else if(locale == KNonLocalized)

			indexForNonLocalized = i;

		}

	CleanupStack::Pop(2, &cleanupParam); // cleanupitem for ComponentRollback, cleanupitem for ComponentLocalizablesRollback

	if(indexForCurrentLocale != KErrNotFound)

		componentNameIndexForLog = indexForCurrentLocale;

	else if(indexForNonLocalized != KErrNotFound)

		componentNameIndexForLog = indexForNonLocalized;

	if(EScrCompHidden != compOpType)

		{

		CScrLogEntry *logRecord = CScrLogEntry::NewLC(componentInfoArray[componentNameIndexForLog]->NameL(), *uniqueSwTypeName, *globalId, KNullDesC, compOpType);

		logRecord->iComponentId = newComponentId;

		iLogEntries.Append(logRecord);

		CleanupStack::Pop(logRecord); // Ownershipd is transferred

		}

	CleanupStack::PopAndDestroy(4, &componentInfoReader); // componentInfoReader, componentInfoArray, uniqueSwTypeName, globalId

	TPckg<TComponentId> componentIdDes(newComponentId);

	aMessage.WriteL(3, componentIdDes);

	}

HBufC* CScrRequestImpl::ReadAndGetGlobalIdLC(const RMessage2& aMessage, TInt aSlot) const

	{

	// Read global id object from the message

	CGlobalComponentId *globalId = ReadObjectFromMessageLC<CGlobalComponentId>(aMessage, aSlot);

	HBufC *globalIdBuf = GenerateGlobalIdL(globalId->SoftwareTypeName(), globalId->GlobalIdName());

	CleanupStack::PopAndDestroy(globalId);

	CleanupStack::PushL(globalIdBuf);

	return globalIdBuf;

	}

TUint32 CScrRequestImpl::HashGlobalIdsL(const TDesC& aDependantId, const TDesC& aSupplierId) const

	{

	RBuf concatGlobalIds;

	concatGlobalIds.CreateL(aDependantId.Length() + aSupplierId.Length());

	concatGlobalIds.CleanupClosePushL();

	concatGlobalIds.Copy(aDependantId);

	concatGlobalIds.Append(aSupplierId);

	TUint32 globalIdsHash = HashCaseSensitiveL(concatGlobalIds);

	CleanupStack::PopAndDestroy(&concatGlobalIds);

	return globalIdsHash;

	}

void CScrRequestImpl::AddComponentDependencyL(const RMessage2& aMessage)

	{

	DEBUG_PRINTF(_L8("Adding a new component dependency."));

	CVersionedComponentId *verCompId = ReadObjectFromMessageLC<CVersionedComponentId>(aMessage, 1);

	HBufC *suppGlobalId = GenerateGlobalIdL(verCompId->GlobalId().SoftwareTypeName(), verCompId->GlobalId().GlobalIdName());

	CleanupStack::PushL(suppGlobalId);

	TUint32 suppGlobalIdHash = HashCaseSensitiveL(*suppGlobalId);

	HBufC *depGlobalId = ReadAndGetGlobalIdLC(aMessage, 2);

	TUint32 depGlobalIdHash = HashCaseSensitiveL(*depGlobalId);

	TUint32 globalIdsHash = HashGlobalIdsL(*depGlobalId, *suppGlobalId);

	const TDesC* versionFrom = verCompId->VersionFrom();

	const TDesC* versionTo = verCompId->VersionTo();

	_LIT(KInsertDependencyFront, "INSERT INTO ComponentDependencies(GlobalIdHash,DependantGlobalIdHash,SupplierGlobalIdHash,DependantGlobalId,SupplierGlobalId");

	_LIT(KInsertDependencyEnd, ") VALUES(?,?,?,?,?");

	const TInt KMaxInsertDependencyLength = 180;     ///< Maximum length of a possible dependency insert statement (KInsertDependencyFront + KInsertDependencyEnd + some space for optional columns)

	const TInt KMaxInsertDependencyValueLength = 30; ///< Maximum length of the end part of a possible dependency insert statement (KInsertDependencyEnd + some space for optional values).

	TInt numberOfValues = 5; // 5->(GlobalIdHash, DependantGlobalIdHash, SupplierGlobalIdHash, DependantGlobalId, SupplierGlobalId)

	RBuf insertStmtStr;

	insertStmtStr.CreateL(KMaxInsertDependencyLength);

	insertStmtStr.CleanupClosePushL();

	insertStmtStr.Copy(KInsertDependencyFront());

	RBuf insertStmtEndStr;

	insertStmtEndStr.CreateL(KMaxInsertDependencyValueLength);

	insertStmtEndStr.CleanupClosePushL();

	insertStmtEndStr.Copy(KInsertDependencyEnd());

	// VersionFrom and VersionTo values are optional. Hence, a dynamic insert statement will be created.

	// insertStmtStr is initialized with the statement including mandatory columns. Then versionFrom/To

	// values are checked. If any of them is provided, then the corresponding column name is added to the statement.

	// insertStmtEndStr is constructed with a number of value characters(?) as new value chars will be added

	// if new columns are added to the statement

	// In the end, insertStmtEndStr is added to insertStmtStr in order to complete the dependency insert statement.

	const TDesC* firstVersionParam(0);

	const TDesC* secondVersionParam(0);

	_LIT(KInsertValue, ",?");

	if(versionFrom)

		{

		_LIT(KVersionFrom, ",VersionFrom");

		insertStmtStr.Append(KVersionFrom());

		insertStmtEndStr.Append(KInsertValue());

		firstVersionParam = versionFrom;

		++numberOfValues;

		}

	if(versionTo)

		{

		_LIT(KVersionTo, ",VersionTo");

		insertStmtStr.Append(KVersionTo());

		insertStmtEndStr.Append(KInsertValue());

		if(firstVersionParam)

			{

			secondVersionParam = versionTo;

			}

		else

			{

			firstVersionParam = versionTo;

			}

		++numberOfValues;

		}

	// Append the end part of the statement to the front part.

	insertStmtStr.Append(insertStmtEndStr);

	// Close the statement

	_LIT(KInsertClose,");");

	insertStmtStr.Append(KInsertClose());

	// SQLite requires the statement string to end with NULL char.

	insertStmtStr.Append('\0');

	// All parameters are supplied, but numberOfValues of them will be taken into account.

	ExecuteStatementL(insertStmtStr, numberOfValues, EValueInteger, globalIdsHash, EValueInteger, depGlobalIdHash, EValueInteger, suppGlobalIdHash, EValueString, depGlobalId, EValueString, suppGlobalId, EValueString, firstVersionParam, EValueString, secondVersionParam);

	CleanupStack::PopAndDestroy(5, verCompId); // verCompId, suppGlobalId, depGlobalId, insertStmtStr, insertStmtEndStr

	}

CStatement* CScrRequestImpl::CreateGeneralPropertyStatementWithLocaleL(const TDesC& aStmtStr, TInt aIdColumnValue, TLanguage aLocale, const TDesC& aPropName, TBool aDoLocaleResolving) const

	{

	CStatement *stmt(0);

	TInt numberOfValues = 3;

	if(KUnspecifiedLocale == aLocale)

		{

		// No locale is specified. Client wants SCR to find the property automatically.

		// So, first look up the properties for the current locale and its downgraded languages.

		ASSERT(aDoLocaleResolving); // We cannot get a situation where KUnspecifiedLocale is given with locale resolving disabled: it is an undefined state.

		stmt = CreateStatementObjectWithLocaleL(aStmtStr, User::Language(), numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage);

		if(!stmt)

			{

			// No property is defined with the current locale. Look up the non-localized properties.

			stmt = CreateStatementObjectWithLocaleL(aStmtStr, KNonLocalized, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage);

			}

		}

	else if(KNonLocalized == aLocale)

		{

		// Non-localized properties are requested. Look up the non-localized properties.

		stmt = CreateStatementObjectWithLocaleL(aStmtStr, KNonLocalized, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage);

		}

	else

		{

		// A particular language is specified. Look up the properties with for this particular language

		// and its downgraded languages.

		stmt = aDoLocaleResolving ? 

			CreateStatementObjectWithLocaleL(aStmtStr, aLocale, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage, aDoLocaleResolving) :

			CreateStatementObjectWithLocaleNoDowngradeL(aStmtStr, aLocale, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage, aDoLocaleResolving);

		}

	return stmt;

	}

TInt CScrRequestImpl::FindGeneralPropertyNoLocaleDowngradeL(const TDesC& aTableName, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropertyName, TLanguage aLocale, TPropertyType& aPropertyType) const

	{

	_LIT(KFindProperty, "SELECT PropertyId,IntValue,StrValue,IsStr8Bit FROM %S WHERE Name=? AND %S=? AND Locale=?;");

	TInt formattedLen = aTableName.Length() + aIdColumnName.Length();

	HBufC *statementStr = FormatStatementLC(KFindProperty(), formattedLen, &aTableName, &aIdColumnName);

	// As we do not require downgrading locales, the last parameter is EFalse

	CStatement *stmtFind = CreateGeneralPropertyStatementWithLocaleL(*statementStr, aIdColumnValue, aLocale, aPropertyName, EFalse);

	if(!stmtFind)

		{ // the property does not exist, return

		CleanupStack::PopAndDestroy(statementStr);

		return KErrNotFound;

		}

	CleanupStack::PushL(stmtFind);

	// the property in question exists in the properties table 

	TInt propertyId = stmtFind->IntColumnL(0);					// 0 -> PropertyId		

	TBool isIntPropertyNull = stmtFind->IsFieldNullL(1); 	// 2 -> IntValue

	TBool isStrPropertyNull = stmtFind->IsFieldNullL(2); 	// 3 -> StrValue

	if(!isIntPropertyNull)

		{

		aPropertyType = CScrRequestImpl::EPropertyInteger;

		}

	else if(!isStrPropertyNull)

		{

		TBool is8BitString = (stmtFind->IntColumnL(3) == 1);

		aPropertyType = is8BitString ? CScrRequestImpl::EPropertyBinary : CScrRequestImpl::EPropertyLocalizable;

		}

	else // None of the columns is defined - corrupt DB 

		{

		DEBUG_PRINTF(_L8("Unexpected situation! Neither int value nor str value are defined for a property"));

		User::Leave(KErrCorrupt);

		}

	CleanupStack::PopAndDestroy(2, statementStr); // stmtFind, statementStr

	return propertyId;

	}

void CScrRequestImpl::BindStatementValuesL(CStatement& aStatement, TLanguage aLanguage, TInt aValuesNum, VA_LIST aList) const

	{

	TInt bindIdx(0);

	while(aValuesNum--)

		{

		CScrRequestImpl::TValueType t = static_cast<CScrRequestImpl::TValueType>(VA_ARG(aList, TInt));

		switch(t)

			{

			case EValueString:

				{

				const TDesC* strVal = VA_ARG(aList, const TDesC*);