sl@0: // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: // SqlSrvStatementCollation.cpp
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include "SqlSrvCollation.h"
sl@0: #include "SqlAssert.h"
sl@0: #include "SqlUtil.h"
sl@0: #include "sqlite3.h"
sl@0: #include "SqliteSymbian.h"		//sqlite3SymbianLastOsError()
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /////////////////////////////        Local const data   ///////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //4 collated comparisons + 1 folded comparison
sl@0: const TInt KCollationMethodCount = 4 + 1;
sl@0: 
sl@0: //Names of the user defined collations (zero-terminated 16-bit strings)
sl@0: const TUint16* KCollationMethodName[KCollationMethodCount] = 
sl@0: 	{
sl@0: 	(const TUint16*)L"CompareC0", 
sl@0: 	(const TUint16*)L"CompareC1", 
sl@0: 	(const TUint16*)L"CompareC2", 
sl@0: 	(const TUint16*)L"CompareC3", 
sl@0: 	(const TUint16*)L"CompareF"
sl@0: 	};
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /////////////////////////////        Local functions      /////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //User-defined collation function prototype, accepted by SQLITE
sl@0: typedef TInt (*TCollationMethodPtr)(void* aUserDefinedData, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2);
sl@0: 
sl@0: /**
sl@0: This function is used for collated/folded string comparisons,
sl@0: {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes.
sl@0: {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes.
sl@0: aLevel - 0,1,2,3 - collation level; -1 - folded string comparison;
sl@0: The function returns negative, zero or positive if the first string is less than, equal to, or 
sl@0: greater than the second string.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt Compare(TInt aLevel, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2)
sl@0: 	{
sl@0: 	TPtrC16 ptr1(static_cast <const TUint16*> (aPtr1), (TUint)aByteSize1 /sizeof(TUint16));
sl@0: 	TPtrC16 ptr2(static_cast <const TUint16*> (aPtr2), (TUint)aByteSize2 /sizeof(TUint16));
sl@0: 	
sl@0: 	return aLevel >= 0 ? ptr1.CompareC(ptr2, aLevel, NULL) : ptr1.CompareF(ptr2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: User defined function which will be used by SQLITE engine for collated string comparisons,
sl@0: collation level 0.
sl@0: {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes.
sl@0: {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes.
sl@0: The function returns negative, zero or positive if the first string is less than, equal to, or 
sl@0: greater than the second string.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt CompareC0(void*, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2)
sl@0: 	{
sl@0: 	return Compare(0, aByteSize1, aPtr1, aByteSize2, aPtr2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: User defined function which will be used by SQLITE engine for collated string comparisons,
sl@0: collation level 1.
sl@0: {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes.
sl@0: {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes.
sl@0: The function returns negative, zero or positive if the first string is less than, equal to, or 
sl@0: greater than the second string.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt CompareC1(void*, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2)
sl@0: 	{
sl@0: 	return Compare(1, aByteSize1, aPtr1, aByteSize2, aPtr2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: User defined function which will be used by SQLITE engine for collated string comparisons,
sl@0: collation level 2.
sl@0: {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes.
sl@0: {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes.
sl@0: The function returns negative, zero or positive if the first string is less than, equal to, or 
sl@0: greater than the second string.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt CompareC2(void*, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2)
sl@0: 	{
sl@0: 	return Compare(2, aByteSize1, aPtr1, aByteSize2, aPtr2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: User defined function which will be used by SQLITE engine for collated string comparisons,
sl@0: collation level 3.
sl@0: {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes.
sl@0: {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes.
sl@0: The function returns negative, zero or positive if the first string is less than, equal to, or 
sl@0: greater than the second string.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt CompareC3(void*, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2)
sl@0: 	{
sl@0: 	return Compare(3, aByteSize1, aPtr1, aByteSize2, aPtr2);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: User defined function which will be used by SQLITE engine for folded string comparisons,
sl@0: {aByteSize1, aPtr1} - string 1, UTF16 encoded. aByteSize1 - length in bytes.
sl@0: {aByteSize2, aPtr2} - string 2, UTF16 encoded. aByteSize2 - length in bytes.
sl@0: The function returns negative, zero or positive if the first string is less than, equal to, or 
sl@0: greater than the second string.
sl@0: 
sl@0: @internalComponent
sl@0: */
sl@0: static TInt CompareF(void*, TInt aByteSize1, const void* aPtr1, TInt aByteSize2, const void* aPtr2)
sl@0: 	{
sl@0: 	return Compare(-1, aByteSize1, aPtr1, aByteSize2, aPtr2);
sl@0: 	}
sl@0: 
sl@0: //KCollationMethodPtr array contains function pointers to all user-defined collation functions
sl@0: const TCollationMethodPtr KCollationMethodPtr[KCollationMethodCount] = 
sl@0: 	{
sl@0: 	&CompareC0, &CompareC1, &CompareC2, &CompareC3, &CompareF
sl@0: 	};
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: /////////////////////////////        TSqlCollationUtil class definition      //////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: Initializes TSqlCollationUtil data members.
sl@0: 
sl@0: @panic SqlDb 4 In _DEBUG mode. aDbHandle is NULL.
sl@0: */
sl@0: TSqlCollationUtil::TSqlCollationUtil(sqlite3* aDbHandle) :
sl@0: 	iDbHandle(aDbHandle)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Installs user defined collations.
sl@0: 
sl@0: At the moment 5 user defined collations with the following names are installed:
sl@0: - CompareC0 - 16-bit strings collated comaprison at level 0;
sl@0: - CompareC1 - 16-bit strings collated comaprison at level 1;
sl@0: - CompareC2 - 16-bit strings collated comaprison at level 2;
sl@0: - CompareC3 - 16-bit strings collated comaprison at level 3;
sl@0: - CompareF  - 16-bit strings folded comaprison;
sl@0: 
sl@0: These user defined collations can be used in the following cases:
sl@0: 
sl@0: - as column constraint in "CREATE TABLE" SQL statements. For example:
sl@0: @code
sl@0:   CREATE TABLE A(Col1 TEXT COLLATE CompareC1)
sl@0: @endcode
sl@0: In this case every time when Col1 values have to be compared, the SQL server will use CompareC1 collation.
sl@0: 
sl@0: - as column constraint in "CREATE INDEX" SQL statements. For example:
sl@0: @code
sl@0:   CREATE INDEX I ON A(Col1 COLLATE CompareC2)
sl@0: @endcode
sl@0: In this case SQL server will use CompareC2 collation to compare Col1 values when using the index.
sl@0: 
sl@0: - In "ORDER BY" clause of "SELECT" SQL statements. For example:
sl@0: @code
sl@0:   SELECT * FROM A ORDER BY Col1 COLLATE CompareC3
sl@0: @endcode
sl@0: In this case SQL server will use CompareC3 collation to compare Col1 values when building the result set.
sl@0: 
sl@0: @leave The function may leave with some database specific errors categorised as ESqlDbError.
sl@0: 
sl@0: @panic SqlDb 2 In _DEBUG mode. iDbHandle is NULL.
sl@0: */
sl@0: void TSqlCollationUtil::InstallCollationsL()
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(iDbHandle != NULL, __SQLPANIC(ESqlPanicInvalidObj));
sl@0: 	(void)sqlite3SymbianLastOsError();//clear last OS error
sl@0: 	//Register user defined collations
sl@0: 	for(TInt i=0;i<KCollationMethodCount;++i)
sl@0: 		{
sl@0: 		TInt err = sqlite3_create_collation16(iDbHandle, reinterpret_cast <const char*> (KCollationMethodName[i]), 
sl@0: 											  SQLITE_UTF16 | SQLITE_UTF16_ALIGNED, 0, KCollationMethodPtr[i]);
sl@0: 		__SQLLEAVE_IF_ERROR(::Sql2OsErrCode(err, sqlite3SymbianLastOsError()));
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @return User-defined collation methods count.
sl@0: 
sl@0: @see TSqlCollationUtil::CollationName() 
sl@0: */
sl@0: TInt TSqlCollationUtil::CollationCount() const
sl@0: 	{
sl@0: 	return KCollationMethodCount;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @return The name of the collation method, identified by aIndex.
sl@0: 
sl@0: @panic SqlDb 4 In _DEBUG mode. aIndex >= CollationMethodCount().
sl@0: 
sl@0: @see TSqlCollationUtil::CollationsCount() 
sl@0: */
sl@0: TPtrC TSqlCollationUtil::CollationName(TInt aIndex) const
sl@0: 	{
sl@0: 	__ASSERT_DEBUG((TUint)aIndex < KCollationMethodCount, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	return TPtrC(KCollationMethodName[aIndex]);
sl@0: 	}