// 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:

 //

 #include "US_STD.H"

 //#define __READBIT_CLASS

 //#define __WRITEBIT_CLASS

 #ifdef __READBIT_CLASS

 class TReadBitSequence

 	{

 public:

 	inline TReadBitSequence();

 	inline TBool HasBits() const;

 	TUint Read(const TUint8*& aPtr);

 private:

 	TUint iBits;

 	};

 inline TReadBitSequence::TReadBitSequence()

 	:iBits(0) {}

 inline TBool TReadBitSequence::HasBits() const

 	{return (iBits&0x2000000);}

 TUint TReadBitSequence::Read(const TUint8*& aPtr)

 	{

 	iBits>>=1;

 	if ((iBits&0x1000000)==0)

 		iBits=*aPtr++ | 0xff000000u;

 	return iBits&1;

 	}

 #define READBITINIT(This) TReadBitSequence This

 #define READHASBITS(This) This.HasBits()

 #define READBIT(This,ptr) This.Read(ptr)

 #define SKIPBIT(This,ptr) READBIT(This,ptr)

 #else

 #define READBITINIT(This) TUint This##_bits=0

 #define READHASBITS(This) (This##_bits&0x2000000)

 #define SKIPBIT(This,ptr) (This##_bits>>=1,(This##_bits&0x1000000 ? void(0) : void(This##_bits=*ptr++|0xff000000u)))

 #define READBIT(This,ptr) (SKIPBIT(This,ptr),This##_bits&1)

 #endif

 #ifdef __WRITEBIT_CLASS

 class TWriteBitSequence

 	{

 public:

 	inline TWriteBitSequence();

 	TUint8* Write(TUint8* aPtr,TUint aBit);

 	void Flush();

 private:

 	TUint iBits;

 	TUint8* iPtr;

 	};

 inline TWriteBitSequence::TWriteBitSequence()

 	:iBits(0),iPtr(0) {}

 TUint8* TWriteBitSequence::Write(TUint8* aPtr,TUint aBit)

 	{

 	TUint bits=iBits>>1;

 	if ((bits&0x1000000)==0)

 		{

 		if (iPtr)

 			*iPtr=TUint8(bits);

 		iPtr=aPtr++;

 		bits=0xff000000;

 		}

 	if (aBit)

 		bits|=0x100;

 	iBits=bits;

 	return aPtr;

 	}

 void TWriteBitSequence::Flush()

 	{

 	TUint8* ptr=iPtr;

 	if (ptr)

 		{

 		TUint bits=iBits;

 		do bits>>=1; while (bits&0x1000000);

 		*ptr=TUint8(bits);

 		}

 	}

 #define WRITEBITINIT(This) TWriteBitSequence This

 #define WRITEBIT(This,ptr,bit) ptr=This.Write(ptr,bit)

 #define WRITEZEROBIT(This,ptr) ptr=This.Write(ptr,0)

 #define FLUSHBITS(This) This.Flush()

 #else

 #define WRITEBITINIT(This) TUint32 This##_bits=0; TUint8* This##_ptr=0

 #define NEXTBIT(This,ptr) This##_bits>>=1;if ((This##_bits&0x1000000)==0){if (This##_ptr) *This##_ptr=TUint8(This##_bits);This##_ptr=ptr++;This##_bits=0xff000000;}

 #define WRITEZEROBIT(This,ptr) {NEXTBIT(This,ptr)}

 #define WRITEBIT(This,ptr,bit) {NEXTBIT(This,ptr) if (bit) This##_bits|=0x100;}

 #define FLUSHBITS(This) {if (This##_ptr){do This##_bits>>=1; while (This##_bits&0x1000000);*This##_ptr=TUint8(This##_bits);}}

 #endif

 LOCAL_C const TUint8* Read32(const TUint8* aPtr,TUint32* aDest)

 // fast read for non-aligned little-endian 32-bit data

 	{

 	TUint32 x=*aPtr++;

 	x|=*aPtr++<<8;

 	x|=*aPtr++<<16;

 	x|=*aPtr++<<24;

 	*aDest=x;

 	return aPtr;

 	}

 LOCAL_C TUint8* Write32(TUint8* aPtr,TUint32 aVal)

 // fast transfer for non-aligned little-endian 32-bit data

 	{

 	*aPtr++=TUint8(aVal);

 	*aPtr++=TUint8(aVal>>8);

 	*aPtr++=TUint8(aVal>>16);

 	*aPtr++=TUint8(aVal>>24);

 	return aPtr;

 	}

 inline const TUint8* Read16(const TUint8* aPtr,TUint32* aDest)

 // Read unsigned 16-bit value into aDest storage

 	{

 	TUint x=*aPtr++;

 	x|=*aPtr++<<8;

 	*aDest=TUint16(x);

 	return aPtr;

 	}

 inline const TUint8* Read16s(const TUint8* aPtr,TUint32* aDest)

 // Read signed 16-bit value into aDest storage

 	{

 	TInt x=*aPtr++<<16;

 	x|=*aPtr++<<24;

 	*aDest=x>>16;

 	return aPtr;

 	}

 inline TUint8* Write16(TUint8* aPtr,TUint aVal)

 // Write little-endian rep of the low 16 bits of aVal

 	{

 	*aPtr++=TUint8(aVal);

 	*aPtr++=TUint8(aVal>>8);

 	return aPtr;

 	}

 LOCAL_C TUint8* WriteCardinality(TUint8* aPtr,TUint aVal)

 // compress cardinality into the data stream

 	{

 	__ASSERT(aVal<(1u<<30));

 	if ((aVal>>7)==0)

 		{

 		*aPtr++=TUint8(aVal<<1);

 		return aPtr;

 		}

 	aVal=(aVal<<2)|1;

 	if ((aVal>>16)==0)

 		{

 		*aPtr++=TUint8(aVal);

 		*aPtr++=TUint8(aVal>>8);

 		return aPtr;

 		}

 	return Write32(aPtr,aVal|2);

 	}

 LOCAL_C TUint ReadCardinality(const TUint8* aPtr)

 // extract cardinality from the data stream

 	{

 	TUint x=aPtr[0];

 	if ((x&1)==0)

 		return x>>1;

 	x|=aPtr[1]<<8;

 	if (x&2)

 		{

 		x|=aPtr[2]<<16;

 		x|=aPtr[3]<<24;

 		}

 	return x>>2;

 	}

 LOCAL_C const TUint8* ReadCardinality(const TUint8* aPtr,TInt& aVal)

 // extract cardinality from the data stream

 	{

 	TUint x=*aPtr++;

 	if ((x&1)==0)

 		x>>=1;

 	else

 		{

 		x|=*aPtr++<<8;

 		if (x&2)

 			{

 			x|=*aPtr++<<16;

 			x|=*aPtr++<<24;

 			}

 		x>>=2;

 		}

 	aVal=x;

 	return aPtr;

 	}

 LOCAL_C TInt SizeOfCardinality(TUint aVal)

 // report the externalized size of the Compressed value in bytes

 	{

 	if ((aVal>>7)==0)

 		return 1;

 	return (aVal>>14)==0 ? 2 : 4;

 	}

 LOCAL_C TUint8* WriteBlobId(TUint8* aPtr,TDbBlobId aId)

 	{

 	return WriteCardinality(aPtr,(aId>>24)|(aId<<8>>4));

 	}

 LOCAL_C const TUint8* ReadBlobId(const TUint8* aPtr,TDbBlobId& aId)

 	{

 	aPtr=ReadCardinality(aPtr,*reinterpret_cast<TInt*>(&aId));

 	aId=(aId>>4)|(aId<<28>>4);

 	return aPtr;

 	}

 LOCAL_C TInt SizeOfBlobId(TDbBlobId aId)

 	{

 	return SizeOfCardinality((aId>>24)|(aId<<8>>4));

 	}

 // Class CDbStoreTable

 CDbStoreTable::CDbStoreTable(CDbStoreDatabase& aDatabase,const CDbTableDef& aDef)

 	: CDbTable(aDatabase,aDef)

 	{}

 CDbRecordSpace* CDbStoreTable::RecordSpaceL()

 //

 // open records handler

 //

 	{

 	return CDbStoreRecords::NewL(Database().ClusterCacheL(),Def());

 	}

 CDbBlobSpace* CDbStoreTable::BlobSpaceL()

 //

 // Open a blobs accessor for the table

 //

 	{

 	return new(ELeave) CDbStoreBlobs(Database(),Def().InlineLimit());

 	}

 CDbRecordIndex* CDbStoreTable::RecordIndexL(const CDbTableIndexDef& anIndex)

 //

 // Open an index

 //

 	{

 	return CDbStoreIndex::NewL(Database(),(const CDbStoreIndexDef&)anIndex,Def());

 	}

 static TUint8* CompressUnicode(TUint8* aRec,const TAny* aData,TInt aSize)

 //

 // initially assume the compressed data requires 1 byte for the length data

 // Copy it if more is necessary. This avoids having to run the compressor twice

 //

 	{

 	TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aData));

 	TUnicodeCompressor compressor;

 	TInt output;

 	compressor.CompressL(aRec+1,source,KMaxTInt,aSize>>1,&output);

 	TInt lenSize=SizeOfCardinality(output);

 	if (lenSize!=1)

 		Mem::Copy(aRec+lenSize,aRec+1,output);	// needs more space for length

 	return WriteCardinality(aRec,output)+output;

 	}

 static TInt SizeOfCompressedUnicode(const TAny* aData,TInt aSize)

 //

 // bytes required to store the unicode data

 //

 	{

 	TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aData));

 	TInt size=TUnicodeCompressor::CompressedSizeL(source,aSize>>1);

 	return SizeOfCardinality(size)+size;

 	}

 static const TUint8* ExpandUnicodeL(const TUint8* aRec,TAny* aTarget,const TAny* aLimit,TInt& aChars)

 //

 // Read compressed unicode from the record

 //

 	{

 	TInt bytes;

 	aRec=ReadCardinality(aRec,bytes);

 	TMemoryUnicodeSink unicode(reinterpret_cast<TUint16*>(aTarget));

 	TUnicodeExpander expander;

 	TInt used;

 	expander.ExpandL(unicode,aRec,(TUint16*)aLimit-(TUint16*)aTarget,bytes,&aChars,&used);

 	return bytes==used ? aRec+bytes : 0;	// signal corruption in data, could not fit text in space

 	}

 static TInt SizeOfExpandedUnicodeL(const TUint8* aData,TInt aSize)

 //

 // bytes required to store the unicode data

 //

 	{

 	return TUnicodeExpander::ExpandedSizeL(aData,aSize)<<1;

 	}

 TInt CDbStoreTable::RecordLength(const RDbRow& aRow)

 //

 // Calculate the size of a record

 //

 	{

 	TInt bits=SizeOfCardinality(OptimizedRowLength(aRow))<<3;		// record buffer size

 	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

 	const TDbCell* const last=aRow.Last();

 	for (const TDbCell* column=aRow.First();column<last;++col,column=column->Next())

 		{

 		__ASSERT(col<Def().Columns().End());	// columns off end

 		TInt size=column->Length();

 		if ((col->iAttributes&TDbCol::ENotNull)==0)

 			{	//nullable

 			++bits;

 			if (size==0)

 				continue;			// no data

 			}

 		__ASSERT(size>0);	// must be non-null to reach here

 		TDbColType type=col->Type();

 		__ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);

 		if (type==EDbColBit)

 			++bits;

 		else if (type<=EDbColDateTime)

 			bits+=TRecordSize::FixedFieldSize(type)<<3;

 		else if (type==EDbColText16)

 			bits+=SizeOfCompressedUnicode(column->Data(),size)<<3;

 		else if (type<=EDbColBinary)

 			bits+=8+(size<<3);

 		else

 			{

 			__ASSERT(type<=EDbColLongBinary);

 			const TDbBlob& blob=*(const TDbBlob*)column->Data();

 			if (!blob.IsInline())

 				bits+=1+((SizeOfBlobId(blob.Id())+SizeOfCardinality(blob.Size()))<<3);

 			else if (type!=EDbColLongText16)

 				bits+=9+(blob.Size()<<3);

 			else

 				bits+=1+(SizeOfCompressedUnicode(blob.Data(),blob.Size())<<3);

 			}

 		}

 	__ASSERT(bits<=(KDbStoreMaxRecordLength<<3));

 	return (bits+7)>>3;

 	}

 TInt CDbStoreTable::OptimizedRowLength(const RDbRow& aRow)

 //

 // Calculate the minimal row buffer size (in words) to store the row data

 //

 	{

 	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

 	const TDbCell* const last=aRow.Last();

 	TInt cellHead=0;

 	TInt words=0;

 	for (const TDbCell* column=aRow.First();column<last;++col,column=column->Next())

 		{

 		++cellHead;

 		__ASSERT(col<Def().Columns().End());	// columns off end

 		TInt size=column->Length();

 		if (size==0)

 			continue;

 		words+=cellHead;

 		cellHead=0;

 		TDbColType type=col->Type();

 		__ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);

 		if (type<=EDbColDateTime)

 			__ASSERT(size==(size>>2<<2));

 		else if (type<=EDbColBinary)

 			;

 		else

 			size=((const TDbBlob*)column->Data())->CellSize();

 		words+=(size+3)>>2;

 		}

 	return words;

 	}

 void CDbStoreTable::CopyFromRow(TUint8* aRecord,const RDbRow& aRow)

 //

 // translate the row buffer into its persistent format in the record buffer

 //

 	{

 	aRecord=WriteCardinality(aRecord,OptimizedRowLength(aRow));	// internal size

 //

 	WRITEBITINIT(bits);

 	HDbColumnSet::TIteratorC iter=Def().Columns().Begin();

 	const TDbCell* const last=aRow.Last();

 	for (const TDbCell* column=aRow.First();column<last;++iter,column=column->Next())

 		{

 		__ASSERT(iter<Def().Columns().End());	// columns off end

 		TInt size=column->Length();

 		if ((iter->iAttributes&TDbCol::ENotNull)==0)

 			{	// nullable

 			WRITEBIT(bits,aRecord,size!=0);

 			if (size==0)

 				continue;			// no data

 			}

 		__ASSERT(size>0);	// must be non-null to reach here

 		const TUint32* data=(const TUint32*)column->Data();

 		TDbColType type=iter->Type();

 		switch (type)

 			{

 		default:

 			__ASSERT(0);

 		case EDbColBit:

 			WRITEBIT(bits,aRecord,*data);

 			break;

 		case EDbColInt8:

 		case EDbColUint8:

 			*aRecord++=TUint8(*data);

 			break;

 		case EDbColInt16:

 		case EDbColUint16:

 			aRecord=Write16(aRecord,*data);

 			break;

 #if defined(__DOUBLE_WORDS_SWAPPED__)

 		case EDbColReal64:

 			aRecord=Write32(aRecord,data[1]);	// write low word out first

 			// drop through to write high word next

 #endif

 		case EDbColInt32:

 		case EDbColUint32:

 		case EDbColReal32:

 			aRecord=Write32(aRecord,*data);

 			break;

 #if !defined(__DOUBLE_WORDS_SWAPPED__)

 		case EDbColReal64:

 #endif

 		case EDbColInt64:

 		case EDbColDateTime:

 			aRecord=Write32(aRecord,data[0]);

 			aRecord=Write32(aRecord,data[1]);

 			break;

 		case EDbColText16:

 			aRecord=CompressUnicode(aRecord,data,size);

 			break;

 		case EDbColText8:

 		case EDbColBinary:

 			*aRecord++=TUint8(size);

 			aRecord=Mem::Copy(aRecord,data,size);

 			break;

 		case EDbColLongText8:

 		case EDbColLongText16:

 		case EDbColLongBinary:

 			{

 			const TDbBlob& blob=*reinterpret_cast<const TDbBlob*>(data);

 			size=blob.Size();

 			WRITEBIT(bits,aRecord,blob.IsInline());

 			if (blob.IsInline())

 				{

 				if (type==EDbColLongText16)

 					aRecord=CompressUnicode(aRecord,blob.Data(),size);

 				else

 					{

 					*aRecord++=TUint8(size);

 					aRecord=Mem::Copy(aRecord,blob.Data(),size);

 					}

 				}

 			else

 				{

 				aRecord=WriteBlobId(aRecord,blob.Id());

 				aRecord=WriteCardinality(aRecord,size);

 				}

 			}

 			break;

 			}

 		}

 	FLUSHBITS(bits);

 	}

 const TUint8* CDbStoreTable::CopyToRowL(TDbCell* aCell,TInt aSize,const TUint8* aRec)

 //

 // translate persistent record into the row buffer

 //

 	{

 	__ASSERT(aSize>0);

 //

 	const TDbCell* const end=PtrAdd(aCell,aSize);

 	READBITINIT(bits);

 	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

 	HDbColumnSet::TIteratorC const cend=Def().Columns().End();

 	for (;;)

 		{

 		TInt size=0; //null data

 		if (col->iAttributes&TDbCol::ENotNull || READBIT(bits,aRec))	// have data

 			{

 			if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TUint32))

 				return 0;

 			size=sizeof(TUint32);	// for most types

 			TDbColType type=col->Type();

 			switch (type)

 				{

 			default:

 				__ASSERT(0);

 			case EDbColBit:

 				*(TUint32*)aCell->Data()=READBIT(bits,aRec);

 				break;

 			case EDbColInt8:

 				*(TInt32*)aCell->Data()=*(const TInt8*)aRec;

 				aRec+=sizeof(TInt8);

 				break;

 			case EDbColUint8:

 				*(TUint32*)aCell->Data()=*aRec;

 				aRec+=sizeof(TUint8);

 				break;

 			case EDbColInt16:

 				aRec=Read16s(aRec,(TUint32*)aCell->Data());

 				break;

 			case EDbColUint16:

 				aRec=Read16(aRec,(TUint32*)aCell->Data());

 				break;

 	#if defined(__DOUBLE_WORDS_SWAPPED__)

 			case EDbColReal64:

 				if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TReal64))

 					return 0;

 				size=sizeof(TReal64);

 				aRec=Read32(aRec,(TUint32*)aCell->Data()+1);	// transfer low word first, to high address

 				// drop through to transfer high word to low address!

 	#endif

 			case EDbColInt32:

 			case EDbColUint32:

 			case EDbColReal32:

 				aRec=Read32(aRec,(TUint32*)aCell->Data());

 				break;

 	#if !defined(__DOUBLE_WORDS_SWAPPED__)

 			case EDbColReal64:

 	#endif

 			case EDbColInt64:

 			case EDbColDateTime:

 				if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TInt64))

 					return 0;

 				size=sizeof(TInt64);

 				aRec=Read32(aRec,(TUint32*)aCell->Data());

 				aRec=Read32(aRec,(TUint32*)aCell->Data()+1);

 				break;

 			case EDbColText16:

 				{

 				TInt len;

 				aRec=ExpandUnicodeL(aRec,aCell->Data(),end,len);

 				if (!aRec)

 					return 0;

 				size=len<<1;

 				}

 				break;

 			case EDbColText8:

 			case EDbColBinary:

 				size=*aRec++;

 				if (TInt(end)-TInt(aCell)<TInt(size+sizeof(TUint32)))

 					return 0;

 				Mem::Copy(aCell->Data(),aRec,size);

 				aRec+=size;

 				break;

 			case EDbColLongText8:

 			case EDbColLongText16:

 			case EDbColLongBinary:

 				if (READBIT(bits,aRec)==0)

 					{	// out of line Long column

 					if (TInt(end)-TInt(aCell)<=TDbBlob::RefSize())

 						return 0;

 					TDbBlobId id;

 					aRec=ReadBlobId(aRec,id);

 					TInt sz;

 					aRec=ReadCardinality(aRec,sz);

 					new(aCell->Data()) TDbBlob(id,sz);

 					size=TDbBlob::RefSize();

 					}

 				else if (type!=EDbColLongText16)

 					{	// inline

 					size=*aRec++;

 					if (TInt(end)-TInt(aCell)<TInt(TDbBlob::InlineSize(size)+sizeof(TUint32)))

 						return 0;

 					new(aCell->Data()) TDbBlob(aRec,size);

 					aRec+=size;

 					size=TDbBlob::InlineSize(size);

 					}

 				else

 					{

 					TDbBlob* blob=new(aCell->Data()) TDbBlob;

 					TInt len;

 					aRec=ExpandUnicodeL(aRec,blob->InlineBuffer(),end,len);

 					if (!aRec)

 						return 0;

 					size=len<<1;

 					blob->SetSize(size);

 					size=TDbBlob::InlineSize(size);

 					}

 				break;

 				}

 			}

 		aCell->SetLength(size);

 		aCell=aCell->Next();

 		if (aCell==end)

 			return aRec;

 		if (++col==cend)

 			return 0;

 		}

 	}

 void CDbStoreTable::CopyToRowL(RDbRow& aRow,const TDesC8& aRecord)

 //

 // translate persistent record into the row buffer

 //

 	{

 	const TUint8* rec=aRecord.Ptr();

 	const TUint8* end=rec+aRecord.Length();

 	TInt size;

 	rec=ReadCardinality(rec,size);

 	size<<=2;

 	//If such huge allocation is requested(KMaxTInt/2), it is highly likely the file is corrupt

 	if((size < 0) || (size >= KMaxTInt/2))

 		{

 		aRow.SetSize(0);

 		__LEAVE(KErrCorrupt);

 		}

 	if (size)

 		{

 		aRow.GrowL(size);

 		rec=CopyToRowL(aRow.First(),size,rec);

 		}

 	if (rec)

 		{

 		do

 			{

 			if (rec==end)

 				{

 	aRow.SetSize(size);

 				return;

 				}

 			} while (*rec++==0);

 		}

 	aRow.SetSize(0);

 	__LEAVE(KErrCorrupt);

 	}

 TUint8* CDbStoreTable::AlterRecordL(TUint8* aWPtr,const TUint8* aRPtr,TInt aLength,TInt aInlineLimit)

 //

 // Rewrite the record in the buffer by removing the data from the delete-list

 // any changes are recorded in the iAltered member

 //

 	{

 	// initially assume that the length count will be the same size after alteration

 	TInt lenSize=SizeOfCardinality(ReadCardinality(aRPtr));

 	const TUint8* const rEnd=aRPtr+aLength;

 	aRPtr+=lenSize;

 	TUint8* wptr=aWPtr+lenSize;

 	TInt wRowSize=0;

 	TInt headers=0;

 //

 	READBITINIT(rbits);

 	WRITEBITINIT(wbits);

 	const HDbColumnSet::TIteratorC cEnd=Def().Columns().End();

 	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

 	do

 		{

 		if (aRPtr==rEnd && !READHASBITS(rbits))

 			break;	// no more data

 		TUint flg=col->iFlags;

 		if ((flg&TDbColumnDef::EDropped)==0)

 			++headers;

 		if ((col->iAttributes&TDbCol::ENotNull)==0)

 			{	// nullable

 			TUint notnull=READBIT(rbits,aRPtr);

 			if ((flg&TDbColumnDef::EDropped)==0)

 				WRITEBIT(wbits,wptr,notnull);

 			if (notnull==0)	// null data

 				continue;

 			}

 		wRowSize+=headers;

 		headers=0;

 		TInt size;

 		TDbColType type=col->Type();

 		switch (type)

 			{

 		default:

 			__ASSERT(0);

 		case EDbColBit:

 			size=READBIT(rbits,aRPtr);

 			if ((flg&TDbColumnDef::EDropped)==0)

 				{

 				WRITEBIT(wbits,wptr,size);

 				++wRowSize;

 				}

 			continue;

 		case EDbColInt8:

 		case EDbColUint8:

 		case EDbColInt16:

 		case EDbColUint16:

 		case EDbColInt32:

 		case EDbColUint32:

 		case EDbColReal32:

 		case EDbColReal64:

 		case EDbColInt64:

 		case EDbColDateTime:

 			size=TRecordSize::FixedFieldSize(type);

 			if ((flg&TDbColumnDef::EDropped)==0)

 				{

 				wptr=Mem::Copy(wptr,aRPtr,size);

 				wRowSize+=(size+3)>>2;	// # words

 				}

 			break;

 		case EDbColText8:

 		case EDbColBinary:

 			size=*aRPtr++;

 			if ((flg&(TDbColumnDef::EChangedType|TDbColumnDef::EDropped))==0)

 				{

 				wptr=Mem::Copy(wptr,aRPtr-1,size+1);	// no change, copy the column

 				wRowSize+=(size+3)>>2;	// # words

 				}

 			else if (flg&TDbColumnDef::EChangedType)

 				goto alterBlob8;	// type change, into a LongColumn

 			else

 				__ASSERT(flg&TDbColumnDef::EDropped);	// drop the column

 			break;

 		case EDbColText16:

 			{

 			TInt sz;

 			aRPtr=ReadCardinality(aRPtr,sz);

 			size=sz;

 			if ((flg&(TDbColumnDef::EChangedType|TDbColumnDef::EDropped))==0)

 				{

 				wptr=WriteCardinality(wptr,size);

 				wptr=Mem::Copy(wptr,aRPtr,size);	// no change, copy the column

 				wRowSize+=(SizeOfExpandedUnicodeL(aRPtr,size)+3)>>2;

 				}

 			else if (flg&TDbColumnDef::EChangedType)

 				goto alterBlob16;	// type change, into a LongColumn

 			else

 				__ASSERT(flg&TDbColumnDef::EDropped);	// drop the column

 			}

 			break;

 		case EDbColLongText8:

 		case EDbColLongBinary:

 		case EDbColLongText16:

 			if (!READBIT(rbits,aRPtr))

 				{	// out-of-line

 				TDbBlobId id;

 				aRPtr=ReadBlobId(aRPtr,id);

 				TInt sz;

 				aRPtr=ReadCardinality(aRPtr,sz);

 				if (flg&TDbColumnDef::EDropped)

 					BlobsL()->DeleteL(id);	// delete the stream

 				else

 					{

 					WRITEZEROBIT(wbits,wptr);			// out-of-line

 					wptr=WriteBlobId(wptr,id);

 					wptr=WriteCardinality(wptr,sz);

 					wRowSize+=TDbBlob::RefSize()>>2;

 					}

 				size=0;

 				}

 			else if (type!=EDbColLongText16)

 				{	// currently inline

 				size=*aRPtr++;

 				if (flg&TDbColumnDef::EDropped)

 					break;

 				// write long-column data, check inline status

 alterBlob8:		WRITEBIT(wbits,wptr,size<=aInlineLimit);

 				if (size<=aInlineLimit)

 					{	// inlined

 					*wptr++=TUint8(size);				// blob size

 					wptr=Mem::Copy(wptr,aRPtr,size);	// blob data

 					wRowSize+=(TDbBlob::InlineSize(size)+3)>>2;

 					}

 				else

 					{

 					TDbBlobId id=BlobsL()->CreateL(type,aRPtr,size);

 					wptr=WriteBlobId(wptr,id);

 					wptr=WriteCardinality(wptr,size);

 					wRowSize+=TDbBlob::RefSize()>>2;

 					}

 				}

 			else

 				{	// currently inline

 				TInt sz;

 				aRPtr=ReadCardinality(aRPtr,sz);

 				size=sz;

 				if (flg&TDbColumnDef::EDropped)

 					break;

 				// write long-column data, check inline status

 alterBlob16:	TInt len=SizeOfExpandedUnicodeL(aRPtr,size);

 				WRITEBIT(wbits,wptr,len<=aInlineLimit);

 				if (len<=aInlineLimit)

 					{	// inlined

 					wptr=WriteCardinality(wptr,size);

 					wptr=Mem::Copy(wptr,aRPtr,size);	// blob data

 					wRowSize+=(TDbBlob::InlineSize(len)+3)>>2;

 					}

 				else

 					{

 					TDbBlobId id=BlobsL()->CreateL(EDbColLongText8,aRPtr,size);	// no unicode compressor!

 					wptr=WriteBlobId(wptr,id);

 					wptr=WriteCardinality(wptr,len);

 					wRowSize+=TDbBlob::RefSize()>>2;

 					}

 				}

 			break;

 			}

 		aRPtr+=size;

 		} while (++col<cEnd);

 	FLUSHBITS(wbits);

 	TInt lsz=SizeOfCardinality(wRowSize);

 	if (lenSize!=lsz)

 		wptr=Mem::Copy(aWPtr+lsz,aWPtr+lenSize,wptr-(aWPtr+lenSize));

 	WriteCardinality(aWPtr,wRowSize);

 	return wptr;

 	}

 TInt CDbStoreTable::IndexSpanL(const CDbTableIndexDef& aIndex,TUint aInclusion,const TDbLookupKey* aLower,const TDbLookupKey* aUpper)

 //

 // Guess the size of the index set contained in the given restriction

 // First check the cached values in the defintion, and only load the index if necessary

 //

 	{

 	const TDbStoreIndexStats& stats=static_cast<const CDbStoreIndexDef&>(aIndex).iStats;

 	if (!stats.IsValid())

 		IndexL(aIndex);				// ensure that the index is loaded

 	return stats.Span(aInclusion,aLower,aUpper,TTextOps::Ops(aIndex.Key().Comparison()));

 	}

 // Class CDbStoreTable::CDiscarder

 CDbStoreTable::CDiscarder::CDiscarder()

 	{}

 CDbStoreTable::CDiscarder::~CDiscarder()

 	{

 	if (iTable)

 		iTable->Close();

 	iRow.Close();

 	}

 TInt CDbStoreTable::CDiscarder::OpenL(CDbStoreTable* aTable)

 	{

 	__ASSERT(!iTable);

 	iTable=aTable;

 	iRecords=&aTable->StoreRecordsL();

 	iCluster=iRecords->Head();

 	return iRecords->Count()+1;

 	}

 TInt CDbStoreTable::CDiscarder::StepL(TInt aStep)

 	{

 	__ASSERT(iTable);

 	TInt limit=iTable->Def().Columns().HasLongColumns() ? EBlobDiscardClusters : EDiscardClusters;

 	for (TInt inc=0;inc<limit;++inc)

 		{

 		if (iCluster==KNullClusterId)

 			{

 			iRecords->DestroyL();

 			return 0;

 			}

 		if (limit==EBlobDiscardClusters)

 			iRecords->AlterL(iCluster,*this);

 		aStep-=iRecords->DiscardL(iCluster);

 		}

 	return Max(aStep,1);

 	}

 TUint8* CDbStoreTable::CDiscarder::AlterRecordL(TUint8* aWPtr,const TUint8* aRPtr,TInt aLength)

 //

 // Scan for and discard all known BLOBs

 //

 	{

 	iTable->CopyToRowL(iRow,TPtrC8(aRPtr,aLength));

 	iTable->DiscardBlobsL(iRow);

 	return aWPtr;

 	}

 // class CDbStoreTable::CAlter

 CDbStoreTable::CAlter::CAlter()

 	{}

 CDbStoreTable::CAlter::~CAlter()

 	{

 	if (iTable)

 		iTable->Close();

 	}

 void CDbStoreTable::CAlter::OpenL(CDbStoreTable* aTable,const HDbColumnSet& aNewSet)

 //

 // Prepare for alteration of the table data

 //

 	{

 	__ASSERT(!iTable);

 	iTable=aTable;

 	iInlineLimit=TRecordSize::InlineLimit(aNewSet);

 	iRecords=&iTable->StoreRecordsL();

 	iCluster=iRecords->Head();

 //

 // Calculate the maximum possible expansion, based on the changes to the column set

 // Currently the only alloed change which affects this is Text->LongText type changes

 // these all add a single bit

 //

 	TInt expand=0;

 	const HDbColumnSet& columns=iTable->Def().Columns();

 	const HDbColumnSet::TIteratorC end=columns.End();

 	HDbColumnSet::TIteratorC col=columns.Begin();

 	do

 		{

 		if (col->iFlags&TDbColumnDef::EChangedType)

 			{

 			__ASSERT(col->iType>=EDbColText8&&col->iType<=EDbColBinary);

 			++expand;

 			}

 		} while (++col<end);

 	iExpansion=(expand+7)>>3;

 	}

 TInt CDbStoreTable::CAlter::StepL(TInt aStep)

 //

 // Do some steps to alter the table data

 //

 	{

 	__ASSERT(iTable);

 	iStep=aStep;

 	iCluster=iRecords->AlterL(iCluster,*this);

 	return iCluster==KNullClusterId ? 0 : Max(iStep,1);

 	}

 TUint8* CDbStoreTable::CAlter::AlterRecordL(TUint8* aWPtr,const TUint8* aRPtr,TInt aLength)

 //

 // providing for CClusterCache::MAlter

 // re-write the record

 //

 	{

 	--iStep;

 	return iTable->AlterRecordL(aWPtr,aRPtr,aLength,iInlineLimit);

 	}

 TInt CDbStoreTable::CAlter::RecordExpansion(const TUint8*,TInt)

 //

 // providing for CClusterCache::MAlter

 // just return the maximum possible expansion, rather than a record-specific one

 //

 	{

 	return iExpansion;

 	}