diff -r 000000000000 -r 08ec8eefde2f persistentstorage/dbms/pcdbms/inc/D32DBAS.INL
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/pcdbms/inc/D32DBAS.INL	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,416 @@
+// 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:
+//
+
+// Class TTextOps
+inline TUint TTextOps::Fold(TUint aChar) const
+	{
+    return iFold(aChar);
+    }
+
+inline TInt TTextOps::Match(const TDesC8& aDes,const TDesC8& aPattern) const
+	{
+    return iMatch8(aDes,aPattern);
+    }
+
+inline TInt TTextOps::Compare(const TText8* aLeftPtr,
+                              TInt aLeftLen,
+                              const TText8* aRightPtr,
+                              TInt aRightLen) const
+	{
+    return iCompare8(aLeftPtr,aLeftLen,aRightPtr,aRightLen);
+    }
+
+inline TInt TTextOps::Match(const TDesC16& aDes,const TDesC16& aPattern) const
+	{
+    return iMatch16(aDes,aPattern);
+    }
+
+inline TInt TTextOps::Compare(const TText16* aLeftPtr,
+                              TInt aLeftLen,
+                              const TText16* aRightPtr,
+                              TInt aRightLen) const
+	{
+    return iCompare16(aLeftPtr,aLeftLen,aRightPtr,aRightLen);
+    }
+
+/**
+The method compares aLeftPtr and aRightPtr unicode strings.
+Collation level 3 will be used. 
+@param aLeftPtr Left string to compare.
+@param aLeftLen The length of left string.
+@param aRightPtr Right string to compare.
+@param aRightLen The length of right string.
+This method is used by sorting algorithms when the key field is a unciode string.
+@return Positive. if aLeftPtr is greater than aRightPtr.
+        Negative. if aLeftPtr is less than aRightPtr.
+        Zero, if aLeftPtr is equal to aRightPtr.
+*/
+inline TInt TTextOps::Order(const TText16* aLeftPtr, TInt aLeftLen, const TText16* aRightPtr, TInt aRightLen) const
+	{
+	return iOrder16(aLeftPtr, aLeftLen, aRightPtr, aRightLen);
+	}
+
+// Class TDbBlob
+inline TDbBlob::TDbBlob() :
+	iId(KDbNullBlobId), 
+    iSize(0)
+	{
+    }
+
+inline TDbBlob::TDbBlob(TDbBlobId anId,TInt aSize) :
+	iId(anId), 
+    iSize(aSize)
+	{
+    }
+
+inline TDbBlob::TDbBlob(const TUint8* aPtr,TInt aSize) :
+	iId(KDbNullBlobId), 
+    iSize(aSize)
+	{
+	__ASSERT_DEBUG(aSize>=0&&aSize<=KDbMaxInlineBlobSize,User::Invariant());
+	Mem::Copy(iInline,aPtr,aSize);
+	}
+
+inline TUint8* TDbBlob::InlineBuffer()
+	{
+	__ASSERT_DEBUG(IsInline(),User::Invariant());
+	return iInline;
+	}
+
+inline void TDbBlob::SetId(TDbBlobId anId)
+	{
+    iId=anId;
+    }
+
+inline void TDbBlob::SetSize(TInt aSize)
+	{
+    iSize=aSize;
+    }
+
+inline TBool TDbBlob::IsInline() const
+	{
+    return iId==KDbNullBlobId;
+    }
+
+inline TInt TDbBlob::Size() const
+	{
+    return iSize;
+    }
+
+inline const TUint8* TDbBlob::Data() const
+	{
+	__ASSERT_DEBUG(IsInline(),User::Invariant());
+	return iInline;
+	}
+
+inline TPtrC8 TDbBlob::PtrC8() const
+	{
+	__ASSERT_DEBUG(IsInline(),User::Invariant());
+	return TPtrC8(iInline,iSize);
+	}
+
+inline TPtrC16 TDbBlob::PtrC16() const
+	{
+	__ASSERT_DEBUG(IsInline(),User::Invariant());
+	return TPtrC16((const TUint16*)iInline,iSize>>1);
+	}
+
+inline TDbBlobId TDbBlob::Id() const
+	{
+	__ASSERT_DEBUG(!IsInline(),User::Invariant());
+	return iId;
+	}
+
+inline TInt TDbBlob::CellSize() const
+	{
+    return _FOFF(TDbBlob,iInline[IsInline() ? Size() : 0]);
+    }
+
+inline TInt TDbBlob::InlineSize(TInt aSize)
+	{
+    return _FOFF(TDbBlob,iInline[aSize]);
+    }
+
+inline TInt TDbBlob::RefSize()
+	{
+    return _FOFF(TDbBlob,iInline[0]);
+    }
+
+// CLass TDbCell
+inline TInt TDbCell::Size(TInt aLength)
+	{ 
+    return Align4(aLength+sizeof(TInt)); 
+    }
+
+inline TInt TDbCell::Size() const
+	{
+    return Size(iLength);
+    }
+
+inline TInt TDbCell::Length() const
+	{
+    return iLength;
+    }
+
+inline const TDbCell* TDbCell::Next() const
+	{
+    return PtrAdd(this,Size());
+    }
+
+inline TDbCell* TDbCell::Next()
+	{
+    return PtrAdd(this,Size());
+    }
+
+inline TAny* TDbCell::Data()
+	{
+    return iBuf;
+    }
+
+inline const TAny* TDbCell::Data() const
+	{
+    return iBuf;
+    }
+
+inline void TDbCell::SetLength(TInt aLength)
+	{
+    iLength=aLength;
+    }
+
+// Class TDbColumnC
+inline TDbColumnC::TDbColumnC(const RDbRow& aRow,TDbColNo aCol) :
+	iCell(aRow.ColCell(aCol))
+	{
+    }
+
+inline TInt TDbColumnC::Size() const
+	{
+    return iCell->Length();
+    }
+
+inline TBool TDbColumnC::IsNull() const
+	{
+    return Size()==0;
+    }
+
+inline TInt8 TDbColumnC::Int8() const
+	{
+    return TInt8(*(const TInt32*)iCell->Data());
+    }
+
+inline TInt16 TDbColumnC::Int16() const
+	{
+    return TInt16(*(const TInt32*)iCell->Data());
+    }
+
+inline TInt32 TDbColumnC::Int32() const
+	{
+    return *(const TInt32*)iCell->Data();
+    }
+
+inline const TInt64& TDbColumnC::Int64() const
+	{
+    return *(const TInt64*)iCell->Data();
+    }
+
+inline TUint8 TDbColumnC::Uint8() const
+	{
+    return TUint8(*(const TUint8*)iCell->Data());
+    }
+
+inline TUint16 TDbColumnC::Uint16() const
+	{
+    return TUint16(*(const TUint32*)iCell->Data());
+    }
+
+inline TUint32 TDbColumnC::Uint32() const
+	{
+    return *(const TUint32*)iCell->Data();
+    }
+
+inline TReal32 TDbColumnC::Real32() const
+	{
+    return *(const TReal32*)iCell->Data();
+    }
+
+inline const TReal64& TDbColumnC::Real64() const
+	{
+    return *(const TReal64*)iCell->Data();
+    }
+
+inline TPtrC8 TDbColumnC::PtrC8() const
+	{
+    return TPtrC8((const TUint8*)iCell->Data(),iCell->Length());
+    }
+
+inline TPtrC16 TDbColumnC::PtrC16() const
+	{
+    return TPtrC16((const TUint16*)iCell->Data(),iCell->Length()>>1);
+    }
+
+inline const TTime& TDbColumnC::Time() const
+	{
+    return *(const TTime*)iCell->Data();
+    }
+
+inline const TDbBlob& TDbColumnC::Blob() const
+	{
+    return *(const TDbBlob*)iCell->Data();
+    }
+
+// Class TDbColumn
+inline TDbColumn::TDbColumn()
+#ifdef _DEBUG
+	: iRow(0)
+#endif
+	{
+    }
+
+inline TDbColumn::TDbColumn(RDbRow& aRow,TDbColNo aCol) :
+	iRow(&aRow), 
+    iColumn(aCol)
+	{
+    }
+
+inline RDbRow& TDbColumn::Row() const
+	{
+    __ASSERT_DEBUG(iRow,User::Invariant());
+    return *iRow;
+    }
+
+inline void TDbColumn::SetNull()
+	{
+    Row().SetColumnWidthL(iColumn,0);
+    }
+
+inline void TDbColumn::SetL(TInt32 aValue)
+	{
+    SetL(TUint32(aValue));
+    }
+
+inline void TDbColumn::SetL(const TTime& aValue)
+	{
+    SetL(aValue.Int64());
+    }
+
+inline void TDbColumn::SetL(const TDbCell* aCell)
+	{
+    SetL(aCell->Data(),aCell->Length());
+    }
+
+inline void TDbColumn::SetL(const TDbColumnC& aColumn)
+	{
+    SetL(aColumn.iCell);
+    }
+
+// Class TDbColumnC
+inline TDbColumnC::TDbColumnC(const TDbColumn& aCol) :
+	iCell(aCol.Row().ColCell(aCol.iColumn))
+	{
+    }
+
+// Class RDbRow
+inline RDbRow::RDbRow(TAny* aBuf,TInt aMaxSize)
+	{
+    Open(aBuf,0,aMaxSize);
+    }
+
+inline RDbRow::RDbRow(TAny* aBuf,TInt aSize,TInt aMaxSize)
+	{
+    Open(aBuf,aSize,aMaxSize);
+    }
+
+inline void RDbRow::Open(TAny* aBuf,TInt aMaxSize)
+	{
+    Open(aBuf,0,aMaxSize);
+    }
+
+inline void RDbRow::Reset()
+	{
+    SetSize(0);
+    }
+
+inline TDbCell* RDbRow::First()
+	{
+    return iFirst;
+    }
+
+inline const TDbCell* RDbRow::First() const
+	{
+    return iFirst;
+    }
+
+inline const TDbCell* RDbRow::Last() const
+	{
+    return iLast;
+    }
+
+inline const TDbCell* RDbRow::End() const
+	{
+    return iEnd;
+    }
+
+inline TInt RDbRow::Diff(const TDbCell* aLeft,const TDbCell* aRight)
+	{
+    return (const TUint8*)aRight-(const TUint8*)aLeft;
+    }
+
+inline TInt RDbRow::Size() const
+	{
+    return Diff(iFirst,iLast);
+    }
+
+inline TInt RDbRow::MaxSize() const
+	{
+    return Diff(iFirst,iEnd);
+    }
+
+// Class CDbObject
+inline const CDbContext* CDbObject::Context() const
+	{
+    return iContext;
+    }
+
+
+// Class RDbHandleBase
+inline void RDbHandleBase::Set(CDbObject* aObject)
+	{
+    iObject=aObject;
+    }
+
+// template Class RDbHandle
+template <class T>
+inline T*  RDbHandle<T>::operator=(T* aT)
+	{
+    Set(aT);return aT;
+    }
+
+template <class T>
+inline T* RDbHandle<T>::operator->() const
+	{
+    return &STATIC_CAST(T&,Object());
+    }
+
+template <class T>
+inline T& RDbHandle<T>::operator*() const
+	{
+    return STATIC_CAST(T&,Object());
+    }
+
+template <class T>
+inline T* RDbHandle<T>::operator()() const
+	{
+    return STATIC_CAST(T*,iObject);
+    }