// Copyright (c) 1998-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:

 // SQL Literal value and node classes

 // 

 //

 #include "UQ_STD.H"

 // internalising literal strings, overload selectors

 inline HBufC8* Alloc8L(const TDesC8& aDes)

 	{return aDes.AllocL();}

 inline HBufC8* Alloc8L(const TDesC16& aDes)

 	{HBufC8* cell=HBufC8::NewL(aDes.Length());cell->Des().Copy(aDes);return cell;}

 inline HBufC16* Alloc16L(const TDesC16& aDes)

 	{return aDes.AllocL();}

 inline HBufC16* Alloc16L(const TDesC8& aDes)

 	{HBufC16* cell=HBufC16::NewL(aDes.Length());cell->Des().Copy(aDes);return cell;}

 template <class B,class T>

 inline B* DoInternString(B* aBuf,T*)

 	{

 	const T* base=aBuf->Ptr();

 	const T* from=base;

 	const T* end=base+aBuf->Length();

 	for (;;)

 		{

 		if (from==end)

 			return aBuf;

 		if (*from++=='\'')

 			break;

 		}

 	T* to=(T*)from;

 	++from;

 	while (from<end)

 		{

 		T c=*from++;

 		if (c=='\'')

 			++from;

 		*to++=c;

 		}

 	aBuf->Des().SetLength(to-base);

 	return aBuf;

 	}

 template <class B>

 inline B* InternString(B* aBuf)

 	{return DoInternString(aBuf,PtrType(*aBuf));}

 // Class RSqlLiteral

 void RSqlLiteral::Close()

 //

 // Free any allocated cell

 //

 	{

 	if(iBuffer)

 		delete iBuffer;

 	if (IsAlloc())

 		User::Free(iVal.iAlloc);

 	}

 void RSqlLiteral::ToInt32L()

 //

 // Convert a numeric type to Int32

 //

 	{

 	ToInt64L();

 	const TInt64& v=iVal.iInt64;

 	TInt32 l = I64LOW(v);

 	TInt32 h = I64HIGH(v);

 	if (h==(l>>31))	// domain check, in signed 32-bit range

 		{

 		iVal.iInt32=l;

 		iType=EInt32;

 		}

 	else

 		__LEAVE(KErrOverflow);	// cannot convert

 	}

 void RSqlLiteral::ToUint32L()

 //

 // Convert a numeric type to Uint32

 //

 	{

 	ToInt64L();

 	const TInt64& v=iVal.iInt64;

 	if (I64HIGH(v)==0)		// domain check, in unsigned 32-bit range

 		{

 		iVal.iUint32 = I64LOW(v);

 		iType=EUint32;

 		}

 	else

 		__LEAVE(KErrOverflow);	// cannot convert

 	}

 void RSqlLiteral::ToInt64L()

 //

 // Convert a numeric type to int64

 //

 	{

 	__ASSERT(IsBasic());	// only apply conversions once

 	TType t=iType;

 	if (t==EReal64)

 		{

 		iVal.iInt64() = static_cast<TInt64>(Real64());

 		iType=EInt64;

 		}

 	else if (t!=EInt64)

 		__LEAVE(KErrGeneral);

 	}

 void RSqlLiteral::ToReal64L()

 //

 // Convert a numeric type to real64

 //

 	{

 	__ASSERT(IsBasic());	// only apply conversions once

 	TType t=iType;

 	if (t==EInt64)

 		{

 		iVal.iReal64=I64REAL(Int64());

 		iType=EReal64;

 		}

 	else if (t!=EReal64)

 		__LEAVE(KErrGeneral);

 	}

 void RSqlLiteral::ToReal32L()

 //

 // Convert a numeric type to real32

 //

 	{

 	ToReal64L();

 	__LEAVE_IF_ERROR(TRealX(iVal.iReal64).GetTReal(iVal.iReal32));

 	iType=EReal32;

 	}

 void RSqlLiteral::ToTimeL()

 //

 // Ensure we are a time

 //

 	{

 	__ASSERT(IsBasic());	// only apply conversions once

 	if (iType!=ETime)

 		__LEAVE(KErrGeneral);	// type mismatch

 	}

 void RSqlLiteral::ToText8L()

 //

 // Convert a ptr to a text8

 //

 	{

 	__ASSERT(IsBasic());	// only apply conversions once

 	if (iType==EPtr)

 		{

 		iVal.iAlloc=InternString(Alloc8L(DesC()));

 		iType=EBuf8;

 		}

 	else

 		__LEAVE(KErrGeneral);	// type mismatch

 	}

 void RSqlLiteral::ToText16L()

 //

 // Convert a ptr to a text8

 //

 	{

 	__ASSERT(IsBasic());	// only apply conversions once

 	if (iType==EPtr)

 		{

 		iVal.iAlloc=InternString(Alloc16L(DesC()));

 		iType=EBuf16;

 		}

 	else

 		__LEAVE(KErrGeneral);	// type mismatch

 	}

 void RSqlLiteral::ToBlobL()

 //

 // Convert a hex encoded ptr to a blob

 //

 	{

 	__ASSERT(IsBasic());	// only apply conversions once

 	if (iType==EBlob)

 		{

 		RBuf8 blobBuf;

 		HBufC* buf = Alloc16L(DesC());

 		CleanupStack::PushL(buf);

 		HexDecodeL(*buf, blobBuf);

 		CleanupStack::PopAndDestroy(buf);

 		iVal.iAlloc=Alloc8L(blobBuf);

 		blobBuf.Close();

 		iType=EBlob;

 		}

 	else

 		__LEAVE(KErrGeneral);	// type mismatch

 	}

 // class CSqlLiteralNode

 CSqlLiteralNode::CSqlLiteralNode(TType aType,const TDesC& aColumn,const RSqlLiteral& aLiteral)

 	:CSqlBoundNode(aType,aColumn),iLiteral(aLiteral)

 	{}

 CSqlLiteralNode::~CSqlLiteralNode()

 	{

 	iLiteral.Close();

 	}

 void CSqlLiteralNode::BindL(const RDbTableRow& aSource)

 	{

 	CSqlBoundNode::BindL(aSource);

 	switch (ColType())

 		{

 	default:	// type not allowed in evaluation expressions

 		__LEAVE(KErrGeneral);

 		break;

 	case EDbColBit:

 	case EDbColInt8:

 	case EDbColUint8:

 	case EDbColInt16:

 	case EDbColUint16:

 	case EDbColInt32:

 	case EDbColUint32:

 	case EDbColInt64:

 		iLiteral.ToInt64L();

 		break;

 	case EDbColReal32:

 	case EDbColReal64:

 		iLiteral.ToReal64L();

 		break;

 	case EDbColDateTime:

 		iLiteral.ToTimeL();

 		break;

 	case EDbColText8:

 	case EDbColLongText8:

 		iLiteral.ToText8L();

 		break;

 	case EDbColText16:

 	case EDbColLongText16:

 		iLiteral.ToText16L();

 		break;

 	case EDbColBinary:

 	case EDbColLongBinary:

 		iLiteral.ToBlobL();

 		break;

 		}

 	}

 // copy text to buffer for LIKE Escape support

 TInt RSqlLiteral::CopyText()

 	{

 	if (iType==EPtr)

 		{

 		TInt length = iVal.iPtr.iEnd - iVal.iPtr.iPtr;

 		if(iBuffer)

 			delete iBuffer;

 		if((iBuffer=HBufC::New(length+1)) == NULL)

 	        	{

 			return KErrNoMemory;

 			}

 		iBuffer->Des().Copy(iVal.iPtr.iPtr,length);

 		iVal.iPtr.iPtr= &iBuffer->Des()[0];

 		iBuffer->Des().Append(iVal.iPtr.iEnd,1);

 		iVal.iPtr.iEnd=&iBuffer->Des()[length]; 

 		}

 	else

 		return KErrGeneral;	// type mismatch

 	return KErrNone;

 	}